libjava/classpath/java/security/Identity.java

   1 /* Identity.java --- Identity Class
   2    Copyright (C) 1999, 2003, Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 02110-1301 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38 package java.security;
  39
  40 import java.io.Serializable;
  41 import java.util.Vector;
  42
  43 /**
  44  * The <code>Identity</code> class is used to represent people and companies
  45  * that can be authenticated using public key encryption. The identities can
  46  * also be abstract objects such as smart cards.
  47  *
  48  * <p><code>Identity</code> objects store a name and public key for each
  49  * identity. The names cannot be changed and the identities can be scoped. Each
  50  * identity (name and public key) within a scope are unique to that scope.</p>
  51  *
  52  * <p>Each identity has a set of ceritificates which all specify the same
  53  * public key, but not necessarily the same name.</p>
  54  *
  55  * <p>The <code>Identity</code> class can be subclassed to allow additional
  56  * information to be attached to it.</p>
  57  *
  58  * @author Mark Benvenuto
  59  * @see IdentityScope
  60  * @see Signer
  61  * @see Principal
  62  * @deprecated Replaced by <code>java.security.KeyStore</code>, the
  63  * <code>java.security.cert</code> package, and
  64  * <code>java.security.Principal</code>.
  65  */
  66 public abstract class Identity implements Principal, Serializable
  67 {
  68   private static final long serialVersionUID = 3609922007826600659L;
  69
  70   private String name;
  71   private IdentityScope scope;
  72   private PublicKey publicKey;
  73   private String info;
  74   private Vector certificates;
  75
  76   /** Constructor for serialization only. */
  77   protected Identity()
  78   {
  79   }
  80
  81   /**
  82    * Constructs a new instance of <code>Identity</code> with the specified
  83    * name and scope.
  84    *
  85    * @param name
  86    *          the name to use.
  87    * @param scope
  88    *          the scope to use.
  89    * @throws KeyManagementException
  90    *           if the identity is already present.
  91    */
  92   public Identity(String name, IdentityScope scope)
  93     throws KeyManagementException
  94   {
  95     this.name = name;
  96     this.scope = scope;
  97   }
  98
  99   /**
 100    * Constructs a new instance of <code>Identity</code> with the specified
 101    * name and no scope.
 102    *
 103    * @param name
 104    *          the name to use.
 105    */
 106   public Identity(String name)
 107   {
 108     this.name = name;
 109     this.scope = null;
 110   }
 111
 112   /** @return the name of this identity. */
 113   public final String getName()
 114   {
 115     return name;
 116   }
 117
 118   /** @return the scope of this identity. */
 119   public final IdentityScope getScope()
 120   {
 121     return scope;
 122   }
 123
 124   /**
 125    * @return the public key of this identity.
 126    * @see #setPublicKey(java.security.PublicKey)
 127    */
 128   public PublicKey getPublicKey()
 129   {
 130     return publicKey;
 131   }
 132
 133   /**
 134    * Sets the public key for this identity. The old key and all certificates
 135    * are removed.
 136    *
 137    * @param key
 138    *          the public key to use.
 139    * @throws KeyManagementException
 140    *           if this public key is used by another identity in the current
 141    *           scope.
 142    * @throws SecurityException
 143    *           if a {@link SecurityManager} is installed which disallows this
 144    *           operation.
 145    */
 146   public void setPublicKey(PublicKey key) throws KeyManagementException
 147   {
 148     SecurityManager sm = System.getSecurityManager();
 149     if (sm != null)
 150       sm.checkSecurityAccess("setIdentityPublicKey");
 151
 152     this.publicKey = key;
 153   }
 154
 155   /**
 156    * Sets the general information string.
 157    *
 158    * @param info
 159    *          the general information string.
 160    * @throws SecurityException
 161    *           if a {@link SecurityManager} is installed which disallows this
 162    *           operation.
 163    */
 164   public void setInfo(String info)
 165   {
 166     SecurityManager sm = System.getSecurityManager();
 167     if (sm != null)
 168       sm.checkSecurityAccess("setIdentityInfo");
 169
 170     this.info = info;
 171   }
 172
 173   /**
 174    * @return the general information string of this identity.
 175    * @see #setInfo(String)
 176    */
 177   public String getInfo()
 178   {
 179     return info;
 180   }
 181
 182   /**
 183    * Adds a certificate to the list of ceritificates for this identity. The
 184    * public key in this certificate must match the existing public key if it
 185    * exists.
 186    *
 187    * @param certificate
 188    *          the certificate to add.
 189    * @throws KeyManagementException
 190    *           if the certificate is invalid, or the public key conflicts.
 191    * @throws SecurityException
 192    *           if a {@link SecurityManager} is installed which disallows this
 193    *           operation.
 194    */
 195   public void addCertificate(Certificate certificate)
 196     throws KeyManagementException
 197   {
 198     SecurityManager sm = System.getSecurityManager();
 199     if (sm != null)
 200       sm.checkSecurityAccess("addIdentityCertificate");
 201
 202     // Check public key of this certificate against the first one in the vector
 203     if (certificates.size() > 0)
 204       {
 205         if (((Certificate) certificates.firstElement()).getPublicKey() != publicKey)
 206           throw new KeyManagementException("Public key does not match");
 207       }
 208     certificates.addElement(certificate);
 209   }
 210
 211   /**
 212    * Removes a certificate from the list of ceritificates for this identity.
 213    *
 214    * @param certificate
 215    *          the certificate to remove.
 216    * @throws KeyManagementException
 217    *           if the certificate is invalid.
 218    * @throws SecurityException
 219    *           if a {@link SecurityManager} is installed which disallows this
 220    *           operation.
 221    */
 222   public void removeCertificate(Certificate certificate)
 223     throws KeyManagementException
 224   {
 225     SecurityManager sm = System.getSecurityManager();
 226     if (sm != null)
 227       sm.checkSecurityAccess("removeIdentityCertificate");
 228
 229     if (certificates.contains(certificate) == false)
 230       throw new KeyManagementException("Certificate not found");
 231
 232     certificates.removeElement(certificate);
 233   }
 234
 235   /** @return an array of {@link Certificate}s for this identity. */
 236   public Certificate[] certificates()
 237   {
 238     Certificate[] certs = new Certificate[certificates.size()];
 239     int max = certificates.size();
 240     for (int i = 0; i < max; i++)
 241       certs[i] = (Certificate) certificates.elementAt(i);
 242
 243     return certs;
 244   }
 245
 246   /**
 247    * Checks for equality between this Identity and a specified object. It first
 248    * checks if they are the same object, then if the name and scope match and
 249    * returns <code>true</code> if successful. If these tests fail, the
 250    * {@link #identityEquals(Identity)} method is called.
 251    *
 252    * @return <code>true</code> if they are equal, <code>false</code>
 253    *         otherwise.
 254    */
 255   public final boolean equals(Object identity)
 256   {
 257     if (identity instanceof Identity)
 258       {
 259         if (identity == this)
 260           return true;
 261
 262         if ((((Identity) identity).getName().equals(this.name)) &&
 263             (((Identity) identity).getScope().equals(this.scope)))
 264           return true;
 265
 266         return identityEquals((Identity) identity);
 267       }
 268     return false;
 269   }
 270
 271   /**
 272    * Checks for equality between this Identity and a specified object. A
 273    * subclass should override this method. The default behavior is to return
 274    * <code>true</code> if the public key and names match.
 275    *
 276    * @return <code>true</code> if they are equal, <code>false</code>
 277    *         otherwise.
 278    */
 279   protected boolean identityEquals(Identity identity)
 280   {
 281     return ((identity.getName().equals(this.name)) &&
 282             (identity.getPublicKey().equals(this.publicKey)));
 283   }
 284
 285   /**
 286    * Returns a string representation of this Identity.
 287    *
 288    * @return a string representation of this Identity.
 289    * @throws SecurityException
 290    *           if a {@link SecurityManager} is installed which disallows this
 291    *           operation.
 292    */
 293   public String toString()
 294   {
 295     SecurityManager sm = System.getSecurityManager();
 296     if (sm != null)
 297       sm.checkSecurityAccess("printIdentity");
 298
 299     /* TODO: Insert proper format here */
 300     return (name + ":@" + scope + " Public Key: " + publicKey);
 301   }
 302
 303   /**
 304    * Returns a detailed string representation of this Identity.
 305    *
 306    * @param detailed
 307    *          indicates whether or detailed information is desired.
 308    * @return a string representation of this Identity.
 309    * @throws SecurityException
 310    *           if a {@link SecurityManager} is installed which disallows this
 311    *           operation.
 312    */
 313   public String toString(boolean detailed)
 314   {
 315     SecurityManager sm = System.getSecurityManager();
 316     if (sm != null)
 317       sm.checkSecurityAccess("printIdentity");
 318
 319     if (detailed)
 320       {
 321         /* TODO: Insert proper detailed format here */
 322         return (name + ":@" + scope + " Public Key: " + publicKey);
 323       }
 324     else
 325       {
 326         /* TODO: Insert proper format here */
 327         return (name + ":@" + scope + " Public Key: " + publicKey);
 328       }
 329   }
 330
 331   /** @return a hashcode of this identity. */
 332   public int hashCode()
 333   {
 334     int ret = name.hashCode();
 335     if (publicKey != null)
 336       ret |= publicKey.hashCode();
 337     if (scope != null)
 338       ret |= scope.hashCode();
 339     if (info != null)
 340       ret |= info.hashCode();
 341     if (certificates != null)
 342       ret |= certificates.hashCode();
 343
 344     return ret;
 345   }
 346 }