java.security: public class: KeyRep

java.security
public class: KeyRep [javadoc | source]

java.lang.Object
   java.security.KeyRep

All Implemented Interfaces:
java$io$Serializable

Standardized representation for serialized Key objects.

Note that a serialized Key may contain sensitive information which should not be exposed in untrusted environments. See the Security Appendix of the Serialization Specification for more information.

Also see:

Key

KeyFactory

javax.crypto.spec.SecretKeySpec

java.security.spec.X509EncodedKeySpec

java.security.spec.PKCS8EncodedKeySpec

since: 1.5 -

Nested Class Summary:
public static enum class	KeyRep.Type	Key type.

Constructor:

Constructor:
public KeyRep(Type type, String algorithm, String format, byte[] encoded) { if (type == null \|\| algorithm == null \|\| format == null \|\| encoded == null) { throw new NullPointerException("invalid null input(s)"); } this.type = type; this.algorithm = algorithm; this.format = format.toUpperCase(); this.encoded = encoded.clone(); } Construct the alternate Key class. Parameters: `type` - either one of Type.SECRET, Type.PUBLIC, or Type.PRIVATE `algorithm` - the algorithm returned from `Key.getAlgorithm()` `format` - the encoding format returned from `Key.getFormat()` `encoded` - the encoded bytes returned from `Key.getEncoded()` Throws: `NullPointerException` - if type is `null`, if algorithm is `null`, if format is `null`, or if encoded is `null` exception: `NullPointerException` - if type is `null`, if algorithm is `null`, if format is `null`, or if encoded is `null`

 public KeyRep(Type type,
    String algorithm,
    String format,
    byte[] encoded) {
        if (type == null || algorithm == null ||
            format == null || encoded == null) {
            throw new NullPointerException("invalid null input(s)");
        }
        this.type = type;
        this.algorithm = algorithm;
        this.format = format.toUpperCase();
        this.encoded = encoded.clone();
}

Parameters:

type - either one of Type.SECRET, Type.PUBLIC, or Type.PRIVATE

algorithm - the algorithm returned from Key.getAlgorithm()

format - the encoding format returned from Key.getFormat()

encoded - the encoded bytes returned from Key.getEncoded()

Throws:

NullPointerException - if type is null, if algorithm is null, if format is null, or if encoded is null

exception: NullPointerException - if type is null, if algorithm is null, if format is null, or if encoded is null

Method from java.security.KeyRep Summary:
readResolve

Methods from java.lang.Object:
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method from java.security.KeyRep Detail:
protected Object readResolve() throws ObjectStreamException { try { if (type == Type.SECRET && RAW.equals(format)) { return new SecretKeySpec(encoded, algorithm); } else if (type == Type.PUBLIC && X509.equals(format)) { KeyFactory f = KeyFactory.getInstance(algorithm); return f.generatePublic(new X509EncodedKeySpec(encoded)); } else if (type == Type.PRIVATE && PKCS8.equals(format)) { KeyFactory f = KeyFactory.getInstance(algorithm); return f.generatePrivate(new PKCS8EncodedKeySpec(encoded)); } else { throw new NotSerializableException ("unrecognized type/format combination: " + type + "/" + format); } } catch (NotSerializableException nse) { throw nse; } catch (Exception e) { NotSerializableException nse = new NotSerializableException ("java.security.Key: " + "[" + type + "] " + "[" + algorithm + "] " + "[" + format + "]"); nse.initCause(e); throw nse; } } Resolve the Key object. This method supports three Type/format combinations: Type.SECRET/"RAW" - returns a SecretKeySpec object constructed using encoded key bytes and algorithm Type.PUBLIC/"X.509" - gets a KeyFactory instance for the key algorithm, constructs an X509EncodedKeySpec with the encoded key bytes, and generates a public key from the spec Type.PRIVATE/"PKCS#8" - gets a KeyFactory instance for the key algorithm, constructs a PKCS8EncodedKeySpec with the encoded key bytes, and generates a private key from the spec

Method from java.security.KeyRep Detail:

 protected Object readResolve() throws ObjectStreamException {
        try {
            if (type == Type.SECRET && RAW.equals(format)) {
                return new SecretKeySpec(encoded, algorithm);
            } else if (type == Type.PUBLIC && X509.equals(format)) {
                KeyFactory f = KeyFactory.getInstance(algorithm);
                return f.generatePublic(new X509EncodedKeySpec(encoded));
            } else if (type == Type.PRIVATE && PKCS8.equals(format)) {
                KeyFactory f = KeyFactory.getInstance(algorithm);
                return f.generatePrivate(new PKCS8EncodedKeySpec(encoded));
            } else {
                throw new NotSerializableException
                        ("unrecognized type/format combination: " +
                        type + "/" + format);
            }
        } catch (NotSerializableException nse) {
            throw nse;
        } catch (Exception e) {
            NotSerializableException nse = new NotSerializableException
                                        ("java.security.Key: " +
                                        "[" + type + "] " +
                                        "[" + algorithm + "] " +
                                        "[" + format + "]");
            nse.initCause(e);
            throw nse;
        }
}

This method supports three Type/format combinations:

Type.SECRET/"RAW" - returns a SecretKeySpec object constructed using encoded key bytes and algorithm
Type.PUBLIC/"X.509" - gets a KeyFactory instance for the key algorithm, constructs an X509EncodedKeySpec with the encoded key bytes, and generates a public key from the spec
Type.PRIVATE/"PKCS#8" - gets a KeyFactory instance for the key algorithm, constructs a PKCS8EncodedKeySpec with the encoded key bytes, and generates a private key from the spec