package javax.crypto; import java.security.InvalidAlgorithmParameterException; import java.security.NoSuchAlgorithmException; import java.security.NoSuchProviderException; import java.security.Provider; import java.security.SecureRandom; import java.security.spec.AlgorithmParameterSpec; /** * This class provides the functionality of a (symmetric) key generator. *
* Key generators are constructed using one of the getInstance
* class methods of this class.
*
* KeyGenerator objects are reusable, i.e., after a key has been * generated, the same KeyGenerator object can be re-used to generate further * keys. *
* There are two ways to generate a key: in an algorithm-independent manner, * and in an algorithm-specific manner. The only difference between the two is * the initialization of the object: * *
All key generators share the concepts of a keysize and a
* source of randomness.
* There is an
* init
* method in this KeyGenerator class that takes these two universally
* shared types of arguments. There is also one that takes just a
* keysize
argument, and uses the SecureRandom implementation
* of the highest-priority installed provider as the source of randomness
* (or a system-provided source of randomness if none of the installed
* providers supply a SecureRandom implementation), and one that takes just a
* source of randomness.
*
* Since no other parameters are specified when you call the above
* algorithm-independent init
methods, it is up to the
* provider what to do about the algorithm-specific parameters (if any) to be
* associated with each of the keys.
*
*
For situations where a set of algorithm-specific parameters already
* exists, there are two
* init
* methods that have an AlgorithmParameterSpec
* argument. One also has a SecureRandom
argument, while the
* other uses the SecureRandom implementation
* of the highest-priority installed provider as the source of randomness
* (or a system-provided source of randomness if none of the installed
* providers supply a SecureRandom implementation).
*
In case the client does not explicitly initialize the KeyGenerator
* (via a call to an init
method), each provider must
* supply (and document) a default initialization.
*
* @see SecretKey
*/
public class KeyGenerator
{
private KeyGeneratorSpi keyGenerator;
private Provider provider;
private String algorithm;
/**
* Creates a KeyGenerator object.
*
* @param keyGenSpi the delegate
* @param provider the provider
* @param algorithm the algorithm
*/
protected KeyGenerator(
KeyGeneratorSpi keyGenSpi,
Provider provider,
String algorithm)
{
this.keyGenerator = keyGenSpi;
this.provider = provider;
this.algorithm = algorithm;
}
/**
* Returns the algorithm name of this KeyGenerator
object.
*
* This is the same name that was specified in one of the
* getInstance
calls that created this
* KeyGenerator
object.
*
* @return the algorithm name of this KeyGenerator
object.
*/
public final String getAlgorithm()
{
return algorithm;
}
/**
* Generates a KeyGenerator
object for the specified algorithm.
* If the default provider package provides an implementation of the
* requested key generator, an instance of KeyGenerator
containing
* that implementation is returned. If the requested key generator is not available
* in the default provider package, other provider packages are searched.
*
* @param algorithm the standard name of the requested key algorithm. See Appendix A in the
* Java Cryptography Extension API Specification & Reference for information about standard
* algorithm names.
* @return the new KeyGenerator
object
* @exception NoSuchAlgorithmException if a key generator for the specified algorithm is not
* available in the default provider package or any of the other provider packages that were searched.
*/
public static final KeyGenerator getInstance(
String algorithm)
throws NoSuchAlgorithmException
{
try
{
JCEUtil.Implementation imp = JCEUtil.getImplementation("KeyGenerator", algorithm, (String) null);
if (imp == null)
{
throw new NoSuchAlgorithmException(algorithm + " not found");
}
KeyGenerator keyGen = new KeyGenerator((KeyGeneratorSpi)imp.getEngine(), imp.getProvider(), algorithm);
return keyGen;
}
catch (NoSuchProviderException e)
{
throw new NoSuchAlgorithmException(algorithm + " not found");
}
}
/**
* Generates a KeyGenerator
object for the specified key
* algorithm from the specified provider.
*
* @param algorithm the standard name of the requested key algorithm. See Appendix A in the
* Java Cryptography Extension API Specification & Reference for information about standard
* algorithm names.
* @param provider the provider
* @return the new KeyGenerator
object
* @exception NoSuchAlgorithmException if a key generator for the specified algorithm is not
* available from the specified provider.
*/
public static final KeyGenerator getInstance(
String algorithm,
Provider provider)
throws NoSuchAlgorithmException
{
if (provider == null)
{
throw new IllegalArgumentException("No provider specified to KeyGenerator.getInstance()");
}
JCEUtil.Implementation imp = JCEUtil.getImplementation("KeyGenerator", algorithm, provider);
if (imp == null)
{
throw new NoSuchAlgorithmException(algorithm + " not found");
}
KeyGenerator keyGen = new KeyGenerator((KeyGeneratorSpi)imp.getEngine(), imp.getProvider(), algorithm);
return keyGen;
}
/**
* Generates a KeyGenerator
object for the specified key
* algorithm from the specified provider.
*
* @param algorithm the standard name of the requested key algorithm. See Appendix A in the
* Java Cryptography Extension API Specification & Reference for information about standard
* algorithm names.
* @param provider the name of the provider
* @return the new KeyGenerator
object
* @exception NoSuchAlgorithmException if a key generator for the specified algorithm is not
* available from the specified provider.
* @exception NoSuchProviderException if the specified provider has not been configured.
*/
public static final KeyGenerator getInstance(
String algorithm,
String provider)
throws NoSuchAlgorithmException, NoSuchProviderException
{
if (provider == null)
{
throw new IllegalArgumentException("No provider specified to KeyGenerator.getInstance()");
}
JCEUtil.Implementation imp = JCEUtil.getImplementation("KeyGenerator", algorithm, provider);
if (imp == null)
{
throw new NoSuchAlgorithmException(algorithm + " not found");
}
KeyGenerator keyGen = new KeyGenerator((KeyGeneratorSpi)imp.getEngine(), imp.getProvider(), algorithm);
return keyGen;
}
/**
* Returns the provider of this KeyGenerator
object.
*
* @return the provider of this KeyGenerator
object
*/
public final Provider getProvider()
{
return provider;
}
/**
* Initializes this key generator.
*
* @param random the source of randomness for this generator
*/
public final void init(
SecureRandom random)
{
keyGenerator.engineInit(random);
}
/**
* Initializes this key generator with the specified parameter set.
*
* If this key generator requires any random bytes, it will get them
* using the *
* SecureRandom
implementation of the highest-priority installed
* provider as the source of randomness.
* (If none of the installed providers supply an implementation of
* SecureRandom, a system-provided source of randomness will be used.)
*
* @param params the key generation parameters
* @exception InvalidAlgorithmParameterException if the given parameters are inappropriate
* for this key generator
*/
public final void init(
AlgorithmParameterSpec params)
throws InvalidAlgorithmParameterException
{
keyGenerator.engineInit(params, new SecureRandom());
}
/**
* Initializes this key generator with the specified parameter set and a user-provided source of randomness.
*
* @param params the key generation parameters
* @param random the source of randomness for this key generator
* @exception InvalidAlgorithmParameterException if params
is inappropriate for this key generator
*/
public final void init(
AlgorithmParameterSpec params,
SecureRandom random)
throws InvalidAlgorithmParameterException
{
keyGenerator.engineInit(params, random);
}
/**
* Initializes this key generator for a certain keysize.
*
* If this key generator requires any random bytes, it will get them using the
*
* SecureRandom
implementation of the highest-priority installed provider as
* the source of randomness. (If none of the installed providers supply an implementation of
* SecureRandom, a system-provided source of randomness will be used.)
*
* @param keysize the keysize. This is an algorithm-specific metric, specified in number of bits.
* @exception InvalidParameterException if the keysize is wrong or not supported.
*/
public final void init(
int keysize)
{
keyGenerator.engineInit(keysize, new SecureRandom());
}
/**
* Initializes this key generator for a certain keysize, using a user-provided source of randomness.
*
* @param keysize the keysize. This is an algorithm-specific metric, specified in number of bits.
* @param random the source of randomness for this key generator
* @exception InvalidParameterException if the keysize is wrong or not supported.
*/
public final void init(
int keysize,
SecureRandom random)
{
keyGenerator.engineInit(keysize, random);
}
/**
* Generates a secret key.
*
* @return the new key
*/
public final SecretKey generateKey()
{
return keyGenerator.engineGenerateKey();
}
}