This type of keystore entry store sensitive crytographic key * information in a protected format.Typically this is a secret * key or a private key with a certificate chain.
This type of keystore entry contains a single public key * certificate belonging to annother entity. It is called trusted * because the keystore owner trusts that the certificates * belongs to the subject (owner) of the certificate.
Entries in a key store are referred to by their "alias": a simple * unique string. * *
The structure and persistentence of the key store is not * specified. Any method could be used to protect sensitive * (private or secret) keys. Smart cards or integrated * cryptographic engines could be used or the keystore could * be simply stored in a file.
* * @see java.security.cert.Certificate * @see Key */ public class KeyStore { // Constants and fields. // ------------------------------------------------------------------------ /** Service name for key stores. */ private static final String KEY_STORE = "KeyStore"; private KeyStoreSpi keyStoreSpi; private Provider provider; private String type; // Constructors. // ------------------------------------------------------------------------ /** Creates an instance of KeyStore @param keyStoreSpi A KeyStore engine to use @param provider A provider to use @param type The type of KeyStore */ protected KeyStore(KeyStoreSpi keyStoreSpi, Provider provider, String type) { this.keyStoreSpi = keyStoreSpi; this.provider = provider; this.type = type; } /** * Returns an instance of aKeyStore representing the specified
* type, from the first provider that implements it.
*
* @param type the type of keystore to create.
* @return a KeyStore repesenting the desired type.
* @throws KeyStoreException if the designated type of is not implemented by
* any provider, or the implementation could not be instantiated.
* @throws IllegalArgumentException if type is
* null or is an empty string.
*/
public static KeyStore getInstance(String type) throws KeyStoreException
{
Provider[] p = Security.getProviders();
KeyStoreException lastException = null;
for (int i = 0; i < p.length; i++)
try
{
return getInstance(type, p[i]);
}
catch (KeyStoreException x)
{
lastException = x;
}
if (lastException != null)
throw lastException;
throw new KeyStoreException(type);
}
/**
* Returns an instance of a KeyStore representing the specified
* type, from the named provider.
*
* @param type the type of keystore to create.
* @param provider the name of the provider to use.
* @return a KeyStore repesenting the desired type.
* @throws KeyStoreException if the designated type is not implemented by the
* given provider.
* @throws NoSuchProviderException if the provider is not found.
* @throws IllegalArgumentException if either type or
* provider is null or empty.
*/
public static KeyStore getInstance(String type, String provider)
throws KeyStoreException, NoSuchProviderException
{
if (provider == null)
throw new IllegalArgumentException("provider MUST NOT be null");
provider = provider.trim();
if (provider.length() == 0)
throw new IllegalArgumentException("provider MUST NOT be empty");
Provider p = Security.getProvider(provider);
if (p == null)
throw new NoSuchProviderException(provider);
return getInstance(type, p);
}
/**
* Returns an instance of a KeyStore representing the specified
* type, from the specified provider.
*
* @param type the type of keystore to create.
* @param provider the provider to use.
* @return a KeyStore repesenting the desired type.
* @throws KeyStoreException if the designated type is not implemented by the
* given provider.
* @throws IllegalArgumentException if either type or
* provider is null, or if
* type is an empty string.
* @since 1.4
*/
public static KeyStore getInstance(String type, Provider provider)
throws KeyStoreException
{
Throwable cause;
try
{
Object spi = Engine.getInstance(KEY_STORE, type, provider);
return new KeyStore((KeyStoreSpi) spi, provider, type);
}
catch (NoSuchAlgorithmException x)
{
cause = x;
}
catch (InvocationTargetException x)
{
cause = x.getCause() != null ? x.getCause() : x;
}
catch (ClassCastException x)
{
cause = x;
}
KeyStoreException x = new KeyStoreException(type);
x.initCause(cause);
throw x;
}
/**
* Returns the default KeyStore type. This method looks up the
* type in <JAVA_HOME>/lib/security/java.security with the
* property "keystore.type" or if that fails then "gkr" .
*/
public static final String getDefaultType()
{
// Security reads every property in java.security so it
// will return this property if it exists.
String tmp = Security.getProperty("keystore.type");
if (tmp == null)
tmp = "gkr";
return tmp;
}
// Instance methods.
// ------------------------------------------------------------------------
/**
Gets the provider that the class is from.
@return the provider of this class
*/
public final Provider getProvider()
{
return provider;
}
/**
Returns the type of the KeyStore supported
@return A string with the type of KeyStore
*/
public final String getType()
{
return type;
}
/**
Returns the key associated with given alias using the
supplied password.
@param alias an alias for the key to get
@param password password to access key with
@return the requested key, or null otherwise
@throws NoSuchAlgorithmException if there is no algorithm
for recovering the key
@throws UnrecoverableKeyException key cannot be reocovered
(wrong password).
*/
public final Key getKey(String alias, char[]password)
throws KeyStoreException, NoSuchAlgorithmException,
UnrecoverableKeyException
{
return keyStoreSpi.engineGetKey(alias, password);
}
/**
Gets a Certificate chain for the specified alias.
@param alias the alias name
@return a chain of Certificates ( ordered from the user's
certificate to the Certificate Authority's ) or
null if the alias does not exist or there is no
certificate chain for the alias ( the alias refers
to a trusted certificate entry or there is no entry).
*/
public final java.security.cert.
Certificate[] getCertificateChain(String alias) throws KeyStoreException
{
return keyStoreSpi.engineGetCertificateChain(alias);
}
/**
Gets a Certificate for the specified alias.
If there is a trusted certificate entry then that is returned.
it there is a key entry with a certificate chain then the
first certificate is return or else null.
@param alias the alias name
@return a Certificate or null if the alias does not exist
or there is no certificate for the alias
*/
public final java.security.cert.Certificate getCertificate(String alias)
throws KeyStoreException
{
return keyStoreSpi.engineGetCertificate(alias);
}
/**
Gets entry creation date for the specified alias.
@param alias the alias name
@returns the entry creation date or null
*/
public final Date getCreationDate(String alias) throws KeyStoreException
{
return keyStoreSpi.engineGetCreationDate(alias);
}
/**
Assign the key to the alias in the keystore, protecting it
with the given password. It will overwrite an existing
entry and if the key is a PrivateKey, also add the
certificate chain representing the corresponding public key.
@param alias the alias name
@param key the key to add
@password the password to protect with
@param chain the certificate chain for the corresponding
public key
@throws KeyStoreException if it fails
*/
public final void setKeyEntry(String alias, Key key, char[]password,
java.security.cert.
Certificate[]chain) throws KeyStoreException
{
keyStoreSpi.engineSetKeyEntry(alias, key, password, chain);
}
/**
Assign the key to the alias in the keystore. It will overwrite
an existing entry and if the key is a PrivateKey, also
add the certificate chain representing the corresponding
public key.
@param alias the alias name
@param key the key to add
@param chain the certificate chain for the corresponding
public key
@throws KeyStoreException if it fails
*/
public final void setKeyEntry(String alias, byte[]key,
java.security.cert.
Certificate[]chain) throws KeyStoreException
{
keyStoreSpi.engineSetKeyEntry(alias, key, chain);
}
/**
Assign the certificate to the alias in the keystore. It
will overwrite an existing entry.
@param alias the alias name
@param cert the certificate to add
@throws KeyStoreException if it fails
*/
public final void setCertificateEntry(String alias,
java.security.cert.
Certificate cert) throws
KeyStoreException
{
keyStoreSpi.engineSetCertificateEntry(alias, cert);
}
/**
Deletes the entry for the specified entry.
@param alias the alias name
@throws KeyStoreException if it fails
*/
public final void deleteEntry(String alias) throws KeyStoreException
{
keyStoreSpi.engineDeleteEntry(alias);
}
/**
Generates a list of all the aliases in the keystore.
@return an Enumeration of the aliases
*/
public final Enumeration