javax.crypto.KeyGenerator Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
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.Security;
import java.security.spec.AlgorithmParameterSpec;
import org.apache.harmony.security.fortress.Engine;
/**
* This class provides the public API for generating symmetric cryptographic
* keys.
*/
public class KeyGenerator {
// Used to access common engine functionality
private static final Engine ENGINE = new Engine("KeyGenerator");
// Store SecureRandom
private static final SecureRandom RANDOM = new SecureRandom();
// Store used provider
private final Provider provider;
// Store used spi implementation
private final KeyGeneratorSpi spiImpl;
// Store used algorithm name
private final String algorithm;
/**
* Creates a new {@code KeyGenerator} instance.
*
* @param keyGenSpi
* the implementation delegate.
* @param provider
* the implementation provider.
* @param algorithm
* the name of the algorithm.
*/
protected KeyGenerator(KeyGeneratorSpi keyGenSpi, Provider provider,
String algorithm) {
this.provider = provider;
this.algorithm = algorithm;
this.spiImpl = keyGenSpi;
}
/**
* Returns the name of the key generation algorithm.
*
* @return the name of the key generation algorithm.
*/
public final String getAlgorithm() {
return algorithm;
}
/**
* Returns the provider of this {@code KeyGenerator} instance.
*
* @return the provider of this {@code KeyGenerator} instance.
*/
public final Provider getProvider() {
return provider;
}
/**
* Creates a new {@code KeyGenerator} instance that provides the specified
* key algorithm,
*
* @param algorithm
* the name of the requested key algorithm
* @return the new {@code KeyGenerator} instance.
* @throws NoSuchAlgorithmException
* if the specified algorithm is not available by any provider.
* @throws NullPointerException
* if {@code algorithm} is {@code null}.
*/
public static final KeyGenerator getInstance(String algorithm)
throws NoSuchAlgorithmException {
if (algorithm == null) {
throw new NullPointerException("algorithm == null");
}
Engine.SpiAndProvider sap = ENGINE.getInstance(algorithm, null);
return new KeyGenerator((KeyGeneratorSpi) sap.spi, sap.provider, algorithm);
}
/**
* Creates a new {@code KeyGenerator} instance that provides the specified
* key algorithm from the specified provider.
*
* @param algorithm
* the name of the requested key algorithm.
* @param provider
* the name of the provider that is providing the algorithm.
* @return the new {@code KeyGenerator} instance.
* @throws NoSuchAlgorithmException
* if the specified algorithm is not provided by the specified
* provider.
* @throws NoSuchProviderException
* if the specified provider is not available.
* @throws IllegalArgumentException
* if the specified provider is name is {@code null} or empty.
* @throws NullPointerException
* if the specified algorithm name is {@code null}.
*/
public static final KeyGenerator getInstance(String algorithm,
String provider) throws NoSuchAlgorithmException, NoSuchProviderException {
if (provider == null || provider.isEmpty()) {
throw new IllegalArgumentException("Provider is null or empty");
}
Provider impProvider = Security.getProvider(provider);
if (impProvider == null) {
throw new NoSuchProviderException(provider);
}
return getInstance(algorithm, impProvider);
}
/**
* Creates a new {@code KeyGenerator} instance that provides the specified
* key algorithm from the specified provider.
*
* @param algorithm
* the name of the requested key algorithm.
* @param provider
* the provider that is providing the algorithm
* @return the new {@code KeyGenerator} instance.
* @throws NoSuchAlgorithmException
* if the specified algorithm is not provided by the specified
* provider.
* @throws IllegalArgumentException
* if the specified provider is {@code null}.
* @throws NullPointerException
* if the specified algorithm name is {@code null}.
*/
public static final KeyGenerator getInstance(String algorithm,
Provider provider) throws NoSuchAlgorithmException {
if (provider == null) {
throw new IllegalArgumentException("provider == null");
}
if (algorithm == null) {
throw new NullPointerException("algorithm == null");
}
Object spi = ENGINE.getInstance(algorithm, provider, null);
return new KeyGenerator((KeyGeneratorSpi) spi, provider, algorithm);
}
/**
* Generates a secret key.
*
* @return the generated secret key.
*/
public final SecretKey generateKey() {
return spiImpl.engineGenerateKey();
}
/**
* Initializes this {@code KeyGenerator} instance with the specified
* algorithm parameters.
*
* @param params
* the parameters for the key generation algorithm.
* @throws InvalidAlgorithmParameterException
* if the parameters cannot be used to initialize this key
* generator algorithm.
*/
public final void init(AlgorithmParameterSpec params)
throws InvalidAlgorithmParameterException {
spiImpl.engineInit(params, RANDOM);//new SecureRandom());
}
/**
* Initializes this {@code KeyGenerator} instance with the specified
* algorithm parameters and randomness source.
*
* @param params
* the parameters for the key generation algorithm.
* @param random
* the randomness source for any random bytes.
* @throws InvalidAlgorithmParameterException
* if the parameters cannot be uses to initialize this key
* generator algorithm.
*/
public final void init(AlgorithmParameterSpec params, SecureRandom random)
throws InvalidAlgorithmParameterException {
spiImpl.engineInit(params, random);
}
/**
* Initializes this {@code KeyGenerator} instance for the specified key size
* (in bits).
*
* @param keysize
* the size of the key (in bits).
*/
public final void init(int keysize) {
spiImpl.engineInit(keysize, RANDOM);//new SecureRandom());
}
/**
* Initializes this {@code KeyGenerator} instance for the specified key size
* (in bits) using the specified randomness source.
*
* @param keysize
* the size of the key (in bits).
* @param random
* the randomness source for any random bytes.
*/
public final void init(int keysize, SecureRandom random) {
spiImpl.engineInit(keysize, random);
}
/**
* Initializes this {@code KeyGenerator} with the specified randomness
* source.
*
* @param random
* the randomness source for any random bytes.
*/
public final void init(SecureRandom random) {
spiImpl.engineInit(random);
}
}