/*
 * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package java.security;

import java.io.*;
import java.util.Locale;

import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.security.spec.InvalidKeySpecException;

import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.SecretKeySpec;

/**
 * Standardized representation for serialized Key objects.
 *
 * <p>
 *
 * Note that a serialized Key may contain sensitive information
 * which should not be exposed in untrusted environments. See the
 * <a href="../../../platform/serialization/spec/security.html">
 * Security Appendix</a>
 * of the Serialization Specification for more information.
 *
 * @see Key
 * @see KeyFactory
 * @see javax.crypto.spec.SecretKeySpec
 * @see java.security.spec.X509EncodedKeySpec
 * @see java.security.spec.PKCS8EncodedKeySpec
 *
 * @since 1.5
 */

public class KeyRep implements Serializable {

 private static final long serialVersionUID = -4757683898830641853L;

 /**
 * Key type.
 *
 * @since 1.5
 */
 public static enum Type {

 /** Type for secret keys. */
 SECRET,

 /** Type for public keys. */
 PUBLIC,

 /** Type for private keys. */
 PRIVATE,

 }

 private static final String PKCS8 = "PKCS#8";
 private static final String X509 = "X.509";
 private static final String RAW = "RAW";

 /**
 * Either one of Type.SECRET, Type.PUBLIC, or Type.PRIVATE
 *
 * @serial
 */
 private Type type;

 /**
 * The Key algorithm
 *
 * @serial
 */
 private String algorithm;

 /**
 * The Key encoding format
 *
 * @serial
 */
 private String format;

 /**
 * The encoded Key bytes
 *
 * @serial
 */
 private byte[] encoded;

 /**
 * Construct the alternate Key class.
 *
 * <p>
 *
 * @param type either one of Type.SECRET, Type.PUBLIC, or Type.PRIVATE
 * @param algorithm the algorithm returned from
 * {@code Key.getAlgorithm()}
 * @param format the encoding format returned from
 * {@code Key.getFormat()}
 * @param encoded the encoded bytes returned from
 * {@code Key.getEncoded()}
 *
 * @exception NullPointerException
 * if type is {@code null},
 * if algorithm is {@code null},
 * if format is {@code null},
 * or if encoded is {@code 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(Locale.ENGLISH);
 this.encoded = encoded.clone();
 }

 /**
 * Resolve the Key object.
 *
 * <p> This method supports three Type/format combinations:
 * <ul>
 * <li> Type.SECRET/"RAW" - returns a SecretKeySpec object
 * constructed using encoded key bytes and algorithm
 * <li> 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
 * <li> 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
 * </ul>
 *
 * <p>
 *
 * @return the resolved Key object
 *
 * @exception ObjectStreamException if the Type/format
 * combination is unrecognized, if the algorithm, key format, or
 * encoded key bytes are unrecognized/invalid, of if the
 * resolution of the key fails for any reason
 */
 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;
 }
 }
}