mirror of git://gcc.gnu.org/git/gcc.git
347 lines
10 KiB
Java
347 lines
10 KiB
Java
/* Identity.java --- Identity Class
|
|
Copyright (C) 1999, 2003, Free Software Foundation, Inc.
|
|
|
|
This file is part of GNU Classpath.
|
|
|
|
GNU Classpath is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2, or (at your option)
|
|
any later version.
|
|
|
|
GNU Classpath is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with GNU Classpath; see the file COPYING. If not, write to the
|
|
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
|
|
02110-1301 USA.
|
|
|
|
Linking this library statically or dynamically with other modules is
|
|
making a combined work based on this library. Thus, the terms and
|
|
conditions of the GNU General Public License cover the whole
|
|
combination.
|
|
|
|
As a special exception, the copyright holders of this library give you
|
|
permission to link this library with independent modules to produce an
|
|
executable, regardless of the license terms of these independent
|
|
modules, and to copy and distribute the resulting executable under
|
|
terms of your choice, provided that you also meet, for each linked
|
|
independent module, the terms and conditions of the license of that
|
|
module. An independent module is a module which is not derived from
|
|
or based on this library. If you modify this library, you may extend
|
|
this exception to your version of the library, but you are not
|
|
obligated to do so. If you do not wish to do so, delete this
|
|
exception statement from your version. */
|
|
|
|
package java.security;
|
|
|
|
import java.io.Serializable;
|
|
import java.util.Vector;
|
|
|
|
/**
|
|
* The <code>Identity</code> class is used to represent people and companies
|
|
* that can be authenticated using public key encryption. The identities can
|
|
* also be abstract objects such as smart cards.
|
|
*
|
|
* <p><code>Identity</code> objects store a name and public key for each
|
|
* identity. The names cannot be changed and the identities can be scoped. Each
|
|
* identity (name and public key) within a scope are unique to that scope.</p>
|
|
*
|
|
* <p>Each identity has a set of ceritificates which all specify the same
|
|
* public key, but not necessarily the same name.</p>
|
|
*
|
|
* <p>The <code>Identity</code> class can be subclassed to allow additional
|
|
* information to be attached to it.</p>
|
|
*
|
|
* @author Mark Benvenuto
|
|
* @see IdentityScope
|
|
* @see Signer
|
|
* @see Principal
|
|
* @deprecated Replaced by <code>java.security.KeyStore</code>, the
|
|
* <code>java.security.cert</code> package, and
|
|
* <code>java.security.Principal</code>.
|
|
*/
|
|
public abstract class Identity implements Principal, Serializable
|
|
{
|
|
private static final long serialVersionUID = 3609922007826600659L;
|
|
|
|
private String name;
|
|
private IdentityScope scope;
|
|
private PublicKey publicKey;
|
|
private String info;
|
|
private Vector certificates;
|
|
|
|
/** Constructor for serialization only. */
|
|
protected Identity()
|
|
{
|
|
}
|
|
|
|
/**
|
|
* Constructs a new instance of <code>Identity</code> with the specified
|
|
* name and scope.
|
|
*
|
|
* @param name
|
|
* the name to use.
|
|
* @param scope
|
|
* the scope to use.
|
|
* @throws KeyManagementException
|
|
* if the identity is already present.
|
|
*/
|
|
public Identity(String name, IdentityScope scope)
|
|
throws KeyManagementException
|
|
{
|
|
this.name = name;
|
|
this.scope = scope;
|
|
}
|
|
|
|
/**
|
|
* Constructs a new instance of <code>Identity</code> with the specified
|
|
* name and no scope.
|
|
*
|
|
* @param name
|
|
* the name to use.
|
|
*/
|
|
public Identity(String name)
|
|
{
|
|
this.name = name;
|
|
this.scope = null;
|
|
}
|
|
|
|
/** @return the name of this identity. */
|
|
public final String getName()
|
|
{
|
|
return name;
|
|
}
|
|
|
|
/** @return the scope of this identity. */
|
|
public final IdentityScope getScope()
|
|
{
|
|
return scope;
|
|
}
|
|
|
|
/**
|
|
* @return the public key of this identity.
|
|
* @see #setPublicKey(java.security.PublicKey)
|
|
*/
|
|
public PublicKey getPublicKey()
|
|
{
|
|
return publicKey;
|
|
}
|
|
|
|
/**
|
|
* Sets the public key for this identity. The old key and all certificates
|
|
* are removed.
|
|
*
|
|
* @param key
|
|
* the public key to use.
|
|
* @throws KeyManagementException
|
|
* if this public key is used by another identity in the current
|
|
* scope.
|
|
* @throws SecurityException
|
|
* if a {@link SecurityManager} is installed which disallows this
|
|
* operation.
|
|
*/
|
|
public void setPublicKey(PublicKey key) throws KeyManagementException
|
|
{
|
|
SecurityManager sm = System.getSecurityManager();
|
|
if (sm != null)
|
|
sm.checkSecurityAccess("setIdentityPublicKey");
|
|
|
|
this.publicKey = key;
|
|
}
|
|
|
|
/**
|
|
* Sets the general information string.
|
|
*
|
|
* @param info
|
|
* the general information string.
|
|
* @throws SecurityException
|
|
* if a {@link SecurityManager} is installed which disallows this
|
|
* operation.
|
|
*/
|
|
public void setInfo(String info)
|
|
{
|
|
SecurityManager sm = System.getSecurityManager();
|
|
if (sm != null)
|
|
sm.checkSecurityAccess("setIdentityInfo");
|
|
|
|
this.info = info;
|
|
}
|
|
|
|
/**
|
|
* @return the general information string of this identity.
|
|
* @see #setInfo(String)
|
|
*/
|
|
public String getInfo()
|
|
{
|
|
return info;
|
|
}
|
|
|
|
/**
|
|
* Adds a certificate to the list of ceritificates for this identity. The
|
|
* public key in this certificate must match the existing public key if it
|
|
* exists.
|
|
*
|
|
* @param certificate
|
|
* the certificate to add.
|
|
* @throws KeyManagementException
|
|
* if the certificate is invalid, or the public key conflicts.
|
|
* @throws SecurityException
|
|
* if a {@link SecurityManager} is installed which disallows this
|
|
* operation.
|
|
*/
|
|
public void addCertificate(Certificate certificate)
|
|
throws KeyManagementException
|
|
{
|
|
SecurityManager sm = System.getSecurityManager();
|
|
if (sm != null)
|
|
sm.checkSecurityAccess("addIdentityCertificate");
|
|
|
|
// Check public key of this certificate against the first one in the vector
|
|
if (certificates.size() > 0)
|
|
{
|
|
if (((Certificate) certificates.firstElement()).getPublicKey() != publicKey)
|
|
throw new KeyManagementException("Public key does not match");
|
|
}
|
|
certificates.addElement(certificate);
|
|
}
|
|
|
|
/**
|
|
* Removes a certificate from the list of ceritificates for this identity.
|
|
*
|
|
* @param certificate
|
|
* the certificate to remove.
|
|
* @throws KeyManagementException
|
|
* if the certificate is invalid.
|
|
* @throws SecurityException
|
|
* if a {@link SecurityManager} is installed which disallows this
|
|
* operation.
|
|
*/
|
|
public void removeCertificate(Certificate certificate)
|
|
throws KeyManagementException
|
|
{
|
|
SecurityManager sm = System.getSecurityManager();
|
|
if (sm != null)
|
|
sm.checkSecurityAccess("removeIdentityCertificate");
|
|
|
|
if (certificates.contains(certificate) == false)
|
|
throw new KeyManagementException("Certificate not found");
|
|
|
|
certificates.removeElement(certificate);
|
|
}
|
|
|
|
/** @return an array of {@link Certificate}s for this identity. */
|
|
public Certificate[] certificates()
|
|
{
|
|
Certificate[] certs = new Certificate[certificates.size()];
|
|
int max = certificates.size();
|
|
for (int i = 0; i < max; i++)
|
|
certs[i] = (Certificate) certificates.elementAt(i);
|
|
|
|
return certs;
|
|
}
|
|
|
|
/**
|
|
* Checks for equality between this Identity and a specified object. It first
|
|
* checks if they are the same object, then if the name and scope match and
|
|
* returns <code>true</code> if successful. If these tests fail, the
|
|
* {@link #identityEquals(Identity)} method is called.
|
|
*
|
|
* @return <code>true</code> if they are equal, <code>false</code>
|
|
* otherwise.
|
|
*/
|
|
public final boolean equals(Object identity)
|
|
{
|
|
if (identity instanceof Identity)
|
|
{
|
|
if (identity == this)
|
|
return true;
|
|
|
|
if ((((Identity) identity).getName().equals(this.name)) &&
|
|
(((Identity) identity).getScope().equals(this.scope)))
|
|
return true;
|
|
|
|
return identityEquals((Identity) identity);
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checks for equality between this Identity and a specified object. A
|
|
* subclass should override this method. The default behavior is to return
|
|
* <code>true</code> if the public key and names match.
|
|
*
|
|
* @return <code>true</code> if they are equal, <code>false</code>
|
|
* otherwise.
|
|
*/
|
|
protected boolean identityEquals(Identity identity)
|
|
{
|
|
return ((identity.getName().equals(this.name)) &&
|
|
(identity.getPublicKey().equals(this.publicKey)));
|
|
}
|
|
|
|
/**
|
|
* Returns a string representation of this Identity.
|
|
*
|
|
* @return a string representation of this Identity.
|
|
* @throws SecurityException
|
|
* if a {@link SecurityManager} is installed which disallows this
|
|
* operation.
|
|
*/
|
|
public String toString()
|
|
{
|
|
SecurityManager sm = System.getSecurityManager();
|
|
if (sm != null)
|
|
sm.checkSecurityAccess("printIdentity");
|
|
|
|
/* TODO: Insert proper format here */
|
|
return (name + ":@" + scope + " Public Key: " + publicKey);
|
|
}
|
|
|
|
/**
|
|
* Returns a detailed string representation of this Identity.
|
|
*
|
|
* @param detailed
|
|
* indicates whether or detailed information is desired.
|
|
* @return a string representation of this Identity.
|
|
* @throws SecurityException
|
|
* if a {@link SecurityManager} is installed which disallows this
|
|
* operation.
|
|
*/
|
|
public String toString(boolean detailed)
|
|
{
|
|
SecurityManager sm = System.getSecurityManager();
|
|
if (sm != null)
|
|
sm.checkSecurityAccess("printIdentity");
|
|
|
|
if (detailed)
|
|
{
|
|
/* TODO: Insert proper detailed format here */
|
|
return (name + ":@" + scope + " Public Key: " + publicKey);
|
|
}
|
|
else
|
|
{
|
|
/* TODO: Insert proper format here */
|
|
return (name + ":@" + scope + " Public Key: " + publicKey);
|
|
}
|
|
}
|
|
|
|
/** @return a hashcode of this identity. */
|
|
public int hashCode()
|
|
{
|
|
int ret = name.hashCode();
|
|
if (publicKey != null)
|
|
ret |= publicKey.hashCode();
|
|
if (scope != null)
|
|
ret |= scope.hashCode();
|
|
if (info != null)
|
|
ret |= info.hashCode();
|
|
if (certificates != null)
|
|
ret |= certificates.hashCode();
|
|
|
|
return ret;
|
|
}
|
|
}
|