1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123
/* * @(#)KeyFactorySpi.java 1.13 05/11/17 * * Copyright 2006 Sun Microsystems, Inc. All rights reserved. * SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms. */ package java.security; import java.security.spec.KeySpec; import java.security.spec.InvalidKeySpecException; /** * This class defines the <i>Service Provider Interface</i> (<b>SPI</b>) * for the <code>KeyFactory</code> class. * All the abstract methods in this class must be implemented by each * cryptographic service provider who wishes to supply the implementation * of a key factory for a particular algorithm. * * <P> Key factories are used to convert <I>keys</I> (opaque * cryptographic keys of type <code>Key</code>) into <I>key specifications</I> * (transparent representations of the underlying key material), and vice * versa. * * <P> 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. * * <P> Multiple compatible key specifications may exist for the same key. * For example, a DSA public key may be specified using * <code>DSAPublicKeySpec</code> or * <code>X509EncodedKeySpec</code>. A key factory can be used to translate * between compatible key specifications. * * <P> A provider should document all the key specifications supported by its * key factory. * * @author Jan Luehe * * @version 1.13, 11/17/05 * * @see KeyFactory * @see Key * @see PublicKey * @see PrivateKey * @see java.security.spec.KeySpec * @see java.security.spec.DSAPublicKeySpec * @see java.security.spec.X509EncodedKeySpec * * @since 1.2 */ public abstract class KeyFactorySpi { /** * Generates a public key object from the provided key * specification (key material). * * @param keySpec the specification (key material) of the public key. * * @return the public key. * * @exception InvalidKeySpecException if the given key specification * is inappropriate for this key factory to produce a public key. */ protected abstract PublicKey engineGeneratePublic(KeySpec keySpec) throws InvalidKeySpecException; /** * Generates a private key object from the provided key * specification (key material). * * @param keySpec the specification (key material) of the private key. * * @return the private key. * * @exception InvalidKeySpecException if the given key specification * is inappropriate for this key factory to produce a private key. */ protected abstract PrivateKey engineGeneratePrivate(KeySpec keySpec) throws InvalidKeySpecException; /** * Returns a specification (key material) of the given key * object. * <code>keySpec</code> identifies the specification class in which * the key material should be returned. It could, for example, be * <code>DSAPublicKeySpec.class</code>, to indicate that the * key material should be returned in an instance of the * <code>DSAPublicKeySpec</code> class. * * @param key the key. * * @param keySpec the specification class in which * the key material should be returned. * * @return the underlying key specification (key material) in an instance * of the requested specification class. * @exception InvalidKeySpecException if the requested key specification is * inappropriate for the given key, or the given key cannot be dealt with * (e.g., the given key has an unrecognized format). */ protected abstract <T extends KeySpec> T engineGetKeySpec(Key key, Class<T> keySpec) throws InvalidKeySpecException; /** * Translates a key object, whose provider may be unknown or * potentially untrusted, into a corresponding key object of this key * factory. * * @param key the key whose provider is unknown or untrusted. * * @return the translated key. * * @exception InvalidKeyException if the given key cannot be processed * by this key factory. */ protected abstract Key engineTranslateKey(Key key) throws InvalidKeyException; }