PC Online 1997 November/PCO1197.ISO/FilesBBS/WIN95/NET_COM/N32E403.EXE/nav40l.z/java40.jar/netscape/security/PrivilegeManager.class

Java Class File | 1997-09-04 | 17.0 KB | 1,245 lines

package netscape.security;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import netscape.util.Archive;
import netscape.util.Archiver;
import netscape.util.CodingException;
import netscape.util.Enumeration;
import netscape.util.Hashtable;
import netscape.util.Unarchiver;

public final class PrivilegeManager {
   public static final int PROPER_SUBSET = -1;
   public static final int EQUAL = 0;
   public static final int NO_SUBSET = 1;
   public static final int SIGNED_APPLET_DBNAME = 1;
   public static final int TEMP_FILENAME = 2;
   private Hashtable itsPrinToPrivTable = new Hashtable();
   private Hashtable itsPrinToMacroTargetPrivTable = new Hashtable();
   private static Principal theSystemPrincipal;
   private static Principal[] theSystemPrincipalAry;
   private static Target theSystemTarget;
   private static boolean theSecurityInited;
   private static Principal theUnsignedPrincipal;
   private static Principal[] theUnsignedPrincipalAry;
   private static Principal theUnknownPrincipal;
   private static Principal[] theUnknownPrincipalAry;
   static Object UpdateLock = new Object();
   private static String SignedAppletDBName = null;

   private static native void initClass();

   private static void init() {
      try {
         theSystemPrincipal = Principal.createSystemPrincipal();
      } catch (IllegalArgumentException var0) {
         theSystemPrincipal = new Principal(12, "52:54:45:4e:4e:45:54:49");
      }

      theSystemPrincipalAry = new Principal[1];
      theSystemPrincipalAry[0] = theSystemPrincipal;
      theSystemTarget = Target.findTarget("SuperUser", theSystemPrincipal);
      theUnsignedPrincipal = new Principal(12, "4a:52:4f:53:4b:49:4e:44");
      theUnsignedPrincipalAry = new Principal[1];
      theUnsignedPrincipalAry[0] = theUnsignedPrincipal;
      theUnknownPrincipal = new Principal(12, "52:4f:53:4b:49:4e:44:4a");
      theUnknownPrincipalAry = new Principal[1];
      theUnknownPrincipalAry[0] = theUnknownPrincipal;
   }

   public PrivilegeManager() {
      this.itsPrinToPrivTable.put(getSystemPrincipal(), new SystemPrivilegeTable());
      this.itsPrinToMacroTargetPrivTable.put(getSystemPrincipal(), new SystemPrivilegeTable());
      initClass();
      this.load();
      if (this.isJavaSecurityDefaultTo30Enabled()) {
         Target var1 = Target.findTarget("30Capabilities", getSystemPrincipal());
         Privilege var2 = Privilege.findPrivilege(1, 1);
         this.registerPrincipalAndSetPrivileges(theUnsignedPrincipal, var1, var2);
      }

   }

   private void registerPrincipal(Principal var1) {
      Hashtable var2 = this.itsPrinToPrivTable;
      synchronized(var2){}

      try {
         if (this.itsPrinToPrivTable.get(var1) == null) {
            this.itsPrinToPrivTable.put(var1, new PrivilegeTable());
         }
      } catch (Throwable var8) {
         throw var8;
      }

      var2 = this.itsPrinToMacroTargetPrivTable;
      synchronized(var2){}

      try {
         if (this.itsPrinToMacroTargetPrivTable.get(var1) == null) {
            this.itsPrinToMacroTargetPrivTable.put(var1, new PrivilegeTable());
         }
      } catch (Throwable var7) {
         throw var7;
      }

   }

   private void unregisterPrincipal(Principal var1) {
      if (getSystemPrincipal().equals(var1)) {
         throw new ForbiddenTargetException("Can not delete system principal");
      } else {
         Hashtable var3 = this.itsPrinToPrivTable;
         synchronized(var3){}

         try {
            Object var2 = this.itsPrinToPrivTable.remove(var1);
            if (var2 == null) {
               throw new ForbiddenTargetException("Couldn't delete principal");
            }
         } catch (Throwable var9) {
            throw var9;
         }

         var3 = this.itsPrinToMacroTargetPrivTable;
         synchronized(var3){}

         try {
            Object var10 = this.itsPrinToMacroTargetPrivTable.remove(var1);
            if (var10 == null) {
               throw new ForbiddenTargetException("Couldn't delete principal");
            }
         } catch (Throwable var8) {
            throw var8;
         }

      }
   }

   private native boolean checkPrivilegeEnabled(Target[] var1, int var2, Object var3, boolean var4);

   public void checkPrivilegeEnabled(Target var1) {
      Target[] var2 = new Target[]{var1};
      this.checkPrivilegeEnabled(var2, 1, (Object)null, true);
   }

