The AlgorithmParameterGenerator class is used to generate a
* set of parameters to be used with a certain algorithm. Parameter generators
* are constructed using the getInstance() factory methods (static
* methods that return instances of a given class).
The object that will generate the parameters can be initialized in two * different ways: in an algorithm-independent manner, or in an * algorithm-specific manner:
* *In case the client does not explicitly initialize the
* AlgorithmParameterGenerator (via a call to an init()
* method), each provider must supply (and document) a default initialization.
* For example, the GNU provider uses a default modulus prime size of
* 1024 bits for the generation of DSA parameters.
*
* @author Mark Benvenuto
* @since 1.2
* @see AlgorithmParameters
* @see AlgorithmParameterSpec
*/
public class AlgorithmParameterGenerator
{
/** Service name for algorithm parameter generators. */
private static final String ALGORITHM_PARAMETER_GENERATOR =
"AlgorithmParameterGenerator";
private AlgorithmParameterGeneratorSpi paramGenSpi;
private Provider provider;
private String algorithm;
/**
* Creates an AlgorithmParameterGenerator object.
*
* @param paramGenSpi the delegate.
* @param provider the provider.
* @param algorithm the algorithm.
*/
protected AlgorithmParameterGenerator(AlgorithmParameterGeneratorSpi
paramGenSpi, Provider provider,
String algorithm)
{
this.paramGenSpi = paramGenSpi;
this.provider = provider;
this.algorithm = algorithm;
}
/**
* Returns the standard name of the algorithm this parameter generator is
* associated with.
*
* @return the string name of the algorithm.
*/
public final String getAlgorithm()
{
return algorithm;
}
/**
* Generates an AlgorithmParameterGenerator object that
* implements the specified digest algorithm. If the default provider package
* provides an implementation of the requested digest algorithm, an instance
* of AlgorithmParameterGenerator containing that implementation
* is returned. If the algorithm is not available in the default package,
* other packages are searched.
*
* @param algorithm the string name of the algorithm this parameter generator
* is associated with.
* @return the new AlgorithmParameterGenerator object.
* @throws NoSuchAlgorithmException if the algorithm is not available in the
* environment.
*/
public static AlgorithmParameterGenerator 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 e)
{
// Ignore.
}
throw new NoSuchAlgorithmException(algorithm);
}
/**
* Generates an AlgorithmParameterGenerator object for the
* requested algorithm, as supplied from the specified provider, if such a
* parameter generator is available from the provider.
*
* @param algorithm the string name of the algorithm.
* @param provider the string name of the provider.
* @return the new AlgorithmParameterGenerator object.
* @throws NoSuchAlgorithmException if the algorithm is not
* available from the provider.
* @throws NoSuchProviderException if the provider is not
* available in the environment.
* @throws IllegalArgumentException if the provider name is
* null or empty.
* @see Provider
*/
public static AlgorithmParameterGenerator 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 an AlgorithmParameterGenerator object for the requested
* algorithm, as supplied from the specified provider, if such a parameter
* generator is available from the provider. Note: the provider
* doesn't have to be registered.
*
* @param algorithm the string name of the algorithm.
* @param provider the provider.
* @return the new AlgorithmParameterGenerator object.
* @throws NoSuchAlgorithmException if the algorithm is not available from
* the provider.
* @throws IllegalArgumentException if the provider is null.
* @since 1.4
* @see Provider
*/
public static AlgorithmParameterGenerator getInstance(String algorithm,
Provider provider)
throws NoSuchAlgorithmException
{
if (provider == null)
throw new IllegalArgumentException("Illegal provider");
try
{
return new AlgorithmParameterGenerator(
(AlgorithmParameterGeneratorSpi) Engine.getInstance(
ALGORITHM_PARAMETER_GENERATOR, 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 algorithm parameter generator object.
*
* @return the provider of this algorithm parameter generator object.
*/
public final Provider getProvider()
{
return provider;
}
/**
* Initializes this parameter generator for a certain size. To create
* the parameters, the {@link SecureRandom} implementation of the
* highest-priority installed provider is used as the source of randomness.
* (If none of the installed providers supply an implementation of
* {@link SecureRandom}, a system-provided source of randomness is used.)
*
* @param size the size (number of bits).
*/
public final void init(int size)
{
init(size, new SecureRandom());
}
/**
* Initializes this parameter generator for a certain size and source of
* randomness.
*
* @param size the size (number of bits).
* @param random the source of randomness.
*/
public final void init(int size, SecureRandom random)
{
paramGenSpi.engineInit(size, random);
}
/**
* Initializes this parameter generator with a set of algorithm-specific
* parameter generation values. To generate the parameters, the {@link
* SecureRandom} implementation of the highest-priority installed provider is
* used as the source of randomness. (If none of the installed providers
* supply an implementation of {@link SecureRandom}, a system-provided source
* of randomness is used.)
*
* @param genParamSpec the set of algorithm-specific parameter generation
* values.
* @throws InvalidAlgorithmParameterException if the given parameter
* generation values are inappropriate for this parameter generator.
*/
public final void init(AlgorithmParameterSpec genParamSpec)
throws InvalidAlgorithmParameterException
{
init(genParamSpec, new SecureRandom());
}
/**
* Initializes this parameter generator with a set of algorithm-specific
* parameter generation values.
*
* @param genParamSpec the set of algorithm-specific parameter generation
* values.
* @param random the source of randomness.
* @throws InvalidAlgorithmParameterException if the given parameter
* generation values are inappropriate for this parameter generator.
*/
public final void init(AlgorithmParameterSpec genParamSpec,
SecureRandom random)
throws InvalidAlgorithmParameterException
{
paramGenSpi.engineInit(genParamSpec, random);
}
/**
* Generates the parameters.
*
* @return the new {@link AlgorithmParameters} object.
*/
public final AlgorithmParameters generateParameters()
{
return paramGenSpi.engineGenerateParameters();
}
}