Key factories are used to convert keys (opaque cryptographic keys of type * {@link Key}) into key specifications (transparent representations of the * underlying key material), and vice versa.
* *Key factories are bi-directional. That is, they allow you to build an * opaque key object from a given key specification (key material), or to * retrieve the underlying key material of a key object in a suitable format.
* *Multiple compatible key specifications may exist for the same key. For * example, a DSA public key may be specified using {@link * java.security.spec.DSAPublicKeySpec} or {@link * java.security.spec.X509EncodedKeySpec}. A key factory can be used to * translate between compatible key specifications.
* *The following is an example of how to use a key factory in order to * instantiate a DSA public key from its encoding. Assume Alice has * received a digital signature from Bob. Bob also sent her his public key (in * encoded format) to verify his signature. Alice then performs the following * actions: * *
* X509EncodedKeySpec bobPubKeySpec = new X509EncodedKeySpec(bobEncodedPubKey);
* KeyFactory keyFactory = KeyFactory.getInstance("DSA");
* PublicKey bobPubKey = keyFactory.generatePublic(bobPubKeySpec);
* Signature sig = Signature.getInstance("DSA");
* sig.initVerify(bobPubKey);
* sig.update(data);
* sig.verify(signature);
*
*
* @since 1.2
* @see Key
* @see PublicKey
* @see PrivateKey
* @see KeySpec
* @see java.security.spec.DSAPublicKeySpec
* @see java.security.spec.X509EncodedKeySpec
@author Mark Benvenuto
*/
public class KeyFactory
{
/** The service name for key factories. */
private static final String KEY_FACTORY = "KeyFactory";
private KeyFactorySpi keyFacSpi;
private Provider provider;
private String algorithm;
/**
* Creates a KeyFactory object.
*
* @param keyFacSpi the delegate.
* @param provider the provider.
* @param algorithm the name of the algorithm to associate with this
* KeyFactory.
*/
protected KeyFactory(KeyFactorySpi keyFacSpi, Provider provider,
String algorithm)
{
this.keyFacSpi = keyFacSpi;
this.provider = provider;
this.algorithm = algorithm;
}
/**
* Generates a KeyFactory object that implements the specified
* algorithm. If the default provider package provides an implementation of
* the requested algorithm, an instance of KeyFactory containing
* that implementation is returned. If the algorithm is not available in the
* default package, other packages are searched.
*
* @param algorithm the name of the requested key algorithm. See Appendix A
* in the Java Cryptography Architecture API Specification & Reference
* for information about standard algorithm names.
* @return a KeyFactory object for the specified algorithm.
* @throws NoSuchAlgorithmException if the requested algorithm is not
* available in the default provider package or any of the other provider
* packages that were searched.
*/
public static KeyFactory getInstance(String algorithm)
throws NoSuchAlgorithmException
{
Provider[] p = Security.getProviders();
for (int i = 0; i < p.length; i++)
try
{
return getInstance(algorithm, p[i]);
}
catch (NoSuchAlgorithmException ignored) {}
throw new NoSuchAlgorithmException(algorithm);
}
/**
* Generates a KeyFactory object for the specified algorithm
* from the specified provider.
*
* @param algorithm the name of the requested key algorithm. See Appendix A
* in the Java Cryptography Architecture API Specification & Reference
* for information about standard algorithm names.
* @param provider the name of the provider.
* @return a KeyFactory object for the specified algorithm.
* @throws NoSuchAlgorithmException if the algorithm is not available from
* the specified provider.
* @throws NoSuchProviderException if the provider has not been configured.
* @throws IllegalArgumentException if the provider name is null or empty.
* @see Provider
*/
public static KeyFactory getInstance(String algorithm, String provider)
throws NoSuchAlgorithmException, NoSuchProviderException
{
if (provider == null || provider.length() == 0)
throw new IllegalArgumentException("Illegal provider");
Provider p = Security.getProvider(provider);
if (p == null)
throw new NoSuchProviderException();
return getInstance(algorithm, p);
}
/**
* Generates a KeyFactory object for the specified algorithm from
* the specified provider. Note: the provider doesn't have to be
* registered.
*
* @param algorithm the name of the requested key algorithm. See Appendix A
* in the Java Cryptography Architecture API Specification & Reference for
* information about standard algorithm names.
* @param provider the provider.
* @return a KeyFactory object for the specified algorithm.
* @throws NoSuchAlgorithmException if the algorithm is not available from
* the specified provider.
* @throws IllegalArgumentException if the provider is
* null.
* @since 1.4
* @see Provider
*/
public static KeyFactory getInstance(String algorithm, Provider provider)
throws NoSuchAlgorithmException
{
if (provider == null)
throw new IllegalArgumentException("Illegal provider");
try
{
return new KeyFactory((KeyFactorySpi)
Engine.getInstance(KEY_FACTORY, algorithm, provider),
provider, algorithm);
}
catch (java.lang.reflect.InvocationTargetException ite)
{
throw new NoSuchAlgorithmException(algorithm);
}
catch (ClassCastException cce)
{
throw new NoSuchAlgorithmException(algorithm);
}
}
/**
* Returns the provider of this key factory object.
*
* @return the provider of this key factory object.
*/
public final Provider getProvider()
{
return provider;
}
/**
* Gets the name of the algorithm associated with this KeyFactory.
*
* @return the name of the algorithm associated with this
* KeyFactory.
*/
public final String getAlgorithm()
{
return algorithm;
}
/**
* Generates a public key object from the provided key specification (key
* material).
*
* @param keySpec the specification (key material) of the public key.
* @return the public key.
* @throws InvalidKeySpecException if the given key specification is
* inappropriate for this key factory to produce a public key.
*/
public final PublicKey generatePublic(KeySpec keySpec)
throws InvalidKeySpecException
{
return keyFacSpi.engineGeneratePublic(keySpec);
}
/**
* Generates a private key object from the provided key specification (key
* material).
*
* @param keySpec the specification (key material) of the private key.
* @return the private key.
* @throws InvalidKeySpecException if the given key specification is
* inappropriate for this key factory to produce a private key.
*/
public final PrivateKey generatePrivate(KeySpec keySpec)
throws InvalidKeySpecException
{
return keyFacSpi.engineGeneratePrivate(keySpec);
}
/**
* Returns a specification (key material) of the given key object.
* keySpec identifies the specification class in which the key
* material should be returned. It could, for example, be
* DSAPublicKeySpec.class, to indicate that the key material
* should be returned in an instance of the {@link
* java.security.spec.DSAPublicKeySpec} class.
*
* @param key the key.
* @param keySpec the specification class in which the key material should be
* returned.
* @return the underlying key specification (key material) in an instance of
* the requested specification class.
* @throws InvalidKeySpecException if the requested key specification is
* inappropriate for the given key, or the given key cannot be processed
* (e.g., the given key has an unrecognized algorithm or format).
*/
public final KeySpec getKeySpec(Key key, Class keySpec)
throws InvalidKeySpecException
{
return keyFacSpi.engineGetKeySpec(key, keySpec);
}
/**
* Translates a key object, whose provider may be unknown or potentially
* untrusted, into a corresponding key object of this key factory.
*
* @param key the key whose provider is unknown or untrusted.
* @return the translated key.
* @throws InvalidKeyException if the given key cannot be processed by this
* key factory.
*/
public final Key translateKey(Key key) throws InvalidKeyException
{
return keyFacSpi.engineTranslateKey(key);
}
}