Back to index...

	/*
	* Copyright (c) 2001, 2017, 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 javax.crypto;

	import java.io.*;
	import java.security.*;
	import java.security.spec.*;
	import sun.security.x509.AlgorithmId;
	import sun.security.util.DerValue;
	import sun.security.util.DerInputStream;
	import sun.security.util.DerOutputStream;

	/**
	* This class implements the <code>EncryptedPrivateKeyInfo</code> type
	* as defined in PKCS #8.
	* <p>Its ASN.1 definition is as follows:
	*
	* <pre>
	* EncryptedPrivateKeyInfo ::= SEQUENCE {
	* encryptionAlgorithm AlgorithmIdentifier,
	* encryptedData OCTET STRING }
	*
	* AlgorithmIdentifier ::= SEQUENCE {
	* algorithm OBJECT IDENTIFIER,
	* parameters ANY DEFINED BY algorithm OPTIONAL }
	* </pre>
	*
	* @author Valerie Peng
	*
	* @see java.security.spec.PKCS8EncodedKeySpec
	*
	* @since 1.4
	*/

	public class EncryptedPrivateKeyInfo {

	// the "encryptionAlgorithm" field
	private AlgorithmId algid;

	// the algorithm name of the encrypted private key
	private String keyAlg;

	// the "encryptedData" field
	private byte[] encryptedData;

	// the ASN.1 encoded contents of this class
	private byte[] encoded = null;

	/**
	* Constructs (i.e., parses) an <code>EncryptedPrivateKeyInfo</code> from
	* its ASN.1 encoding.
	* @param encoded the ASN.1 encoding of this object. The contents of
	* the array are copied to protect against subsequent modification.
	* @exception NullPointerException if the <code>encoded</code> is null.
	* @exception IOException if error occurs when parsing the ASN.1 encoding.
	*/
	public EncryptedPrivateKeyInfo(byte[] encoded)
	throws IOException {
	if (encoded == null) {
	throw new NullPointerException("the encoded parameter " +
	"must be non-null");
	}
	this.encoded = encoded.clone();
	DerValue val = new DerValue(this.encoded);

	DerValue[] seq = new DerValue[2];

	seq[0] = val.data.getDerValue();
	seq[1] = val.data.getDerValue();

	if (val.data.available() != 0) {
	throw new IOException("overrun, bytes = " + val.data.available());
	}

	this.algid = AlgorithmId.parse(seq[0]);
	if (seq[0].data.available() != 0) {
	throw new IOException("encryptionAlgorithm field overrun");
	}

	this.encryptedData = seq[1].getOctetString();
	if (seq[1].data.available() != 0) {
	throw new IOException("encryptedData field overrun");
	}
	}

	/**
	* Constructs an <code>EncryptedPrivateKeyInfo</code> from the
	* encryption algorithm name and the encrypted data.
	*
	* <p>Note: This constructor will use null as the value of the
	* algorithm parameters. If the encryption algorithm has
	* parameters whose value is not null, a different constructor,
	* e.g. EncryptedPrivateKeyInfo(AlgorithmParameters, byte[]),
	* should be used.
	*
	* @param algName encryption algorithm name. See the
	* <a href="{@docRoot}/../specs/security/standard-names.html">
	* Java Security Standard Algorithm Names</a> document
	* for information about standard Cipher algorithm names.
	* @param encryptedData encrypted data. The contents of
	* <code>encrypedData</code> are copied to protect against subsequent
	* modification when constructing this object.
	* @exception NullPointerException if <code>algName</code> or
	* <code>encryptedData</code> is null.
	* @exception IllegalArgumentException if <code>encryptedData</code>
	* is empty, i.e. 0-length.
	* @exception NoSuchAlgorithmException if the specified algName is
	* not supported.
	*/
	public EncryptedPrivateKeyInfo(String algName, byte[] encryptedData)
	throws NoSuchAlgorithmException {

	if (algName == null)
	throw new NullPointerException("the algName parameter " +
	"must be non-null");
	this.algid = AlgorithmId.get(algName);

	if (encryptedData == null) {
	throw new NullPointerException("the encryptedData " +
	"parameter must be non-null");
	} else if (encryptedData.length == 0) {
	throw new IllegalArgumentException("the encryptedData " +
	"parameter must not be empty");
	} else {
	this.encryptedData = encryptedData.clone();
	}
	// delay the generation of ASN.1 encoding until
	// getEncoded() is called
	this.encoded = null;
	}

	/**
	* Constructs an <code>EncryptedPrivateKeyInfo</code> from the
	* encryption algorithm parameters and the encrypted data.
	*
	* @param algParams the algorithm parameters for the encryption
	* algorithm. <code>algParams.getEncoded()</code> should return
	* the ASN.1 encoded bytes of the <code>parameters</code> field
	* of the <code>AlgorithmIdentifer</code> component of the
	* <code>EncryptedPrivateKeyInfo</code> type.
	* @param encryptedData encrypted data. The contents of
	* <code>encrypedData</code> are copied to protect against
	* subsequent modification when constructing this object.
	* @exception NullPointerException if <code>algParams</code> or
	* <code>encryptedData</code> is null.
	* @exception IllegalArgumentException if <code>encryptedData</code>
	* is empty, i.e. 0-length.
	* @exception NoSuchAlgorithmException if the specified algName of
	* the specified <code>algParams</code> parameter is not supported.
	*/
	public EncryptedPrivateKeyInfo(AlgorithmParameters algParams,
	byte[] encryptedData) throws NoSuchAlgorithmException {

	if (algParams == null) {
	throw new NullPointerException("algParams must be non-null");
	}
	this.algid = AlgorithmId.get(algParams);

	if (encryptedData == null) {
	throw new NullPointerException("encryptedData must be non-null");
	} else if (encryptedData.length == 0) {
	throw new IllegalArgumentException("the encryptedData " +
	"parameter must not be empty");
	} else {
	this.encryptedData = encryptedData.clone();
	}

	// delay the generation of ASN.1 encoding until
	// getEncoded() is called
	this.encoded = null;
	}


	/**
	* Returns the encryption algorithm.
	* <p>Note: Standard name is returned instead of the specified one
	* in the constructor when such mapping is available.
	* See the <a href="{@docRoot}/../specs/security/standard-names.html">
	* Java Security Standard Algorithm Names</a> document
	* for information about standard Cipher algorithm names.
	*
	* @return the encryption algorithm name.
	*/
	public String getAlgName() {
	return this.algid.getName();
	}

	/**
	* Returns the algorithm parameters used by the encryption algorithm.
	* @return the algorithm parameters.
	*/
	public AlgorithmParameters getAlgParameters() {
	return this.algid.getParameters();
	}

	/**
	* Returns the encrypted data.
	* @return the encrypted data. Returns a new array
	* each time this method is called.
	*/
	public byte[] getEncryptedData() {
	return this.encryptedData.clone();
	}

	/**
	* Extract the enclosed PKCS8EncodedKeySpec object from the
	* encrypted data and return it.
	* <br>Note: In order to successfully retrieve the enclosed
	* PKCS8EncodedKeySpec object, <code>cipher</code> needs
	* to be initialized to either Cipher.DECRYPT_MODE or
	* Cipher.UNWRAP_MODE, with the same key and parameters used
	* for generating the encrypted data.
	*
	* @param cipher the initialized cipher object which will be
	* used for decrypting the encrypted data.
	* @return the PKCS8EncodedKeySpec object.
	* @exception NullPointerException if <code>cipher</code>
	* is null.
	* @exception InvalidKeySpecException if the given cipher is
	* inappropriate for the encrypted data or the encrypted
	* data is corrupted and cannot be decrypted.
	*/
	public PKCS8EncodedKeySpec getKeySpec(Cipher cipher)
	throws InvalidKeySpecException {
	byte[] encoded = null;
	try {
	encoded = cipher.doFinal(encryptedData);
	checkPKCS8Encoding(encoded);
	} catch (GeneralSecurityException \|
	IOException \|
	IllegalStateException ex) {
	throw new InvalidKeySpecException(
	"Cannot retrieve the PKCS8EncodedKeySpec", ex);
	}
	return new PKCS8EncodedKeySpec(encoded, keyAlg);
	}

	private PKCS8EncodedKeySpec getKeySpecImpl(Key decryptKey,
	Provider provider) throws NoSuchAlgorithmException,
	InvalidKeyException {
	byte[] encoded = null;
	Cipher c;
	try {
	if (provider == null) {
	// use the most preferred one
	c = Cipher.getInstance(algid.getName());
	} else {
	c = Cipher.getInstance(algid.getName(), provider);
	}
	c.init(Cipher.DECRYPT_MODE, decryptKey, algid.getParameters());
	encoded = c.doFinal(encryptedData);
	checkPKCS8Encoding(encoded);
	} catch (NoSuchAlgorithmException nsae) {
	// rethrow
	throw nsae;
	} catch (GeneralSecurityException \| IOException ex) {
	throw new InvalidKeyException(
	"Cannot retrieve the PKCS8EncodedKeySpec", ex);
	}
	return new PKCS8EncodedKeySpec(encoded, keyAlg);
	}

	/**
	* Extract the enclosed PKCS8EncodedKeySpec object from the
	* encrypted data and return it.
	* @param decryptKey key used for decrypting the encrypted data.
	* @return the PKCS8EncodedKeySpec object.
	* @exception NullPointerException if <code>decryptKey</code>
	* is null.
	* @exception NoSuchAlgorithmException if cannot find appropriate
	* cipher to decrypt the encrypted data.
	* @exception InvalidKeyException if <code>decryptKey</code>
	* cannot be used to decrypt the encrypted data or the decryption
	* result is not a valid PKCS8KeySpec.
	*
	* @since 1.5
	*/
	public PKCS8EncodedKeySpec getKeySpec(Key decryptKey)
	throws NoSuchAlgorithmException, InvalidKeyException {
	if (decryptKey == null) {
	throw new NullPointerException("decryptKey is null");
	}
	return getKeySpecImpl(decryptKey, null);
	}

	/**
	* Extract the enclosed PKCS8EncodedKeySpec object from the
	* encrypted data and return it.
	* @param decryptKey key used for decrypting the encrypted data.
	* @param providerName the name of provider whose Cipher
	* implementation will be used.
	* @return the PKCS8EncodedKeySpec object.
	* @exception NullPointerException if <code>decryptKey</code>
	* or <code>providerName</code> is null.
	* @exception NoSuchProviderException if no provider
	* <code>providerName</code> is registered.
	* @exception NoSuchAlgorithmException if cannot find appropriate
	* cipher to decrypt the encrypted data.
	* @exception InvalidKeyException if <code>decryptKey</code>
	* cannot be used to decrypt the encrypted data or the decryption
	* result is not a valid PKCS8KeySpec.
	*
	* @since 1.5
	*/
	public PKCS8EncodedKeySpec getKeySpec(Key decryptKey,
	String providerName) throws NoSuchProviderException,
	NoSuchAlgorithmException, InvalidKeyException {
	if (decryptKey == null) {
	throw new NullPointerException("decryptKey is null");
	}
	if (providerName == null) {
	throw new NullPointerException("provider is null");
	}
	Provider provider = Security.getProvider(providerName);
	if (provider == null) {
	throw new NoSuchProviderException("provider " +
	providerName + " not found");
	}
	return getKeySpecImpl(decryptKey, provider);
	}

	/**
	* Extract the enclosed PKCS8EncodedKeySpec object from the
	* encrypted data and return it.
	* @param decryptKey key used for decrypting the encrypted data.
	* @param provider the name of provider whose Cipher implementation
	* will be used.
	* @return the PKCS8EncodedKeySpec object.
	* @exception NullPointerException if <code>decryptKey</code>
	* or <code>provider</code> is null.
	* @exception NoSuchAlgorithmException if cannot find appropriate
	* cipher to decrypt the encrypted data in <code>provider</code>.
	* @exception InvalidKeyException if <code>decryptKey</code>
	* cannot be used to decrypt the encrypted data or the decryption
	* result is not a valid PKCS8KeySpec.
	*
	* @since 1.5
	*/
	public PKCS8EncodedKeySpec getKeySpec(Key decryptKey,
	Provider provider) throws NoSuchAlgorithmException,
	InvalidKeyException {
	if (decryptKey == null) {
	throw new NullPointerException("decryptKey is null");
	}
	if (provider == null) {
	throw new NullPointerException("provider is null");
	}
	return getKeySpecImpl(decryptKey, provider);
	}

	/**
	* Returns the ASN.1 encoding of this object.
	* @return the ASN.1 encoding. Returns a new array
	* each time this method is called.
	* @exception IOException if error occurs when constructing its
	* ASN.1 encoding.
	*/
	public byte[] getEncoded() throws IOException {
	if (this.encoded == null) {
	DerOutputStream out = new DerOutputStream();
	DerOutputStream tmp = new DerOutputStream();

	// encode encryption algorithm
	algid.encode(tmp);

	// encode encrypted data
	tmp.putOctetString(encryptedData);

	// wrap everything into a SEQUENCE
	out.write(DerValue.tag_Sequence, tmp);
	this.encoded = out.toByteArray();
	}
	return this.encoded.clone();
	}

	private static void checkTag(DerValue val, byte tag, String valName)
	throws IOException {
	if (val.getTag() != tag) {
	throw new IOException("invalid key encoding - wrong tag for " +
	valName);
	}
	}

	@SuppressWarnings("fallthrough")
	private void checkPKCS8Encoding(byte[] encodedKey)
	throws IOException {
	DerInputStream in = new DerInputStream(encodedKey);
	DerValue[] values = in.getSequence(3);

	switch (values.length) {
	case 4:
	checkTag(values[3], DerValue.TAG_CONTEXT, "attributes");
	/* fall through */
	case 3:
	checkTag(values[0], DerValue.tag_Integer, "version");
	keyAlg = AlgorithmId.parse(values[1]).getName();
	checkTag(values[2], DerValue.tag_OctetString, "privateKey");
	break;
	default:
	throw new IOException("invalid key encoding");
	}
	}
	}

Back to index...