   public void checkPrivilegeEnabled(Target var1, Object var2) {
      Target[] var3 = new Target[]{var1};
      this.checkPrivilegeEnabled(var3, 1, var2, true);
   }

   public static void checkPrivilegeEnabled(String var0) {
      PrivilegeManager var1 = getPrivilegeManager();
      if (var1 == null) {
         throw new ForbiddenTargetException("access to target denied");
      } else {
         Target[] var2 = new Target[]{Target.findTarget(var0)};
         if (var2[0] == null) {
            throw new ForbiddenTargetException(var0 + " target not found");
         } else {
            var1.checkPrivilegeEnabled(var2, 1, (Object)null, true);
         }
      }
   }

   boolean isPrivilegeEnabled(Target var1, int var2) {
      Target[] var3 = new Target[]{var1};
      return this.isPrivilegeEnabled(var3, var2 + 1, (Object)null);
   }

   boolean isPrivilegeEnabled(Target[] var1, int var2, Object var3) {
      int var4 = var1.length;

      while(var4-- > 0) {
         if (var1[var4] == null) {
            throw new ForbiddenTargetException("Null target is passed.");
         }
      }

      return this.checkPrivilegeEnabled(var1, var2 + 1, var3, false);
   }

   public static void enablePrivilege(String var0) {
      PrivilegeManager var1 = getPrivilegeManager();
      if (var1 == null) {
         throw new ForbiddenTargetException("access to target denied");
      } else {
         Target var2 = Target.findTarget(var0);
         if (var2 == null) {
            throw new ForbiddenTargetException(var0 + " target not found");
         } else {
            var1.enablePrincipalPrivilegeHelper(var2, 1, (Principal)null, (Object)null);
            var1.enableScopePrivilegeHelper(var2, 1, (Object)null, false, (Principal)null);
         }
      }
   }

   public void enablePrivilege(Target var1) {
      this.enablePrincipalPrivilegeHelper(var1, 1, (Principal)null, (Object)null);
      this.enableScopePrivilegeHelper(var1, 1, (Object)null, false, (Principal)null);
   }

   public void enablePrivilege(Target var1, Principal var2) {
      this.enablePrincipalPrivilegeHelper(var1, 1, var2, (Object)null);
      this.enableScopePrivilegeHelper(var1, 1, (Object)null, false, var2);
   }

   public void enablePrivilege(Target var1, Principal var2, Object var3) {
      this.enablePrincipalPrivilegeHelper(var1, 1, var2, var3);
      this.enableScopePrivilegeHelper(var1, 1, var3, false, var2);
   }

   void enablePrivilege(String var1, int var2) {
      Target var3 = Target.findTarget(var1);
      if (var3 == null) {
         throw new ForbiddenTargetException(var1 + " target not found");
      } else {
         this.enablePrincipalPrivilegeHelper(var3, var2 + 1, (Principal)null, (Object)null);
         this.enableScopePrivilegeHelper(var3, var2 + 1, (Object)null, false, (Principal)null);
      }
   }

   Object setScopePrivilegeAssistant(int var1) {
      return this.enableScopePrivilegeHelper(theSystemTarget, var1 + 1, (Object)null, true, (Principal)null);
   }

   Object setScopePrivilegeAssistant(int var1, String var2) {
      Target var3 = Target.findTarget(var2);
      if (var3 == null) {
         throw new ForbiddenTargetException(var2 + " target not found");
      } else {
         this.enablePrincipalPrivilegeHelper(var3, var1 + 1, (Principal)null, (Object)null);
         return this.enableScopePrivilegeHelper(var3, var1 + 1, (Object)null, true, (Principal)null);
      }
   }

   private void enablePrincipalPrivilegeHelper(Target var1, int var2, Principal var3, Object var4) {
      Principal var6 = null;
      Principal[] var5 = this.getClassPrincipalsFromStackUnsafeJava(var2 + 1);
      if (var3 != null) {
         int var7 = var5.length;

         while(var7-- > 0) {
            if (var5[var7].equals(var3) && (var5[var7].isCert() || var5[var7].isCertFingerprint())) {
               var6 = var5[var7];
               break;
            }
         }

         if (var6 == null) {
            Target var8 = Target.findTarget("Impersonator");
            this.checkPrivilegeEnabled(var8);
            var6 = var3;
            var5 = new Principal[]{var3};
         }
      }

      if (!this.isPermissionGranted(var1, var5, var4)) {
         if (var6 == null) {
            if (var5.length == 0) {
               throw new ForbiddenTargetException("request's caller has no principal!");
            }

            var6 = var5[0];
         }

         Object var13 = UpdateLock;
         synchronized(var13){}

         try {
            if (!this.isPermissionGranted(var1, var5, var4)) {
               Privilege var12 = var1.enablePrivilege(var6, var4);
               if (!var12.isAllowed() && var12.getDuration() == 1) {
                  throw new ForbiddenTargetException("User didn't grant the " + var1.getName() + " privilege.");
               }

               this.registerPrincipalAndSetPrivileges(var6, var1, var12);
               if (var6.savePrincipalPermanently() && var12.getDuration() == 2 && !var6.equals(theUnsignedPrincipal)) {
                  this.save();
               }

               if (!var12.isForbidden()) {
                  return;
               }

               throw new ForbiddenTargetException("User didn't grant the " + var1.getName() + " privilege.");
            }
         } catch (Throwable var11) {
            throw var11;
         }

      }
   }

