jdk-sandbox: comparison src/java.base/share/classes/com/sun/crypto/provider/PBES1Core.java

equal deleted inserted replaced

-:0265a70ea2a5
+:c9a3e3cac9c7
 package com.sun.crypto.provider;
 import java.security.*;
 import java.security.spec.*;
+import java.util.Arrays;
 import javax.crypto.*;
 import javax.crypto.spec.*;
 /**
 * This class represents password-based encryption as defined by the PKCS #5
 if (((opmode == Cipher.DECRYPT_MODE) ||
 (opmode == Cipher.UNWRAP_MODE)) && (params == null)) {
 throw new InvalidAlgorithmParameterException("Parameters "
 + "missing");
 }
-if ((key == null) ||
+if (key == null) {
-(key.getEncoded() == null) ||
+throw new InvalidKeyException("Null key");
-!(key.getAlgorithm().regionMatches(true, 0, "PBE", 0, 3))) {
+}
-throw new InvalidKeyException("Missing password");
-}
+byte[] derivedKey;
+byte[] passwdBytes = key.getEncoded();
-if (params == null) {
+try {
-// create random salt and use default iteration count
+if ((passwdBytes == null) ||
-salt = new byte[8];
+!(key.getAlgorithm().regionMatches(true, 0, "PBE", 0, 3))) {
-random.nextBytes(salt);
+throw new InvalidKeyException("Missing password");
-} else {
+}
-if (!(params instanceof PBEParameterSpec)) {
-throw new InvalidAlgorithmParameterException
+if (params == null) {
-("Wrong parameter type: PBE expected");
+// create random salt and use default iteration count
-}
+salt = new byte[8];
-salt = ((PBEParameterSpec) params).getSalt();
+random.nextBytes(salt);
-// salt must be 8 bytes long (by definition)
+} else {
-if (salt.length != 8) {
+if (!(params instanceof PBEParameterSpec)) {
 throw new InvalidAlgorithmParameterException
-("Salt must be 8 bytes long");
+("Wrong parameter type: PBE expected");
 }
-iCount = ((PBEParameterSpec) params).getIterationCount();
+salt = ((PBEParameterSpec) params).getSalt();
-if (iCount <= 0) {
+// salt must be 8 bytes long (by definition)
-throw new InvalidAlgorithmParameterException
+if (salt.length != 8) {
-("IterationCount must be a positive number");
+throw new InvalidAlgorithmParameterException
-}
+("Salt must be 8 bytes long");
 }
+iCount = ((PBEParameterSpec) params).getIterationCount();
-byte[] derivedKey = deriveCipherKey(key);
+if (iCount <= 0) {
+throw new InvalidAlgorithmParameterException
+("IterationCount must be a positive number");
+}
+}
+derivedKey = deriveCipherKey(passwdBytes);
+} finally {
+if (passwdBytes != null) Arrays.fill(passwdBytes, (byte) 0x00);
+}
 // use all but the last 8 bytes as the key value
 SecretKeySpec cipherKey = new SecretKeySpec(derivedKey, 0,
 derivedKey.length-8, algo);
 // use the last 8 bytes as the IV
 IvParameterSpec ivSpec = new IvParameterSpec(derivedKey,
 8);
 // initialize the underlying cipher
 cipher.init(opmode, cipherKey, ivSpec, random);
 }
-private byte[] deriveCipherKey(Key key) {
+private byte[] deriveCipherKey(byte[] passwdBytes) {
 byte[] result = null;
-byte[] passwdBytes = key.getEncoded();
 if (algo.equals("DES")) {
 // P || S (password concatenated with salt)
 byte[] concat = new byte[Math.addExact(passwdBytes.length, salt.length)];
 System.arraycopy(passwdBytes, 0, concat, 0, passwdBytes.length);
-java.util.Arrays.fill(passwdBytes, (byte)0x00);
 System.arraycopy(salt, 0, concat, passwdBytes.length, salt.length);
 // digest P || S with c iterations
 byte[] toBeHashed = concat;
 for (int i = 0; i < iCount; i++) {
 md.update(toBeHashed);
 toBeHashed = md.digest(); // this resets the digest
 }
-java.util.Arrays.fill(concat, (byte)0x00);
+Arrays.fill(concat, (byte)0x00);
 result = toBeHashed;
 } else if (algo.equals("DESede")) {
 // if the 2 salt halves are the same, invert one of them
 int i;
 for (i=0; i<4; i++) {
 // half, go through the loop as many times as specified by the
 // iteration count parameter (inner for loop).
 // Concatenate the output from each digest round with the
 // password, and use the result as the input to the next digest
 // operation.
-byte[] kBytes = null;
-IvParameterSpec iv = null;
 byte[] toBeHashed = null;
 result = new byte[DESedeKeySpec.DES_EDE_KEY_LEN +
 DESConstants.DES_BLOCK_SIZE];
 for (i = 0; i < 2; i++) {
 toBeHashed = new byte[salt.length/2];
 System.arraycopy(salt, i*(salt.length/2), toBeHashed, 0,
 toBeHashed.length);
 for (int j=0; j < iCount; j++) {
 md.update(toBeHashed);
 md.update(passwdBytes);
-toBeHashed = md.digest(); // this resets the digest
+toBeHashed = md.digest();
 }
 System.arraycopy(toBeHashed, 0, result, i*16,
 toBeHashed.length);
 }
 }
+// clear data used in message
+md.reset();
 return result;
 }
 void init(int opmode, Key key, AlgorithmParameters params,
 SecureRandom random)
 * being passed to a software only cipher).
 */
 byte[] wrap(Key key)
 throws IllegalBlockSizeException, InvalidKeyException {
 byte[] result = null;
+byte[] encodedKey = null;
 try {
-byte[] encodedKey = key.getEncoded();
+encodedKey = key.getEncoded();
 if ((encodedKey == null) || (encodedKey.length == 0)) {
 throw new InvalidKeyException("Cannot get an encoding of " +
 "the key to be wrapped");
 }
 result = doFinal(encodedKey, 0, encodedKey.length);
 } catch (BadPaddingException e) {
 // Should never happen
+} finally {
+if (encodedKey != null) Arrays.fill(encodedKey, (byte)0x00);
 }
 return result;
 }

changeset 51504	c9a3e3cac9c7
parent 47417	5984d1c9d03d
child 55493	159edfcbc2ce