home *** CD-ROM | disk | FTP | other *** search
/ Programming Languages Suite / ProgLangD.iso / VCAFE.3.0A / Main.bin / Identity.java < prev    next >
Text File  |  1998-09-22  |  11KB  |  402 lines
  1. /*
  2.  * @(#)Identity.java    1.28 98/07/01
  3.  *
  4.  * Copyright 1995-1998 by Sun Microsystems, Inc.,
  5.  * 901 San Antonio Road, Palo Alto, California, 94303, U.S.A.
  6.  * All rights reserved.
  7.  * 
  8.  * This software is the confidential and proprietary information
  9.  * of Sun Microsystems, Inc. ("Confidential Information").  You
  10.  * shall not disclose such Confidential Information and shall use
  11.  * it only in accordance with the terms of the license agreement
  12.  * you entered into with Sun.
  13.  */
  14.  
  15. package java.security;
  16.  
  17. import java.io.Serializable;
  18. import java.util.*;
  19.  
  20. /**
  21.  * <p>This class represents identities: real-world objects such as people,
  22.  * companies or organizations whose identities can be authenticated using 
  23.  * their public keys. Identities may also be more abstract (or concrete) 
  24.  * constructs, such as daemon threads or smart cards.
  25.  *
  26.  * <p>All Identity objects have a name and a public key. Names are
  27.  * immutable. Identities may also be scoped. That is, if an Identity is
  28.  * specified to have a particular scope, then the name and public
  29.  * key of the Identity are unique within that scope.
  30.  *
  31.  * <p>An Identity also has a set of certificates (all certifying its own
  32.  * public key). The Principal names specified in these certificates need 
  33.  * not be the same, only the key.
  34.  *
  35.  * <p>An Identity can be subclassed, to include postal and email addresses,
  36.  * telephone numbers, images of faces and logos, and so on.
  37.  *
  38.  * @see IdentityScope
  39.  * @see Signer
  40.  * @see Principal
  41.  *
  42.  * @version     1.24, 01/27/97
  43.  * @author Benjamin Renaud 
  44.  */
  45. public abstract 
  46. class Identity implements Principal, Serializable {
  47.  
  48.     /**
  49.      * The name for this identity.
  50.      */
  51.     private String name;
  52.  
  53.     /**
  54.      * The public key for this identity.
  55.      */
  56.     private PublicKey publicKey;
  57.  
  58.     /**
  59.      * Generic, descriptive information about the identity.
  60.      */
  61.     String info = "No further information available.";
  62.  
  63.     /**
  64.      * The scope of the identity.
  65.      */
  66.     IdentityScope scope;
  67.  
  68.     /**
  69.      * The certificates for this identity.
  70.      */
  71.     Vector certificates;
  72.  
  73.     /**
  74.      * Constructor for serialization only.
  75.      */
  76.     protected Identity() {
  77.     this("restoring...");
  78.     }
  79.  
  80.     /**
  81.      * Constructs an identity with the specified name and scope.
  82.      *
  83.      * @param name the identity name.  
  84.      * @param scope the scope of the identity.
  85.      *
  86.      * @exception KeyManagementException if there is already an identity 
  87.      * with the same name in the scope.
  88.      */
  89.     public Identity(String name, IdentityScope scope) throws
  90.     KeyManagementException {
  91.     this(name);
  92.     this.scope = scope;
  93.     }
  94.  
  95.     /**
  96.      * Constructs an identity with the specified name and no scope.
  97.      *
  98.      * @param name the identity name.
  99.      */
  100.     public Identity(String name) {
  101.     this.name = name;
  102.     }
  103.  
  104.     /**
  105.      * Returns this identity's name.
  106.      *
  107.      * @return the name of this identity.
  108.      */
  109.     public final String getName() {
  110.     return name;
  111.     }
  112.  
  113.     /**
  114.      * Returns this identity's scope.
  115.      *
  116.      * @return the scope of this identity.
  117.      */
  118.     public final IdentityScope getScope() {
  119.     return scope;
  120.     }
  121.  
  122.     /**
  123.      * Returns this identity's public key.
  124.      * 
  125.      * @return the public key for this identity.
  126.      */
  127.     public PublicKey getPublicKey() {
  128.     return publicKey;
  129.     }
  130.  
  131.     /**
  132.      * Sets this identity's public key. The old key and all of this
  133.      * identity's certificates are removed by this operation. 
  134.      *
  135.      * @param key the public key for this identity.
  136.      *
  137.      * @exception KeyManagementException if another identity in the 
  138.      * identity's scope has the same public key, or if another exception occurs.  
  139.      */
  140.     /* Should we throw an exception if this is already set? */
  141.     public void setPublicKey(PublicKey key) throws KeyManagementException {
  142.     
  143.     check("set.public.key");
  144.     this.publicKey = key;
  145.     certificates = new Vector();
  146.     }
  147.  
  148.     /**
  149.      * Specifies a general information string for this identity.
  150.      *
  151.      * @param info the information string.
  152.      *
  153.      * @see #getInfo
  154.      */
  155.     public void setInfo(String info) {
  156.     check("set.info");
  157.     this.info = info;
  158.     }
  159.  
  160.     /**
  161.      * Returns general information previously specified for this identity.
  162.      *
  163.      * @return general information about this identity.
  164.      *
  165.      * @see #setInfo
  166.      */
  167.     public String getInfo() {
  168.     return info;
  169.     }
  170.  
  171.     /**
  172.      * Adds a certificate for this identity. If the identity has a public
  173.      * key, the public key in the certificate must be the same, and if
  174.      * the identity does not have a public key, the identity's
  175.      * public key is set to be that specified in the certificate.
  176.      *
  177.      * @param certificate the certificate to be added.
  178.      *
  179.      * @exception KeyManagementException if the certificate is not valid,
  180.      * if the public key in the certificate being added conflicts with
  181.      * this identity's public key, or if another exception occurs.
  182.      */
  183.     public void addCertificate(Certificate certificate)
  184.     throws KeyManagementException {
  185.  
  186.     check("add.certificate");
  187.  
  188.     if (certificates == null) {
  189.         certificates = new Vector();
  190.     }
  191.     if (publicKey != null) {
  192.         if (!keyEquals(publicKey, certificate.getPublicKey())) {
  193.         throw new KeyManagementException(
  194.             "public key different from cert public key");
  195.         }
  196.     } else {
  197.         publicKey = certificate.getPublicKey();
  198.     }
  199.     certificates.addElement(certificate);
  200.     }
  201.  
  202.    private boolean keyEquals(Key aKey, Key anotherKey) {
  203.     if (aKey.getFormat().equalsIgnoreCase(anotherKey.getFormat())) {
  204.         return MessageDigest.isEqual(aKey.getEncoded(), 
  205.                      anotherKey.getEncoded());
  206.     } else {
  207.         return false;
  208.     }
  209.     }
  210.  
  211.  
  212.     /**
  213.      * Removes a certificate from this identity.
  214.      *
  215.      * @param certificate the certificate to be removed.
  216.      *
  217.      * @exception KeyManagementException if the certificate is
  218.      * missing, or if another exception occurs.
  219.      */
  220.     public void removeCertificate(Certificate certificate)
  221.     throws KeyManagementException {
  222.     check("remove.certificate");
  223.     if (certificates != null) {
  224.         certificates.removeElement(certificate);
  225.     }
  226.     }
  227.  
  228.     /**
  229.      * Returns a copy of all the certificates for this identity.  
  230.      * 
  231.      * @return a copy of all the certificates for this identity.  
  232.      */
  233.     public Certificate[] certificates() {
  234.     if (certificates == null) {
  235.         return new Certificate[0];
  236.     }
  237.     int len = certificates.size();
  238.     Certificate[] certs = new Certificate[len];
  239.     certificates.copyInto(certs);
  240.     return certs;
  241.     }
  242.  
  243.     /**
  244.      * Tests for equality between the specified object and this identity.
  245.      * This first tests to see if the entities actually refer to the same
  246.      * object, in which case it returns true. Next, it checks to see if
  247.      * the entities have the same name and the same scope. If they do, 
  248.      * the method returns true. Otherwise, it calls <a href = 
  249.      * "#identityEquals">identityEquals</a>, which subclasses should 
  250.      * override.
  251.      *
  252.      * @param identity the object to test for equality with this identity.  
  253.      *
  254.      * @return true if the objects are considered equal, false otherwise.
  255.      *
  256.      * @see #identityEquals 
  257.      */
  258.     public final boolean equals(Object identity) {
  259.  
  260.     if (identity == this) {
  261.         return true;
  262.     }
  263.  
  264.     if (identity instanceof Identity) {
  265.         Identity i = (Identity)identity;
  266.         if (i.getScope() == scope && i.getName().equals(name)) {
  267.         return true;
  268.         } else {
  269.         return identityEquals(i);        
  270.         }
  271.     }
  272.     return false;
  273.     }
  274.  
  275.     /**
  276.      * Tests for equality between the specified identity and this identity.
  277.      * This method should be overriden by subclasses to test for equality. 
  278.      * The default behavior is to return true if the names and public keys 
  279.      * are equal.
  280.      *
  281.      * @param identity the identity to test for equality with this identity.
  282.      * 
  283.      * @return true if the identities are considered equal, false
  284.      * otherwise. 
  285.      *
  286.      * @see #equals 
  287.      */
  288.     protected boolean identityEquals(Identity identity) {
  289.     return (name.equals(identity.name) && 
  290.         publicKey.equals(identity.publicKey));
  291.     }
  292.  
  293.     /**
  294.      * Returns a parsable name for identity: identityName.scopeName
  295.      */
  296.     String fullName() {
  297.     String parsable = name;
  298.     if (scope != null) {
  299.         parsable += "." + scope.getName();
  300.     }
  301.     return parsable;
  302.     }
  303.  
  304.     /**
  305.      * Returns a short string describing this identity, telling its
  306.      * name and its scope (if any).
  307.      *
  308.      * @return information about this identity, such as its name and the  
  309.      * name of its scope (if any).
  310.      */
  311.     public String toString() {
  312.     check("print");
  313.     String printable = name;
  314.     if (scope != null) {
  315.         printable += "[" + scope.getName() + "]";
  316.     }
  317.     return printable;
  318.     }
  319.  
  320.     /**
  321.      * Returns a string representation of this identity, with
  322.      * optionally more details than that provided by the
  323.      * <code>toString</code> method without any arguments.
  324.      *
  325.      * @param detailed whether or not to provide detailed information.  
  326.      *
  327.      * @return information about this identity. If <code>detailed</code>
  328.      * is true, then this method returns more information than that 
  329.      * provided by the <code>toString</code> method without any arguments.
  330.      *
  331.      * @see #toString
  332.      */
  333.     public String toString(boolean detailed) {
  334.     String out = toString();
  335.     if (detailed) {
  336.         out += "\n";
  337.         out += printKeys();
  338.         out += "\n" + printCertificates();
  339.         if (info != null) {
  340.         out += "\n\t" + info;
  341.         } else {
  342.         out += "\n\tno additional information available.";
  343.         }
  344.     }      
  345.     return out;
  346.     }
  347.  
  348.     String printKeys() {
  349.     String key = "";
  350.     if (publicKey != null) {
  351.         key = "\tpublic key initialized";
  352.     } else {
  353.         key = "\tno public key";
  354.     }
  355.     return key;
  356.     }
  357.  
  358.     String printCertificates() {
  359.     String out = "";
  360.     if (certificates == null) {
  361.         return "\tno certificates";
  362.     } else {
  363.         out += "\tcertificates: \n";
  364.         Enumeration e = certificates.elements();
  365.         int i = 1;
  366.         while (e.hasMoreElements()) {
  367.         Certificate cert = (Certificate)e.nextElement();
  368.         out += "\tcertificate " + i++ +
  369.             "\tfor  : " + cert.getPrincipal() + "\n";
  370.         out += "\t\t\tfrom : " + 
  371.             cert.getGuarantor() + "\n";
  372.         }
  373.     }
  374.     return out;
  375.     }
  376.     
  377.     /**
  378.      * Returns a hashcode for this identity.
  379.      *
  380.      * @return a hashcode for this identity.
  381.      */
  382.     public int hashCode() {
  383.     String scopedName = name;
  384.     if (scope != null) {
  385.         scopedName += scope.getName();
  386.     }
  387.     return scopedName.hashCode();
  388.     }
  389.  
  390.     void check(String directive) {
  391.     staticCheck(this.getClass().getName() + "." + directive + "." +fullName());
  392.     }
  393.  
  394.     static void staticCheck(String directive) {
  395.     SecurityManager security = System.getSecurityManager();
  396.     if (security != null) {
  397.         security.checkSecurityAccess(directive);
  398.     }
  399.     }
  400. }
  401.  
  402.