   private boolean isPermissionGranted(Target var1, Principal[] var2, Object var3) {
      int var4 = this.getPrincipalPrivilege(var1, var2, var3);
      switch (var4) {
         case 0:
         default:
            throw new ForbiddenTargetException("access to target denied");
         case 1:
            return true;
         case 2:
            return false;
      }
   }

   private Object enableScopePrivilegeHelper(Target var1, int var2, Object var3, boolean var4, Principal var5) {
      if (var5 != null) {
         this.checkPrivilegeGranted(var1, var5, var3);
      } else {
         this.checkPrivilegeGranted(var1, var2 + 1, var3);
      }

      PrivilegeTable var6 = this.getPrivilegeTableFromStackUnsafe(var2 + 1, !var4);
      if (var4) {
         if (var6 != null) {
            var6 = (PrivilegeTable)var6.clone();
         } else {
            var6 = new PrivilegeTable();
         }
      }

      Privilege var7 = Privilege.findPrivilege(1, 0);
      this.updatePrivilegeTable(var1, var6, var7);
      return var6;
   }

   private void registerPrincipalAndSetPrivileges(Principal var1, Target var2, Privilege var3) {
      this.registerPrincipal(var1);
      PrivilegeTable var4 = (PrivilegeTable)this.itsPrinToMacroTargetPrivTable.get(var1);
      var4.put(var2, var3);
      var4 = (PrivilegeTable)this.itsPrinToPrivTable.get(var1);
      this.updatePrivilegeTable(var2, var4, var3);
   }

   private void updatePrivilegeTable(Target var1, PrivilegeTable var2, Privilege var3) {
      Target[] var4 = var1.getFlattenedTargetAryUnsafe();
      synchronized(var2){}

      try {
         for(int var8 = var4.length; var8-- > 0; var2.put(var4[var8], var3)) {
            Privilege var5 = var2.get(var4[var8]);
            if (var5 != null) {
               var3 = Privilege.add(var5, var3);
            }
         }
      } catch (Throwable var10) {
         throw var10;
      }

   }

   public void revertPrivilege(Target var1) {
      this.revertPrivilege(var1, 1);
   }

   public static void revertPrivilege(String var0) {
      PrivilegeManager var1 = getPrivilegeManager();
      if (var1 == null) {
         throw new ForbiddenTargetException("access to target denied");
      } else {
         Target var2 = Target.findTarget(var0);
         if (var2 == null) {
            throw new ForbiddenTargetException(var0 + " target not found");
         } else {
            var1.revertPrivilege(var2, 1);
         }
      }
   }

   void revertPrivilege() {
      PrivilegeTable var1 = this.getPrivilegeTableFromStackUnsafe(1, true);
      synchronized(var1){}

      try {
         var1.clear();
      } catch (Throwable var4) {
         throw var4;
      }

   }

   private void revertPrivilege(Target var1, int var2) {
      PrivilegeTable var3 = this.getPrivilegeTableFromStackUnsafe(var2 + 1, true);
      synchronized(var3){}

      try {
         var3.put(var1, Privilege.findPrivilege(2, 0));
      } catch (Throwable var6) {
         throw var6;
      }

   }

   public void disablePrivilege(Target var1) {
      this.disablePrivilege(var1, 1);
   }

   public static void disablePrivilege(String var0) {
      PrivilegeManager var1 = getPrivilegeManager();
      if (var1 == null) {
         throw new ForbiddenTargetException("access to target denied");
      } else {
         Target var2 = Target.findTarget(var0);
         if (var2 == null) {
            throw new ForbiddenTargetException(var0 + " target not found");
         } else {
            var1.disablePrivilege(var2, 1);
         }
      }
   }

   private void disablePrivilege(Target var1, int var2) {
      PrivilegeTable var3 = this.getPrivilegeTableFromStackUnsafe(var2 + 1, true);
      var3.put(var1, Privilege.findPrivilege(0, 0));
   }

   private int getPrincipalPrivilege(Target var1, int var2) {
      return this.getPrincipalPrivilege(var1, var2 + 1, (Object)null);
   }

   private int getPrincipalPrivilege(Target var1, Principal[] var2) {
      return this.getPrincipalPrivilege(var1, (Principal[])var2, (Object)null);
   }

