content: /*
   * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   *
   * This code is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 only, as
   * published by the Free Software Foundation.  Oracle designates this
   * particular file as subject to the "Classpath" exception as provided
   * by Oracle in the LICENSE file that accompanied this code.
   *
   * This code 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
   * version 2 for more details (a copy is included in the LICENSE file that
   * accompanied this code).
   *
   * You should have received a copy of the GNU General Public License version
   * 2 along with this work; if not, write to the Free Software Foundation,
   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
   * or visit www.oracle.com if you need additional information or have any
   * questions.
   */
  
  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 SecretKeySpec
   * @see X509EncodedKeySpec
   * @see 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;
          }
      }
  }
  