From 9c401cddf07afe7340148ba626a7a7a5dbb0cf74 Mon Sep 17 00:00:00 2001 From: "Aaron M. Renn" Date: Sun, 18 Jul 1999 21:39:52 +0000 Subject: Initial checking of Mark Benvenuto's security code --- java/security/KeyFactory.java | 216 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 216 insertions(+) create mode 100644 java/security/KeyFactory.java (limited to 'java/security/KeyFactory.java') diff --git a/java/security/KeyFactory.java b/java/security/KeyFactory.java new file mode 100644 index 000000000..fd882bcd8 --- /dev/null +++ b/java/security/KeyFactory.java @@ -0,0 +1,216 @@ +/* KeyFactory.java --- Key Factory Class + + Copyright (c) 1999 by Free Software Foundation, Inc. + Written by Mark Benvenuto + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU Library General Public License as published + by the Free Software Foundation, version 2. (see COPYING.LIB) + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software Foundation + Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307 USA. */ + +package java.security; +import java.security.spec.KeySpec; +import java.security.spec.InvalidKeySpecException; + +/** + Key factories are used to convert keys (opaque cryptographic + keys of type Key) into key specifications (transparent + representations of the underlying key material). + + Key factories are bi-directional. They allow a key class + to be converted into a key specification (key material) and + back again. + + For example DSA public keys can be specified as + DSAPublicKeySpec or X509EncodedKeySpec. The key factory + translate these key specifications. + + @since JDK 1.2 + + @author Mark Benvenuto +*/ +public class KeyFactory +{ + +private KeyFactorySpi keyFacSpi; +private Provider provider; +private String algorithm; + +/** + Constructs a new keyFactory with the specified parameters. + + @param keyFacSpi Key Factory SPI to use + @param provider the provider of the Key Factory SPI + @param algorithm the name of the key algorithm for this key factory +*/ +protected KeyFactory(KeyFactorySpi keyFacSpi, Provider provider, String algorithm) +{ + this.keyFacSpi = keyFacSpi; + this.provider = provider; + this.algorithm = algorithm; +} + +/** + Gets an instance of the KeyFactory class representing + the specified key factory. If the algorithm is not + found then, it throws NoSuchAlgorithmException. + + @param algorithm the name of algorithm to choose + @return a KeyFactory repesenting the desired algorithm + + @throws NoSuchAlgorithmException if the algorithm is not implemented by providers +*/ +public static KeyFactory getInstance(String algorithm) + throws NoSuchAlgorithmException +{ + Provider[] p = Security.getProviders (); + + for (int i = 0; i < p.length; i++) + { + String classname = p[i].getProperty ("KeyFactory." + algorithm); + if (classname != null) + return getInstance (classname, algorithm, p[i]); + } + + throw new NoSuchAlgorithmException (algorithm); +} + +/** + Gets an instance of the KeyFactory class representing + the specified key factory from the specified provider. + If the algorithm is not found then, it throws + NoSuchAlgorithmException. If the provider is not found, then + it throws NoSuchProviderException. + + @param algorithm the name of algorithm to choose + @param provider the name of the provider to find the algorithm in + @return a KeyFactory repesenting the desired algorithm + + @throws NoSuchAlgorithmException if the algorithm is not implemented by the provider + @throws NoSuchProviderException if the provider is not found +*/ +public static KeyFactory getInstance(String algorithm, String provider) + throws NoSuchAlgorithmException, NoSuchProviderException +{ + Provider p = Security.getProvider(provider); + if( p == null) + throw new NoSuchProviderException(); + + return getInstance (p.getProperty ("KeyFactory." + algorithm), + algorithm, p); +} + +private static KeyFactory getInstance (String classname, + String algorithm, + Provider provider) + throws NoSuchAlgorithmException +{ + + try { + return new KeyFactory( (KeyFactorySpi)Class.forName( classname ).newInstance(), provider, algorithm ); + } catch( ClassNotFoundException cnfe) { + throw new NoSuchAlgorithmException("Class not found"); + } catch( InstantiationException ie) { + throw new NoSuchAlgorithmException("Class instantiation failed"); + } catch( IllegalAccessException iae) { + throw new NoSuchAlgorithmException("Illegal Access"); + } +} + +/** + Gets the provider that the class is from. + + @return the provider of this class +*/ +public final Provider getProvider() +{ + return provider; +} + +/** + Returns the name of the algorithm used + + @return A string with the name of the algorithm +*/ +public final String getAlgorithm() +{ + return algorithm; +} + +/** + Generates a public key from the provided key specification. + + @param keySpec key specification + + @return the public key + + @throws InvalidKeySpecException invalid key specification 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 from the provided key specification. + + @param keySpec key specification + + @return the private key + + @throws InvalidKeySpecException invalid key specification for + this key factory to produce a private key +*/ +public final PrivateKey generatePrivate(KeySpec keySpec) throws InvalidKeySpecException +{ + return keyFacSpi.engineGeneratePrivate( keySpec ); +} + +/** + Returns a key specification for the given key. keySpec + identifies the specification class to return the key + material in. + + @param key the key + @param keySpec the specification class to return the + key material in. + + @return the key specification in an instance of the requested + specification class + + @throws InvalidKeySpecException the requested key specification + is inappropriate for this key or the key is + unrecognized. +*/ +public final KeySpec getKeySpec(Key key, Class keySpec) + throws InvalidKeySpecException +{ + return keyFacSpi.engineGetKeySpec( key, keySpec ); +} + +/** + Translates the key from an unknown or untrusted provider + into a key for this key factory. + + @param the key from an unknown or untrusted provider + + @return the translated key + + @throws InvalidKeySpecException if the key cannot be + processed by this key factory +*/ +public final Key translateKey(Key key) throws InvalidKeyException +{ + return keyFacSpi.engineTranslateKey( key ); +} + +} -- cgit v1.2.1