   private int getPrincipalPrivilege(Target var1, int var2, Object var3) {
      Principal[] var4 = this.getClassPrincipalsFromStackUnsafeJava(var2 + 1);
      return this.getPrincipalPrivilege(var1, var4, var3);
   }

   private int getPrincipalPrivilege(Target var1, Principal[] var2, Object var3) {
      boolean var5 = false;
      int var6 = var2.length;

      while(var6-- > 0) {
         Privilege var4 = this.getPrincipalPrivilege(var1, var2[var6], var3);
         if (var4 != null) {
            switch (var4.getPermission()) {
               case 0:
               default:
                  return 0;
               case 1:
                  var5 = true;
               case 2:
            }
         }
      }

      if (var5) {
         return 1;
      } else {
         return 2;
      }
   }

   Privilege getPrincipalPrivilege(Target var1, Principal var2, Object var3) {
      PrivilegeTable var4 = (PrivilegeTable)this.itsPrinToPrivTable.get(var2);
      if (var4 == null) {
         return null;
      } else {
         Privilege var5;
         if (var1 instanceof ParameterizedTarget) {
            ParameterizedTarget var6 = (ParameterizedTarget)var1;
            var5 = var6.getPrincipalPrivilege(var2, var3);
         } else {
            var5 = var4.get(var1);
         }

         return var5;
      }
   }

   public static void checkPrivilegeGranted(String var0) {
      PrivilegeManager var1 = getPrivilegeManager();
      if (var1 == null) {
         throw new ForbiddenTargetException("access to target denied");
      } else {
         Target var2 = Target.findTarget(var0);
         if (var2 == null) {
            throw new ForbiddenTargetException(var0 + " target not found");
         } else {
            var1.checkPrivilegeGranted(var2, 1, (Object)null);
         }
      }
   }

   public void checkPrivilegeGranted(Target var1) {
      this.checkPrivilegeGranted(var1, 1, (Object)null);
   }

   private void checkPrivilegeGranted(Target var1, int var2) {
      this.checkPrivilegeGranted(var1, var2 + 1, (Object)null);
   }

   public void checkPrivilegeGranted(Target var1, Object var2) {
      this.checkPrivilegeGranted(var1, 1, var2);
   }

   private void checkPrivilegeGranted(Target var1, int var2, Object var3) {
      int var4 = this.getPrincipalPrivilege(var1, var2 + 1, var3);
      if (var4 != 1) {
         throw new ForbiddenTargetException("access to target denied");
      }
   }

   public void checkPrivilegeGranted(Target var1, Principal var2, Object var3) {
      Principal[] var4 = new Principal[]{var2};
      int var5 = this.getPrincipalPrivilege(var1, var4, var3);
      if (var5 != 1) {
         throw new ForbiddenTargetException("access to target denied");
      }
   }

   public boolean isCalledByPrincipal(Principal var1, int var2) {
      Principal[] var3 = this.getClassPrincipalsFromStackUnsafeJava(var2 + 1);
      int var4 = var3.length;

      while(var4-- > 0) {
         if (var3[var4].equals(var1)) {
            return true;
         }
      }

      return false;
   }

   public boolean isCalledByPrincipal(Principal var1) {
      return this.isCalledByPrincipal(var1, 2);
   }

   public static Principal getSystemPrincipal() {
      if (theSystemPrincipal == null) {
         init();
      }

      return theSystemPrincipal;
   }

   public static PrivilegeManager getPrivilegeManager() {
      return AppletSecurity.getPrivilegeManager();
   }

   private static Principal[] getSystemPrincipals() {
      try {
         return (Principal[])theSystemPrincipalAry.clone();
      } catch (CloneNotSupportedException var0) {
         throw new ForbiddenTargetException("internal error: unable to clone System Principal");
      }
   }

   private static Principal[] getSystemPrincipalsUnsafe() {
      return theSystemPrincipalAry;
   }

   private static Principal[] getUnsignedPrincipalArray() {
      try {
         return (Principal[])theUnsignedPrincipalAry.clone();
      } catch (CloneNotSupportedException var0) {
         throw new ForbiddenTargetException("internal error: unable to clone Unsigned Principal");
      }
   }

   private static Principal[] getUnsignedPrincipalsUnsafe() {
      return theUnsignedPrincipalAry;
   }

   static Principal getUnsignedPrincipal() {
      return theUnsignedPrincipal;
   }

   private static Principal[] getUnknownPrincipalArrayUnsafe() {
      return theUnknownPrincipalAry;
   }

   static Principal[] getUnknownPrincipalArray() {
      try {
         return (Principal[])theUnknownPrincipalAry.clone();
      } catch (CloneNotSupportedException var0) {
         throw new ForbiddenTargetException("internal error: unable to clone Unknown Principal");
      }
   }

   static Principal getUnknownPrincipal() {
      return theUnknownPrincipal;
   }

