home *** CD-ROM | disk | FTP | other *** search
/ Popular Software (Premium Edition) / mycd.iso / INTERNET / NETSCAP4.06 / CP32E406.EXE / nav40.z / java40.jar / netscape / security / Principal.class (.txt) < prev    next >
Encoding:
Java Class File  |  1998-08-13  |  8.6 KB  |  487 lines
  1. package netscape.security;
  2.  
  3. import java.net.MalformedURLException;
  4. import java.net.URL;
  5. import java.util.StringTokenizer;
  6. import netscape.util.ClassInfo;
  7. import netscape.util.Codable;
  8. import netscape.util.CodingException;
  9. import netscape.util.Decoder;
  10. import netscape.util.Encoder;
  11.  
  12. public final class Principal implements Codable {
  13.    static final int VERSION = 1;
  14.    public static final int CODEBASE_EXACT = 10;
  15.    public static final int CODEBASE_REGEXP = 11;
  16.    public static final int CERT = 12;
  17.    public static final int CERT_FINGERPRINT = 13;
  18.    public static final int CERT_KEY = 14;
  19.    static final int COMPANY_NAME = 1;
  20.    static final int CERT_AUTH = 2;
  21.    static final int SERIAL_NO = 3;
  22.    static final int EXP_DATE = 4;
  23.    static final int NICKNAME = 5;
  24.    static final int FINGERPRINT = 6;
  25.    private int itsType;
  26.    private int itsHashCode;
  27.    private String itsStringRep;
  28.    private byte[] itsBinaryRep;
  29.    private byte[] itsFingerprint;
  30.    private byte[] itsCertKey;
  31.    private int itsZig;
  32.    private boolean itsInited;
  33.    private String itsNickname;
  34.    private String itsAsciiFingerPrint;
  35.    private String itsExpDate;
  36.    private String itsSerialNo;
  37.    private String itsCertAuth;
  38.    private String itsCompanyName;
  39.  
  40.    public Principal() {
  41.       this.itsInited = false;
  42.    }
  43.  
  44.    public Principal(URL var1) {
  45.       this.itsInited = false;
  46.       this.itsStringRep = var1.toString();
  47.       this.itsType = 10;
  48.       this.computeHashCode();
  49.       this.itsZig = 0;
  50.       this.itsInited = true;
  51.    }
  52.  
  53.    public Principal(int var1, String var2) {
  54.       this.itsInited = false;
  55.       switch (var1) {
  56.          case 10:
  57.          case 11:
  58.             this.itsStringRep = var2;
  59.             break;
  60.          case 12:
  61.          case 13:
  62.             StringTokenizer var3 = new StringTokenizer(var2, ":;, \t");
  63.             this.itsBinaryRep = new byte[var3.countTokens()];
  64.  
  65.             for(int var4 = 0; var3.hasMoreElements(); ++var4) {
  66.                this.itsBinaryRep[var4] = (byte)Integer.parseInt(var3.nextToken(), 16);
  67.             }
  68.  
  69.             if (var1 == 12) {
  70.                this.certToFingerprint();
  71.             } else {
  72.                this.itsFingerprint = this.itsBinaryRep;
  73.             }
  74.             break;
  75.          default:
  76.             throw new IllegalArgumentException("unknown principal type");
  77.       }
  78.  
  79.       this.itsType = var1;
  80.       this.computeHashCode();
  81.       this.itsZig = 0;
  82.       this.itsInited = true;
  83.    }
  84.  
  85.    public Principal(int var1, byte[] var2) {
  86.       this.itsInited = false;
  87.       switch (var1) {
  88.          case 10:
  89.          case 11:
  90.             this.itsStringRep = new String(var2, 0);
  91.             break;
  92.          case 12:
  93.          case 13:
  94.          case 14:
  95.             try {
  96.                this.itsBinaryRep = (byte[])var2.clone();
  97.             } catch (CloneNotSupportedException var3) {
  98.                throw new IllegalArgumentException("bogus value");
  99.             }
  100.  
  101.             if (var1 == 12) {
  102.                this.certToFingerprint();
  103.             } else if (var1 == 14) {
  104.                this.itsCertKey = this.itsBinaryRep;
  105.             } else {
  106.                this.itsFingerprint = this.itsBinaryRep;
  107.             }
  108.             break;
  109.          default:
  110.             throw new IllegalArgumentException("unknown principal type");
  111.       }
  112.  
  113.       this.itsType = var1;
  114.       this.computeHashCode();
  115.       this.itsZig = 0;
  116.       this.itsInited = true;
  117.    }
  118.  
  119.    public Principal(int var1, byte[] var2, Class var3) {
  120.       this(var1, var2);
  121.       this.itsZig = getZigPtr(var3);
  122.    }
  123.  
  124.    private boolean compareByteArrays(byte[] var1, byte[] var2) {
  125.       if (var1.length != var2.length) {
  126.          return false;
  127.       } else {
  128.          for(int var3 = 0; var3 < var2.length; ++var3) {
  129.             if (var1[var3] != var2[var3]) {
  130.                return false;
  131.             }
  132.          }
  133.  
  134.          return true;
  135.       }
  136.    }
  137.  
  138.    public boolean equals(Object var1) {
  139.       if (var1 == this) {
  140.          return true;
  141.       } else if (!(var1 instanceof Principal)) {
  142.          return false;
  143.       } else {
  144.          Principal var2 = (Principal)var1;
  145.          switch (this.itsType) {
  146.             case 10:
  147.             case 11:
  148.                switch (var2.itsType) {
  149.                   case 10:
  150.                   case 11:
  151.                      return this.itsStringRep.equals(var2.itsStringRep);
  152.                   default:
  153.                      return false;
  154.                }
  155.             case 12:
  156.             case 13:
  157.                switch (var2.itsType) {
  158.                   case 12:
  159.                   case 13:
  160.                      return this.compareByteArrays(this.itsFingerprint, var2.itsFingerprint);
  161.                   default:
  162.                      return false;
  163.                }
  164.             case 14:
  165.                switch (var2.itsType) {
  166.                   case 14:
  167.                      return this.compareByteArrays(this.itsCertKey, var2.itsCertKey);
  168.                   default:
  169.                      return false;
  170.                }
  171.             default:
  172.                return false;
  173.          }
  174.       }
  175.    }
  176.  
  177.    public int hashCode() {
  178.       return this.itsHashCode;
  179.    }
  180.  
  181.    private int computeHashCode(byte[] var1) {
  182.       int var2 = 0;
  183.  
  184.       for(int var3 = 0; var3 < var1.length; ++var3) {
  185.          var2 = var2 * 37 + var1[var3];
  186.       }
  187.  
  188.       return var2;
  189.    }
  190.  
  191.    private void computeHashCode() {
  192.       switch (this.itsType) {
  193.          case 10:
  194.          case 11:
  195.             this.itsHashCode = this.itsStringRep.hashCode();
  196.             return;
  197.          case 12:
  198.          case 13:
  199.             this.itsHashCode = this.computeHashCode(this.itsFingerprint);
  200.             return;
  201.          case 14:
  202.             this.itsHashCode = this.computeHashCode(this.itsCertKey);
  203.             return;
  204.          default:
  205.       }
  206.    }
  207.  
  208.    public boolean isCodebase() {
  209.       return this.itsType == 10 || this.itsType == 11;
  210.    }
  211.  
  212.    public boolean isCodebaseExact() {
  213.       return this.itsType == 10;
  214.    }
  215.  
  216.    public boolean isCodebaseRegexp() {
  217.       return this.itsType == 11;
  218.    }
  219.  
  220.    boolean isSecurePrincipal() {
  221.       if (this == PrivilegeManager.getUnknownPrincipal()) {
  222.          System.out.println("Principal: Internal Error: Unknown principal");
  223.          return false;
  224.       } else if (!this.isCodebase()) {
  225.          return true;
  226.       } else {
  227.          URL var1;
  228.          try {
  229.             var1 = new URL(this.itsStringRep);
  230.          } catch (MalformedURLException var4) {
  231.             return false;
  232.          }
  233.  
  234.          String var2 = var1.getProtocol();
  235.          if (!var2.equals("https") && !var2.equals("file")) {
  236.             PrivilegeManager var3 = PrivilegeManager.getPrivilegeManager();
  237.             return var2.equals("http") && !var3.getJavaSecurityEnabled();
  238.          } else {
  239.             return true;
  240.          }
  241.       }
  242.    }
  243.  
  244.    public boolean isCert() {
  245.       return this.itsType == 12;
  246.    }
  247.  
  248.    public boolean isCertFingerprint() {
  249.       return this.itsType == 13 || this.itsType == 14;
  250.    }
  251.  
  252.    public String toString() {
  253.       switch (this.itsType) {
  254.          case 10:
  255.          case 11:
  256.             return this.itsStringRep;
  257.          case 12:
  258.          case 13:
  259.             StringBuffer var1 = new StringBuffer();
  260.  
  261.             for(int var2 = 0; var2 < this.itsBinaryRep.length; ++var2) {
  262.                if (var2 > 0) {
  263.                   var1.append(":");
  264.                }
  265.  
  266.                var1.append(Integer.toHexString(255 & this.itsBinaryRep[var2]));
  267.             }
  268.  
  269.             return var1.toString();
  270.          case 14:
  271.             return this.getNickname();
  272.          default:
  273.             return this.itsStringRep;
  274.       }
  275.    }
  276.  
  277.    public String toVerboseString() {
  278.       String var1 = this.toString();
  279.       switch (this.itsType) {
  280.          case 10:
  281.             return "CODEBASE_EXACT: " + var1;
  282.          case 11:
  283.             return "CODEBASE_REGEXP: " + var1;
  284.          case 12:
  285.             return "CERT: " + var1;
  286.          case 13:
  287.             return "CERT_FINGERPRINT: " + var1;
  288.          case 14:
  289.             return "CERT_FINGERPRINT: " + var1 + " " + this.getFingerPrint();
  290.          default:
  291.             return "Bogus type (" + this.itsType + "): " + var1;
  292.       }
  293.    }
  294.  
  295.    private void certToFingerprint() {
  296.       int var1 = 0;
  297.  
  298.       for(int var2 = 0; var2 < this.itsBinaryRep.length; ++var2) {
  299.          var1 = var1 * 37 + this.itsBinaryRep[var2];
  300.       }
  301.  
  302.       String var3 = Integer.toString(var1);
  303.       byte[] var4 = new byte[var3.length()];
  304.       var3.getBytes(0, var3.length() - 1, var4, 0);
  305.       this.itsFingerprint = var4;
  306.    }
  307.  
  308.    public String getVendor() {
  309.       switch (this.itsType) {
  310.          case 10:
  311.          case 11:
  312.          default:
  313.             return this.itsStringRep;
  314.          case 12:
  315.          case 13:
  316.          case 14:
  317.             return this.getNickname();
  318.       }
  319.    }
  320.  
  321.    public void describeClassInfo(ClassInfo var1) {
  322.       var1.addClass("Principal", 1);
  323.       var1.addField("Type", (byte)8);
  324.       var1.addField("HashCode", (byte)8);
  325.       var1.addField("StringRep", (byte)16);
  326.       var1.addField("BinaryRep", (byte)5);
  327.       var1.addField("Fingerprint", (byte)5);
  328.       var1.addField("CertKey", (byte)5);
  329.    }
  330.  
  331.    public void encode(Encoder var1) throws CodingException {
  332.       var1.encodeInt("Type", this.itsType);
  333.       var1.encodeInt("HashCode", this.itsHashCode);
  334.       var1.encodeString("StringRep", this.itsStringRep);
  335.       if (this.itsType == 12 || this.itsType == 13 || this.itsType == 14) {
  336.          var1.encodeByteArray("BinaryRep", this.itsBinaryRep, 0, this.itsBinaryRep.length);
  337.          var1.encodeByteArray("Fingerprint", this.itsFingerprint, 0, this.itsFingerprint == null ? 0 : this.itsFingerprint.length);
  338.          var1.encodeByteArray("CertKey", this.itsCertKey, 0, this.itsCertKey == null ? 0 : this.itsCertKey.length);
  339.       }
  340.  
  341.    }
  342.  
  343.    public void decode(Decoder var1) throws CodingException {
  344.       if (!this.itsInited) {
  345.          this.itsInited = true;
  346.          this.itsType = var1.decodeInt("Type");
  347.          this.itsHashCode = var1.decodeInt("HashCode");
  348.          this.itsStringRep = var1.decodeString("StringRep");
  349.          if (this.itsType == 12 || this.itsType == 13 || this.itsType == 14) {
  350.             this.itsBinaryRep = var1.decodeByteArray("BinaryRep");
  351.             this.itsFingerprint = var1.decodeByteArray("Fingerprint");
  352.             this.itsCertKey = var1.decodeByteArray("CertKey");
  353.          }
  354.  
  355.       }
  356.    }
  357.  
  358.    public void finishDecoding() throws CodingException {
  359.    }
  360.  
  361.    String getCompanyName() {
  362.       if (this.itsCompanyName == null) {
  363.          this.itsCompanyName = this.getCertAttribute(this.itsZig, 1, this.itsCertKey);
  364.       }
  365.  
  366.       return this.itsCompanyName;
  367.    }
  368.  
  369.    String getSecAuth() {
  370.       if (this.itsCertAuth == null) {
  371.          this.itsCertAuth = this.getCertAttribute(this.itsZig, 2, this.itsCertKey);
  372.       }
  373.  
  374.       return this.itsCertAuth;
  375.    }
  376.  
  377.    String getSerialNo() {
  378.       if (this.itsSerialNo == null) {
  379.          this.itsSerialNo = this.getCertAttribute(this.itsZig, 3, this.itsCertKey);
  380.       }
  381.  
  382.       return this.itsSerialNo;
  383.    }
  384.  
  385.    String getExpDate() {
  386.       if (this.itsExpDate == null) {
  387.          this.itsExpDate = this.getCertAttribute(this.itsZig, 4, this.itsCertKey);
  388.       }
  389.  
  390.       return this.itsExpDate;
  391.    }
  392.  
  393.    public String getFingerPrint() {
  394.       switch (this.itsType) {
  395.          case 10:
  396.          case 11:
  397.          case 12:
  398.          case 13:
  399.             return this.toString();
  400.          default:
  401.             if (this.itsAsciiFingerPrint == null) {
  402.                this.itsAsciiFingerPrint = this.getCertAttribute(this.itsZig, 6, this.itsCertKey);
  403.             }
  404.  
  405.             return this.itsAsciiFingerPrint;
  406.       }
  407.    }
  408.  
  409.    public String getNickname() {
  410.       if (this.itsType == 12 && this == PrivilegeManager.getUnsignedPrincipal()) {
  411.          return UserDialogHelper.getUnsignedPrincipal();
  412.       } else {
  413.          if (this.itsNickname == null) {
  414.             this.itsNickname = this.getCertAttribute(this.itsZig, 5, this.itsCertKey);
  415.          }
  416.  
  417.          return this.itsNickname;
  418.       }
  419.    }
  420.  
  421.    boolean savePrincipalPermanently() {
  422.       return !this.isCodebase() && this.itsZig != 0 ? this.saveCert(this.itsZig, this.itsCertKey) : true;
  423.    }
  424.  
  425.    static Principal createPrincipal(String var0) {
  426.       byte[] var1 = getPrincipalCertKey(var0);
  427.       if (var1 != null) {
  428.          return new Principal(14, var1);
  429.       } else {
  430.          throw new IllegalArgumentException("Unknown principal " + var0);
  431.       }
  432.    }
  433.  
  434.    static Principal createSystemPrincipal() {
  435.       Object[] var0 = getSystemPrincipalCertKey();
  436.       if (var0 != null && var0.length > 0) {
  437.          return new Principal(14, (byte[])var0[0]);
  438.       } else {
  439.          throw new IllegalArgumentException("Unknown system principal ");
  440.       }
  441.    }
  442.  
  443.    static boolean isSystemPrincipal(byte[] var0) {
  444.       Principal var1 = PrivilegeManager.getSystemPrincipal();
  445.       return var1.itsCertKey == null ? false : var1.compareByteArrays(var0, var1.itsCertKey);
  446.    }
  447.  
  448.    public boolean isSystemPrincipal() {
  449.       return this.equals(PrivilegeManager.getSystemPrincipal());
  450.    }
  451.  
  452.    private static Principal[] getPrincipalAry(Class var0, String var1, Object[] var2) {
  453.       Principal var3 = null;
  454.       int var4 = 0;
  455.       if (var2 != null) {
  456.          var4 += var2.length;
  457.       }
  458.  
  459.       if (var4 == 0) {
  460.          return PrivilegeManager.getUnknownPrincipalArray();
  461.       } else {
  462.          var3 = new Principal[var4];
  463.          int var5 = var4;
  464.  
  465.          while(var5-- > 0) {
  466.             if (isSystemPrincipal((byte[])var2[var5])) {
  467.                ((Object[])var3)[var5] = PrivilegeManager.getSystemPrincipal();
  468.             } else {
  469.                ((Object[])var3)[var5] = new Principal(14, (byte[])var2[var5], var0);
  470.             }
  471.          }
  472.  
  473.          return var3;
  474.       }
  475.    }
  476.  
  477.    private static native int getZigPtr(Class var0);
  478.  
  479.    native String getCertAttribute(int var1, int var2, byte[] var3);
  480.  
  481.    static native byte[] getPrincipalCertKey(String var0);
  482.  
  483.    static native Object[] getSystemPrincipalCertKey();
  484.  
  485.    private native boolean saveCert(int var1, byte[] var2);
  486. }
  487.