java.security.Key Maven / Gradle / Ivy

/*
This is not an official specification document, and usage is restricted.


NOTICE





(c) 2005-2007 Sun Microsystems, Inc. All Rights Reserved.

Neither this file nor any files generated from it describe a complete
specification, and they may only be used as described below. For
example, no permission is given for you to incorporate this file, in
whole or in part, in an implementation of a Java specification.

Sun Microsystems Inc. owns the copyright in this file and it is provided
to you for informative, as opposed to normative, use. The file and any
files generated from it may be used to generate other informative
documentation, such as a unified set of documents of API signatures for
a platform that includes technologies expressed as Java APIs. The file
may also be used to produce "compilation stubs," which allow
applications to be compiled and validated for such platforms.

Any work generated from this file, such as unified javadocs or compiled
stub files, must be accompanied by this notice in its entirety.

This work corresponds to the API signatures of JSR 219: Foundation
Profile 1.1. In the event of a discrepency between this work and the
JSR 219 specification, which is available at
http://www.jcp.org/en/jsr/detail?id=219, the latter takes precedence.
*/


  


package java.security;

/** 
 * The Key interface is the top-level interface for all keys. It
 * defines the functionality shared by all key objects. All keys
 * have three characteristics:
 *
 * 
 *
 * An Algorithm
 *
 * This is the key algorithm for that key. The key algorithm is usually
 * an encryption or asymmetric operation algorithm (such as DSA or
 * RSA), which will work with those algorithms and with related
 * algorithms (such as MD5 with RSA, SHA-1 with RSA, Raw DSA, etc.)
 * The name of the algorithm of a key is obtained using the
 * {@link #getAlgorithm() getAlgorithm} method.

 *
 * An Encoded Form
 *
 * This is an external encoded form for the key used when a standard
 * representation of the key is needed outside the Java Virtual Machine,
 * as when transmitting the key to some other party. The key
 * is encoded according to a standard format (such as 
 * X.509 SubjectPublicKeyInfo or PKCS#8), and
 * is returned using the {@link #getEncoded() getEncoded} method.
 * Note: The syntax of the ASN.1 type SubjectPublicKeyInfo 
 * is defined as follows:
 *
 * 
 * SubjectPublicKeyInfo ::= SEQUENCE {
 *   algorithm AlgorithmIdentifier,
 *   subjectPublicKey BIT STRING }
 *
 * AlgorithmIdentifier ::= SEQUENCE {
 *   algorithm OBJECT IDENTIFIER,
 *   parameters ANY DEFINED BY algorithm OPTIONAL }
 * 
 * 
 * For more information, see 
 * RFC 2459: 
 * Internet X.509 Public Key Infrastructure Certificate and CRL Profile.
 * 
 *
 * 
A Format
 *
 * This is the name of the format of the encoded key. It is returned
 * by the {@link #getFormat() getFormat} method.

 *
 * 
 *
 * Keys are generally obtained through key generators, certificates,
 * or various Identity classes used to manage keys.
 * Keys may also be obtained from key specifications (transparent
 * representations of the underlying key material) through the use of a key
 * factory (see {@link KeyFactory}).
 * NOTE: java.security.Identity is found in J2ME CDC profiles such as 
 * J2ME Foundation Profile.
 *
 * @see PublicKey
 * @see PrivateKey
 * @see KeyPair
 * @see KeyPairGenerator
 * @see KeyFactory
 * @see java.security.spec.KeySpec
 * @see Identity
 * @see Signer
 *
 * @version 1.47 00/02/02
 * @author Benjamin Renaud
 */
public interface Key extends java.io.Serializable
{
    /** 
     * The class fingerprint that is set to indicate 
     * serialization compatibility with a previous 
     * version of the class.
     */
    public static final long serialVersionUID = 6603384152749567654L;

    /** 
     * Returns the standard algorithm name for this key. For
     * example, "DSA" would indicate that this key is a DSA key.
     * See Appendix A in the 
     * Java Cryptography Architecture API Specification & Reference 
     * for information about standard algorithm names.
     *
     * @return the name of the algorithm associated with this key.
     */
    public String getAlgorithm();

    /** 
     * Returns the name of the primary encoding format of this key,
     * or null if this key does not support encoding.
     * The primary encoding format is
     * named in terms of the appropriate ASN.1 data format, if an
     * ASN.1 specification for this key exists.
     * For example, the name of the ASN.1 data format for public
     * keys is SubjectPublicKeyInfo, as
     * defined by the X.509 standard; in this case, the returned format is
     * "X.509". Similarly,
     * the name of the ASN.1 data format for private keys is
     * PrivateKeyInfo,
     * as defined by the PKCS #8 standard; in this case, the returned format is
     * "PKCS#8".
     *
     * @return the primary encoding format of the key.
     */
    public String getFormat();

    /** 
     * Returns the key in its primary encoding format, or null
     * if this key does not support encoding.
     *
     * @return the encoded key, or null if the key does not support
     * encoding.
     */
    public byte[] getEncoded();
}