   public static Principal[] getMyPrincipals() {
      PrivilegeManager var0 = getPrivilegeManager();
      return var0 == null ? null : var0.getClassPrincipalsFromStack(1);
   }

   public Principal[] getClassPrincipals(Class var1) {
      Principal[] var2 = this.getClassPrincipalsUnsafeJava(var1);

      try {
         return (Principal[])var2.clone();
      } catch (CloneNotSupportedException var3) {
         throw new ForbiddenTargetException("internal error: unable to clone Principal");
      }
   }

   public boolean hasPrincipal(Class var1, Principal var2) {
      Principal[] var3 = this.getClassPrincipalsUnsafeJava(var1);
      int var4 = var3.length;

      while(var4-- > 0) {
         if (var3[var4].equals(var2)) {
            return true;
         }
      }

      return false;
   }

   public int comparePrincipalArray(Principal[] var1, Principal[] var2) {
      Hashtable var3 = new Hashtable();
      Integer var4 = new Integer(1);
      Integer var5 = new Integer(0);
      int var8 = var2.length;

      while(var8-- > 0) {
         var3.put(var2[var8], var4);
      }

      int var9 = var1.length;

      while(var9-- > 0) {
         Principal var7 = var1[var9];
         Integer var6 = (Integer)var3.get(var7);
         if (var6 == null) {
            return 1;
         }

         if (var6 == var4) {
            var3.put(var7, var5);
         }
      }

      Enumeration var10 = var3.keys();

      while(var10.hasMoreElements()) {
         Object var12 = var10.nextElement();
         Integer var11 = (Integer)var3.get(var12);
         if (var11 == var4) {
            return -1;
         }
      }

      return 0;
   }

   public Principal[] intersectPrincipalArray(Principal[] var1, Principal[] var2) {
      boolean[] var3 = new boolean[var1.length];
      int var4 = 0;

      for(int var5 = 0; var5 < var1.length; ++var5) {
         for(int var6 = 0; var6 < var2.length; ++var6) {
            if (var1[var5].equals(var2[var6])) {
               var3[var5] = true;
               ++var4;
               break;
            }
         }
      }

      Principal[] var9 = new Principal[var4];
      int var7 = 0;

      for(int var8 = 0; var8 < var3.length; ++var8) {
         if (var3[var8]) {
            var9[var7++] = var1[var8];
         }
      }

      return var9;
   }

   public boolean canExtendTrust(Principal[] var1, Principal[] var2) {
      Principal[] var3 = this.intersectPrincipalArray(var1, var2);
      if (var3.length == var1.length) {
         return true;
      } else if (var3.length != 0 && var3.length == var1.length - 1) {
         for(int var4 = 0; var4 < var3.length; ++var4) {
            if (var3[var4].isCodebase()) {
               return false;
            }
         }

         int var5 = 0;

         for(int var6 = 0; var6 < var1.length; ++var6) {
            if (var1[var6].isCodebase()) {
               ++var5;
            }
         }

         if (var5 != 1) {
            return false;
         } else {
            return true;
         }
      } else {
         return false;
      }
   }

   public boolean checkMatchPrincipal(Class var1, int var2) {
      return this.comparePrincipalArray(this.getClassPrincipalsFromStack(var2 + 1), this.getClassPrincipalsUnsafeJava(var1)) != 1;
   }

   public boolean checkMatchPrincipal(Principal var1, int var2) {
      Principal[] var3 = new Principal[]{var1};
      return this.comparePrincipalArray(var3, this.getClassPrincipalsFromStack(var2 + 1)) != 1;
   }

   public boolean checkMatchPrincipal(Class var1) {
      return this.checkMatchPrincipal((Class)var1, 1);
   }

   public boolean checkMatchPrincipalAlways() {
      return SecurityManager.checksMatchPrincipalAlways(1);
   }

   public Principal[] getClassPrincipalsFromStack(int var1) {
      Principal[] var2 = this.getClassPrincipalsFromStackUnsafeJava(var1 + 1);

      try {
         return (Principal[])var2.clone();
      } catch (CloneNotSupportedException var3) {
         throw new ForbiddenTargetException("internal error: unable to clone Principal");
      }
   }

   private Principal[] getClassPrincipalsFromStackUnsafeJava(int var1) {
      Principal[] var2 = this.getClassPrincipalsFromStackUnsafe(var1 + 1);
      if (var2 == null) {
         if (!this.getJavaSecurityEnabled()) {
            System.out.println("Java Navigator Beta internal error message: Defaulting to system principal");
            return getSystemPrincipalsUnsafe();
         } else {
            return getUnknownPrincipalArray();
         }
      } else {
         return var2;
      }
   }

