java.security
public class: KeyFactory [javadoc |
source]
java.lang.Object
java.security.KeyFactory
Key factories are used to convert
keys (opaque
cryptographic keys of type
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
DSAPublicKeySpec or
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);
Every implementation of the Java platform is required to support the
following standard KeyFactory algorithms:
These algorithms are described in the
KeyFactory section of the
Java Cryptography Architecture Standard Algorithm Name Documentation.
Consult the release documentation for your implementation to see if any
other algorithms are supported.
| Constructor: |
|---|
 protected KeyFactory(KeyFactorySpi keyFacSpi,
Provider provider,
String algorithm) {
this.spi = keyFacSpi;
this.provider = provider;
this.algorithm = algorithm;
}
Creates a KeyFactory object. Parameters:
keyFacSpi - the delegate
provider - the provider
algorithm - the name of the algorithm
to associate with this KeyFactory
|
| Methods from java.lang.Object: |
|---|
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Method from java.security.KeyFactory Detail: |
|---|
public final PrivateKey generatePrivate(KeySpec keySpec) throws InvalidKeySpecException {
if (serviceIterator == null) {
return spi.engineGeneratePrivate(keySpec);
}
Exception failure = null;
KeyFactorySpi mySpi = spi;
do {
try {
return mySpi.engineGeneratePrivate(keySpec);
} catch (Exception e) {
if (failure == null) {
failure = e;
}
mySpi = nextSpi(mySpi);
}
} while (mySpi != null);
if (failure instanceof RuntimeException) {
throw (RuntimeException)failure;
}
if (failure instanceof InvalidKeySpecException) {
throw (InvalidKeySpecException)failure;
}
throw new InvalidKeySpecException
("Could not generate private key", failure);
} Generates a private key object from the provided key specification
(key material). |
public final PublicKey generatePublic(KeySpec keySpec) throws InvalidKeySpecException {
if (serviceIterator == null) {
return spi.engineGeneratePublic(keySpec);
}
Exception failure = null;
KeyFactorySpi mySpi = spi;
do {
try {
return mySpi.engineGeneratePublic(keySpec);
} catch (Exception e) {
if (failure == null) {
failure = e;
}
mySpi = nextSpi(mySpi);
}
} while (mySpi != null);
if (failure instanceof RuntimeException) {
throw (RuntimeException)failure;
}
if (failure instanceof InvalidKeySpecException) {
throw (InvalidKeySpecException)failure;
}
throw new InvalidKeySpecException
("Could not generate public key", failure);
} Generates a public key object from the provided key specification
(key material). |
public final String getAlgorithm() {
return this.algorithm;
} Gets the name of the algorithm
associated with this KeyFactory. |
public static KeyFactory getInstance(String algorithm) throws NoSuchAlgorithmException {
return new KeyFactory(algorithm);
} Returns a KeyFactory object that converts
public/private keys of the specified algorithm.
This method traverses the list of registered security Providers,
starting with the most preferred Provider.
A new KeyFactory object encapsulating the
KeyFactorySpi implementation from the first
Provider that supports the specified algorithm is returned.
Note that the list of registered providers may be retrieved via
the Security.getProviders() method. |
public static KeyFactory getInstance(String algorithm,
String provider) throws NoSuchAlgorithmException, NoSuchProviderException {
Instance instance = GetInstance.getInstance("KeyFactory",
KeyFactorySpi.class, algorithm, provider);
return new KeyFactory((KeyFactorySpi)instance.impl,
instance.provider, algorithm);
} Returns a KeyFactory object that converts
public/private keys of the specified algorithm.
A new KeyFactory object encapsulating the
KeyFactorySpi implementation from the specified provider
is returned. The specified provider must be registered
in the security provider list.
Note that the list of registered providers may be retrieved via
the Security.getProviders() method. |
public static KeyFactory getInstance(String algorithm,
Provider provider) throws NoSuchAlgorithmException {
Instance instance = GetInstance.getInstance("KeyFactory",
KeyFactorySpi.class, algorithm, provider);
return new KeyFactory((KeyFactorySpi)instance.impl,
instance.provider, algorithm);
} Returns a KeyFactory object that converts
public/private keys of the specified algorithm.
A new KeyFactory object encapsulating the
KeyFactorySpi implementation from the specified Provider
object is returned. Note that the specified Provider object
does not have to be registered in the provider list. |
public final T getKeySpec(Key key,
Class<T> keySpec) throws InvalidKeySpecException {
if (serviceIterator == null) {
return spi.engineGetKeySpec(key, keySpec);
}
Exception failure = null;
KeyFactorySpi mySpi = spi;
do {
try {
return mySpi.engineGetKeySpec(key, keySpec);
} catch (Exception e) {
if (failure == null) {
failure = e;
}
mySpi = nextSpi(mySpi);
}
} while (mySpi != null);
if (failure instanceof RuntimeException) {
throw (RuntimeException)failure;
}
if (failure instanceof InvalidKeySpecException) {
throw (InvalidKeySpecException)failure;
}
throw new InvalidKeySpecException
("Could not get key spec", failure);
} 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
DSAPublicKeySpec class. |
public final Provider getProvider() {
synchronized (lock) {
// disable further failover after this call
serviceIterator = null;
return provider;
}
} Returns the provider of this key factory object. |
public final Key translateKey(Key key) throws InvalidKeyException {
if (serviceIterator == null) {
return spi.engineTranslateKey(key);
}
Exception failure = null;
KeyFactorySpi mySpi = spi;
do {
try {
return mySpi.engineTranslateKey(key);
} catch (Exception e) {
if (failure == null) {
failure = e;
}
mySpi = nextSpi(mySpi);
}
} while (mySpi != null);
if (failure instanceof RuntimeException) {
throw (RuntimeException)failure;
}
if (failure instanceof InvalidKeyException) {
throw (InvalidKeyException)failure;
}
throw new InvalidKeyException
("Could not translate key", failure);
} Translates a key object, whose provider may be unknown or potentially
untrusted, into a corresponding key object of this key factory. |