On 5/16/18 10:02 PM, Weijun Wang wrote:

On May 17, 2018, at 2:42 AM, Sean Mullan <sean.mul...@oracle.com> wrote:

The while(true) in PKCS12KeyStore.java seems like it isn't really necessary, 
since you are calling the code inside it at most twice. I think a better 
approach would be to move lines 2134-2146 into a utility method and call it 
again if you get an Exception and the password is empty.

The while block looks a little strange, but there are too many local variables 
here and extracting the lines into a method means we need to pass all of them 
as arguments. This is also just a single step in a long process and taking it 
out as a separate method breaks the code reading. Finally, such while blocks 
appear 3 times and we will have to create multiple methods like 

Ok, I didn't realize this pattern was used before.

It will be nice if Java allows a method defined inside a method. What do you 
think if I extract the lines into a lambda?

interface RetryWithZero<T> {

     T tryOnce(char[] password) throws Exception;

     static <S> S run(RetryWithZero<S> f, char[] password) throws Exception {
         try {
             return f.tryOnce(password);
         } catch (Exception e) {
             if (password.length == 0) {
                 return f.tryOnce(new char[1]);
             throw e;

byte[] keyInfo = RetryWithZero.run(pass -> {
     SecretKey skey = getPBEKey(pass);
     Cipher cipher = Cipher.getInstance(
             mapPBEParamsToAlgorithm(algOid, algParams));
     cipher.init(Cipher.DECRYPT_MODE, skey, algParams);
     return cipher.doFinal(encryptedKey);
}, password);

byte[] rawData = safeContentsData;
try {
     safeContentsData = RetryWithZero.run(pass -> {
         SecretKey skey = getPBEKey(pass);
         Cipher cipher = Cipher.getInstance(algOid.toString());
         cipher.init(Cipher.DECRYPT_MODE, skey, algParams);
         return cipher.doFinal(rawData);
     }, password);
} catch (Exception e) {
     throw new IOException("keystore password was incorrect",
             new UnrecoverableKeyException(
                     "failed to decrypt safe contents entry: " + e));

RetryWithZero.run(pass -> {
     SecretKey key = getPBEKey(pass);
     m.init(key, params);
     byte[] macResult = m.doFinal();

     if (debug != null) {
         debug.println("Checking keystore integrity " +
                 "(" + m.getAlgorithm() + " iterations: " + ic + ")");

     if (!MessageDigest.isEqual(macData.getDigest(), macResult)) {
         throw new UnrecoverableKeyException("Failed PKCS12" +
                 " integrity checking");
     return (Void)null;
}, password);

If we code this way, password will NOT be updated permanently (see p.p.s of my 
previous mail).

Seems more complicated and harder to understand that code. So I'm ok with the current changes.



Looks fine otherwise.


On 4/27/18 12:56 PM, Weijun Wang wrote:
Please take a look at
Turns out we have to retry [0] other than [] in all 3 locations: decrypting 
keys, decrypting certs, and verifying the mac.
p.s. You might wonder why suddenly in Windows Server 2016, Microsoft starts 
using [0] to generate the Mac. In fact, they have been doing this all the time. 
However, before 2016, they also encrypted the certificates, and to decrypt 
them, Java has already changed password from [] to [0].
p.p.s. But is this correct? Should the certificate decryption code only 
temporarily retries [0] but not changing password itself? Well, maybe. But 
unless a weird software sometimes uses [] and sometimes [0], this will not be a 
problem, and changing password itself saves us some cycles from always trying 

Reply via email to