   private Principal[] getClassPrincipalsUnsafeJava(Class var1) {
      Principal[] var2 = this.getClassPrincipalsUnsafe(var1);
      if (var2 == null) {
         if (!this.getJavaSecurityEnabled()) {
            System.out.println("Java Navigator Beta internal error message: Defaulting to system principal");
            return getSystemPrincipalsUnsafe();
         } else {
            return getUnknownPrincipalArray();
         }
      } else {
         return var2;
      }
   }

   PrivilegeTable getPrivilegeTableFromStack(int var1) {
      PrivilegeTable var2 = this.getPrivilegeTableFromStackUnsafe(var1 + 1, false);
      return var2 == null ? null : (PrivilegeTable)var2.clone();
   }

   public PrivilegeTable getPrivilegeTableFromStack() {
      return this.getPrivilegeTableFromStack(2);
   }

   private native Principal[] getClassPrincipalsFromStackUnsafe(int var1);

   private native Principal[] getClassPrincipalsUnsafe(Class var1);

   private native PrivilegeTable getPrivilegeTableFromStackUnsafe(int var1, boolean var2);

   native boolean getJavaSecurityEnabled();

   synchronized native int getPrivilegeFromUser(String var1, String var2, String var3, boolean var4);

   native boolean showDocument(String var1, String var2);

   native boolean isJavaSecurityDefaultTo30Enabled();

   native boolean getBoolPref(String var1);

   private native String getWHFileName(String var1, int var2);

   native boolean picsCanUserEnableAdditionalJavaCapabilities();

   Principal[] getAllPrincipals() {
      int var1 = 0;
      Hashtable var6 = this.itsPrinToMacroTargetPrivTable;
      synchronized(var6){}

      Object var5;
      try {
         int var8 = this.itsPrinToMacroTargetPrivTable.size();
         if (var8 != 0) {
            Principal[] var2 = new Principal[var8];

            Principal var4;
            for(Enumeration var3 = this.itsPrinToMacroTargetPrivTable.keys(); var3.hasMoreElements(); var2[var1++] = var4) {
               var4 = (Principal)var3.nextElement();
            }

            return var2;
         }

         var5 = null;
      } catch (Throwable var10) {
         throw var10;
      }

      return (Principal[])var5;
   }

   static String getAllPrincipalsString() {
      PrivilegeManager var0 = getPrivilegeManager();
      if (var0 == null) {
         return null;
      } else {
         Principal[] var1 = var0.getAllPrincipals();
         if (var1 == null) {
            return null;
         } else {
            boolean var2 = true;
            StringBuffer var3 = new StringBuffer();
            int var4 = var1.length;

            while(var4-- > 0) {
               if (var0.principalHasPrivileges(var1[var4])) {
                  if (var2) {
                     var3.append("\"" + var1[var4].toString() + "\"");
                     var2 = false;
                  } else {
                     var3.append(",\"" + var1[var4].toString() + "\"");
                  }
               }
            }

            if (var2) {
               return null;
            } else {
               return var3.toString();
            }
         }
      }
   }

   private Principal getPrincipalFromString(String var1) {
      Principal[] var2 = this.getAllPrincipals();
      if (var2 == null) {
         return null;
      } else {
         int var3 = var2.length;

         while(var3-- > 0) {
            if (var1.equals(var2[var3].toString())) {
               return var2[var3];
            }
         }

         return null;
      }
   }

   boolean principalHasPrivileges(Principal var1) {
      Hashtable var3 = this.itsPrinToMacroTargetPrivTable;
      synchronized(var3){}

      PrivilegeTable var2;
      try {
         var2 = (PrivilegeTable)this.itsPrinToMacroTargetPrivTable.get(var1);
      } catch (Throwable var5) {
         throw var5;
      }

      return var2 != null && var2.size() != 0;
   }

   static String[] getTargetsWithPrivileges(String var0) {
      PrivilegeManager var1 = getPrivilegeManager();
      if (var1 == null) {
         return null;
      } else {
         Principal var2 = var1.getPrincipalFromString(var0);
         if (var2 == null) {
            return null;
         } else {
            StringBuffer var8 = new StringBuffer();
            StringBuffer var9 = new StringBuffer();
            StringBuffer var10 = new StringBuffer();
            String[] var11 = new String[3];
            Hashtable var12 = var1.itsPrinToMacroTargetPrivTable;
            synchronized(var12){}

            PrivilegeTable var3;
            try {
               var3 = (PrivilegeTable)var1.itsPrinToMacroTargetPrivTable.get(var2);
            } catch (Throwable var14) {
               throw var14;
            }

            Enumeration var6 = var3.keys();

            while(var6.hasMoreElements()) {
               Target var4 = (Target)var6.nextElement();
               Privilege var5 = var3.get(var4);
               String var7 = var4.getDescription();
               if (var5.isAllowed()) {
                  if (var5.getDuration() == 2) {
                     var8.append("<option>" + var7);
                  } else {
                     var9.append("<option>" + var7);
                  }
               } else if (var5.isForbidden()) {
                  var10.append("<option>" + var7);
               }
            }

            var11[0] = var8.toString();
            var11[1] = var9.toString();
            var11[2] = var10.toString();
            return var11;
         }
      }
   }

   private Target getTargetFromString(Principal var1, String var2) {
      PrivilegeTable var3 = (PrivilegeTable)this.itsPrinToMacroTargetPrivTable.get(var1);
      Enumeration var5 = var3.keys();

      while(var5.hasMoreElements()) {
         Target var4 = (Target)var5.nextElement();
         if (var2.equals(var4.getDescription())) {
            return var4;
         }
      }

      return null;
   }

   static String[] getTargetDetails(String var0) {
      PrivilegeManager var1 = getPrivilegeManager();
      if (var1 == null) {
         return null;
      } else {
         Target var2 = Target.getTargetFromDescription(var0);
         if (var2 == null) {
            return null;
         } else {
            StringBuffer var3 = new StringBuffer();
            Target[] var4 = var2.getFlattenedTargetAryUnsafe();
            int var5 = var4.length;

            while(var5-- > 0) {
               var3.append("<option>" + var4[var5].getDescription() + " (" + var4[var5].getRisk() + ")");
            }

            String[] var6 = new String[]{var3.toString(), var2.getRisk()};
            return var6;
         }
      }
   }

   static boolean removePrincipal(String var0) {
      PrivilegeManager var1 = getPrivilegeManager();
      if (var1 == null) {
         return false;
      } else {
         Principal var2 = var1.getPrincipalFromString(var0);
         if (var2 == null) {
            return false;
         } else {
            try {
               var1.removeAllParameterizedTargets(var2);
               var1.unregisterPrincipal(var2);
            } catch (Exception var4) {
               System.out.println("Unable to delete principal " + var2 + " " + var4);
               ((Throwable)var4).printStackTrace(System.out);
               return false;
            }

            var1.save();
            return true;
         }
      }
   }

   static boolean removePrincipalsPrivilege(String var0, String var1) {
      PrivilegeManager var2 = getPrivilegeManager();
      if (var2 == null) {
         return false;
      } else {
         Principal var3 = var2.getPrincipalFromString(var0);
         if (var3 == null) {
            return false;
         } else {
            Target var4 = var2.getTargetFromString(var3, var1);
            if (var4 == null) {
               return false;
            } else {
               Hashtable var9 = var2.itsPrinToMacroTargetPrivTable;
               synchronized(var9){}

               PrivilegeTable var6;
               try {
                  var6 = (PrivilegeTable)var2.itsPrinToMacroTargetPrivTable.get(var3);
                  if (var4 instanceof ParameterizedTarget) {
                     ParameterizedTarget var11 = (ParameterizedTarget)var4;
                     var11.unregisterPrincipal(var3);
                  }

                  var6.remove(var4);
               } catch (Throwable var17) {
                  throw var17;
               }

               var9 = var2.itsPrinToPrivTable;
               synchronized(var9){}

               try {
                  PrivilegeTable var19 = new PrivilegeTable();
                  var2.itsPrinToPrivTable.put(var3, var19);
                  Enumeration var5 = var6.keys();

                  while(var5.hasMoreElements()) {
                     Target var8 = (Target)var5.nextElement();
                     Privilege var7 = var6.get(var8);
                     var2.updatePrivilegeTable(var8, var19, var7);
                  }
               } catch (Throwable var16) {
                  throw var16;
               }

               var2.save();
               return true;
            }
         }
      }
   }

   void removeAllParameterizedTargets(Principal var1) {
      Hashtable var5 = this.itsPrinToPrivTable;
      synchronized(var5){}

      try {
         PrivilegeTable var3 = (PrivilegeTable)this.itsPrinToPrivTable.get(var1);
         Enumeration var2 = var3.keys();

         while(var2.hasMoreElements()) {
            Target var4 = (Target)var2.nextElement();
            if (var4 instanceof ParameterizedTarget) {
               ParameterizedTarget var7 = (ParameterizedTarget)var4;
               var7.unregisterPrincipal(var1);
            }
         }
      } catch (Throwable var9) {
         throw var9;
      }

   }

   String getArchiveFileName() {
      if (SignedAppletDBName == null) {
         SignedAppletDBName = this.getWHFileName("", 1);
      }

      return SignedAppletDBName;
   }

   String getArchiveFileName(String var1) {
      return this.getWHFileName(var1, 1);
   }

   private synchronized void save() {
      SecurityManager.enablePrivilege("UniversalFileWrite");
      String var2 = this.getArchiveFileName();

      FileOutputStream var1;
      try {
         var1 = new FileOutputStream(var2);
      } catch (FileNotFoundException var6) {
         System.err.println("Error1: can't open <" + var2 + "> to save java capabilities list");
         return;
      } catch (IOException var7) {
         System.err.println("Error2: can't open <" + var2 + "> to save java capabilities list");
         return;
      }

      try {
         this.save(var1);
      } catch (Exception var5) {
         System.err.println("Error: unable to save java capabilities list into <" + var2 + "> " + var5);
      }

      try {
         var1.close();
      } catch (IOException var4) {
         System.err.println("Error while saving java capabilities list into <" + var2 + ">");
      }
   }

   private void save(OutputStream var1) {
      Hashtable var10 = new Hashtable();
      Enumeration var4 = this.itsPrinToMacroTargetPrivTable.keys();

      while(var4.hasMoreElements()) {
         Principal var7 = (Principal)var4.nextElement();
         PrivilegeTable var6 = (PrivilegeTable)this.itsPrinToMacroTargetPrivTable.get(var7);
         synchronized(var6){}

         try {
            PrivilegeTable var11 = new PrivilegeTable();
            Enumeration var5 = var6.keys();

            while(var5.hasMoreElements()) {
               Target var9 = (Target)var5.nextElement();
               Privilege var8 = var6.get(var9);
               switch (var8.getDuration()) {
                  case 2:
                     var11.put(var9, var8);
               }
            }

            if (var11.size() > 0) {
               var10.put(var7, var11);
            }
         } catch (Throwable var18) {
            throw var18;
         }
      }

      Archive var2 = new Archive();
      Archiver var3 = new Archiver(var2);

      try {
         var3.archiveRootObject(var10);
      } catch (CodingException var17) {
         System.err.println("Internal error during archiving of Capabilities");
         ((Throwable)var17).printStackTrace(System.out);
         return;
      }

      try {
         var2.write(var1);
      } catch (Exception var16) {
         System.err.println("Error during serializing java Capabilities " + var16);
      }
   }

   boolean isSecurityInited() {
      return theSecurityInited;
   }

   private synchronized void load() {
      if (!theSecurityInited) {
         Object var1 = null;
         String var2 = this.getArchiveFileName();
         SecurityManager.enablePrivilege("UniversalFileRead");

         try {
            var6 = new FileInputStream(var2);
         } catch (Exception var5) {
            var6 = null;
         }

         if (var6 == null) {
            var2 = this.getArchiveFileName("0");

            try {
               var6 = new FileInputStream(var2);
            } catch (Exception var4) {
               return;
            }
         }

         this.load(var6);

         try {
            var6.close();
         } catch (IOException var3) {
            System.err.println("Error while reading java Capabilities file <" + var2 + ">");
            return;
         }

         theSecurityInited = true;
      }
   }

   private void load(InputStream var1) {
      Object var5 = null;
      Archive var2 = new Archive();

      try {
         var2.read(var1);
      } catch (Exception var17) {
         System.err.println("Error: unable to read java Capabilities from archive " + var17);
         return;
      }

      int[] var18 = var2.rootIdentifiers();
      Unarchiver var3 = new Unarchiver(var2);

      Object var4;
      try {
         var4 = var3.unarchiveIdentifier(var18[0]);
      } catch (Exception var16) {
         System.err.println("Error: old java capabilites list was lost " + var16);
         return;
      }

      if (var4 != null) {
         Hashtable var12 = (Hashtable)var4;
         Enumeration var6 = var12.keys();

         while(var6.hasMoreElements()) {
            Principal var14 = (Principal)var6.nextElement();
            PrivilegeTable var13 = (PrivilegeTable)var12.get(var14);
            this.registerPrincipal(var14);
            PrivilegeTable var8 = (PrivilegeTable)this.itsPrinToMacroTargetPrivTable.get(var14);
            Enumeration var7 = var13.keys();

            while(var7.hasMoreElements()) {
               Target var10 = (Target)var7.nextElement();
               Privilege var9 = var13.get(var10);
               Target var11 = Target.findTarget(var10);
               if (var11 == null) {
                  var11 = var10.registerTarget();
               }

               var9 = Privilege.findPrivilege(var9.getPermission(), var9.getDuration());
               var8.put(var11, var9);
            }
         }

         this.explodePrivilege();
      }
   }

   private void explodePrivilege() {
      Enumeration var1 = this.itsPrinToMacroTargetPrivTable.keys();

      while(var1.hasMoreElements()) {
         Principal var4 = (Principal)var1.nextElement();
         PrivilegeTable var3 = (PrivilegeTable)this.itsPrinToMacroTargetPrivTable.get(var4);
         PrivilegeTable var7 = (PrivilegeTable)this.itsPrinToPrivTable.get(var4);
         Enumeration var2 = var3.keys();

         while(var2.hasMoreElements()) {
            Target var6 = (Target)var2.nextElement();
            Privilege var5 = var3.get(var6);
            this.updatePrivilegeTable(var6, var7, var5);
         }
      }

   }
}