259 lines
9.5 KiB
Java
259 lines
9.5 KiB
Java
/*
|
|
* Copyright (c) 2015, 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.
|
|
*
|
|
* 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.
|
|
*/
|
|
|
|
import java.security.AlgorithmParameters;
|
|
import java.security.InvalidAlgorithmParameterException;
|
|
import java.security.InvalidKeyException;
|
|
import java.security.NoSuchAlgorithmException;
|
|
import java.security.spec.AlgorithmParameterSpec;
|
|
import java.security.spec.InvalidKeySpecException;
|
|
import java.security.spec.InvalidParameterSpecException;
|
|
import java.util.Arrays;
|
|
import java.util.List;
|
|
import java.util.ArrayList;
|
|
import javax.crypto.BadPaddingException;
|
|
import javax.crypto.Cipher;
|
|
import javax.crypto.IllegalBlockSizeException;
|
|
import javax.crypto.NoSuchPaddingException;
|
|
import javax.crypto.SecretKey;
|
|
import javax.crypto.SecretKeyFactory;
|
|
import javax.crypto.ShortBufferException;
|
|
import javax.crypto.spec.IvParameterSpec;
|
|
import javax.crypto.spec.PBEKeySpec;
|
|
import javax.crypto.spec.PBEParameterSpec;
|
|
import javax.crypto.spec.SecretKeySpec;
|
|
|
|
/**
|
|
* PBECipherWrapper is the abstract class for all concrete PBE Cipher wrappers.
|
|
*/
|
|
public abstract class PBECipherWrapper {
|
|
|
|
public static final int ITERATION_COUNT = 1000;
|
|
private final String algorithm;
|
|
private final byte[] salt;
|
|
protected SecretKey key;
|
|
protected Cipher ci;
|
|
protected String baseAlgo;
|
|
protected byte[] resultText = null;
|
|
protected AlgorithmParameterSpec aps = null;
|
|
|
|
public PBECipherWrapper(String algorithm, int saltSize) {
|
|
this.algorithm = algorithm;
|
|
baseAlgo = algorithm.split("/")[0].toUpperCase();
|
|
salt = generateSalt(saltSize);
|
|
}
|
|
|
|
protected abstract void initCipher(int mode) throws InvalidKeyException,
|
|
InvalidAlgorithmParameterException, InvalidParameterSpecException;
|
|
|
|
public void execute(int edMode, byte[] inputText)
|
|
throws InvalidAlgorithmParameterException,
|
|
InvalidParameterSpecException, IllegalBlockSizeException,
|
|
BadPaddingException, ShortBufferException, InvalidKeyException {
|
|
// Initialize
|
|
initCipher(edMode);
|
|
|
|
// Generate a resultText using a single-part enc/dec
|
|
resultText = ci.doFinal(inputText);
|
|
|
|
// Generate outputText for each multi-part en/de-cryption
|
|
/* Combination #1:
|
|
update(byte[], int, int)
|
|
doFinal(byte[], int, int)
|
|
*/
|
|
byte[] part11 = ci.update(inputText, 0, inputText.length);
|
|
byte[] part12 = ci.doFinal();
|
|
byte[] outputText1 = new byte[part11.length + part12.length];
|
|
System.arraycopy(part11, 0, outputText1, 0, part11.length);
|
|
System.arraycopy(part12, 0, outputText1, part11.length, part12.length);
|
|
|
|
List<byte[]> outputTexts = new ArrayList<>(4);
|
|
outputTexts.add(outputText1);
|
|
|
|
/* Combination #2:
|
|
update(byte[], int, int)
|
|
doFinal(byte[], int, int, byte[], int)
|
|
*/
|
|
byte[] part21 = ci.update(inputText, 0, inputText.length - 5);
|
|
byte[] part22 = new byte[ci.getOutputSize(inputText.length)];
|
|
int len2 = ci.doFinal(inputText, inputText.length - 5, 5, part22, 0);
|
|
byte[] outputText2 = new byte[part21.length + len2];
|
|
System.arraycopy(part21, 0, outputText2, 0, part21.length);
|
|
System.arraycopy(part22, 0, outputText2, part21.length, len2);
|
|
|
|
outputTexts.add(outputText2);
|
|
|
|
/* Combination #3:
|
|
update(byte[], int, int, byte[], int)
|
|
doFinal(byte[], int, int)
|
|
*/
|
|
byte[] part31 = new byte[ci.getOutputSize(inputText.length)];
|
|
int len3 = ci.update(inputText, 0, inputText.length - 8, part31, 0);
|
|
byte[] part32 = ci.doFinal(inputText, inputText.length - 8, 8);
|
|
byte[] outputText3 = new byte[len3 + part32.length];
|
|
System.arraycopy(part31, 0, outputText3, 0, len3);
|
|
System.arraycopy(part32, 0, outputText3, len3, part32.length);
|
|
|
|
outputTexts.add(outputText3);
|
|
|
|
/* Combination #4:
|
|
update(byte[], int, int, byte[], int)
|
|
doFinal(byte[], int, int, byte[], int)
|
|
*/
|
|
byte[] part41 = new byte[ci.getOutputSize(inputText.length)];
|
|
int len4 = ci.update(inputText, 0, inputText.length - 8, part41, 0);
|
|
int rest4 = ci
|
|
.doFinal(inputText, inputText.length - 8, 8, part41, len4);
|
|
byte[] outputText4 = new byte[len4 + rest4];
|
|
System.arraycopy(part41, 0, outputText4, 0, outputText4.length);
|
|
|
|
outputTexts.add(outputText4);
|
|
|
|
// Compare results
|
|
for (int k = 0; k < outputTexts.size(); k++) {
|
|
if (!Arrays.equals(resultText, outputTexts.get(k))) {
|
|
throw new RuntimeException(
|
|
"Compare value of resultText and combination " + k
|
|
+ " are not same. Test failed.");
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
public final byte[] generateSalt(int numberOfBytes) {
|
|
byte[] aSalt = new byte[numberOfBytes];
|
|
for (int i = 0; i < numberOfBytes; i++) {
|
|
aSalt[i] = (byte) (i & 0xff);
|
|
}
|
|
return aSalt;
|
|
}
|
|
|
|
public byte[] getResult() {
|
|
return resultText;
|
|
}
|
|
|
|
public String getAlgorithm() {
|
|
return algorithm;
|
|
}
|
|
|
|
public byte[] getSalt() {
|
|
return salt;
|
|
}
|
|
|
|
/**
|
|
* Wrapper class to test a given SecretKeyFactory.PBKDF2 algorithm.
|
|
*/
|
|
public static class PBKDF2 extends PBECipherWrapper {
|
|
|
|
private static final int PBKDF2_SALT_SIZE = 64;
|
|
private static final int CIPHER_KEY_SIZE = 128;
|
|
private static final String CIPHER_TRANSFORMATION = "AES/CBC/PKCS5Padding";
|
|
private static final String KEY_ALGORITHM = "AES";
|
|
private byte[] iv = null;
|
|
|
|
public PBKDF2(String algo, String passwd)
|
|
throws InvalidKeySpecException, NoSuchAlgorithmException,
|
|
NoSuchPaddingException {
|
|
super(algo, PBKDF2_SALT_SIZE);
|
|
|
|
ci = Cipher.getInstance(CIPHER_TRANSFORMATION);
|
|
|
|
PBEKeySpec pbeKeySpec = new PBEKeySpec(passwd.toCharArray(), getSalt(),
|
|
ITERATION_COUNT, CIPHER_KEY_SIZE);
|
|
SecretKeyFactory keyFactory = SecretKeyFactory.getInstance(algo);
|
|
key = keyFactory.generateSecret(pbeKeySpec);
|
|
}
|
|
|
|
@Override
|
|
protected void initCipher(int mode) throws InvalidKeyException,
|
|
InvalidAlgorithmParameterException, InvalidParameterSpecException {
|
|
if (Cipher.ENCRYPT_MODE == mode) {
|
|
ci.init(Cipher.ENCRYPT_MODE, new SecretKeySpec(key.getEncoded(),
|
|
KEY_ALGORITHM));
|
|
iv = ci.getParameters().getParameterSpec(IvParameterSpec.class)
|
|
.getIV();
|
|
} else {
|
|
ci.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key.getEncoded(),
|
|
KEY_ALGORITHM), new IvParameterSpec(iv));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Wrapper class to test a given AES-based PBE algorithm.
|
|
*/
|
|
public static class AES extends PBECipherWrapper {
|
|
|
|
private AlgorithmParameters pbeParams;
|
|
|
|
public AES(String algo, String passwd)
|
|
throws NoSuchAlgorithmException, NoSuchPaddingException,
|
|
InvalidKeySpecException {
|
|
super(algo, 0);
|
|
|
|
ci = Cipher.getInstance(algo);
|
|
|
|
SecretKeyFactory skf = SecretKeyFactory.getInstance(algo);
|
|
key = skf.generateSecret(new PBEKeySpec(passwd.toCharArray()));
|
|
}
|
|
|
|
@Override
|
|
protected void initCipher(int mode) throws InvalidKeyException,
|
|
InvalidAlgorithmParameterException, InvalidParameterSpecException {
|
|
if (Cipher.ENCRYPT_MODE == mode) {
|
|
ci.init(Cipher.ENCRYPT_MODE, key);
|
|
pbeParams = ci.getParameters();
|
|
} else {
|
|
ci.init(Cipher.DECRYPT_MODE, key, pbeParams);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Wrapper class to test a given PBE algorithm.
|
|
*/
|
|
public static class Legacy extends PBECipherWrapper {
|
|
|
|
private static final int PBE_SALT_SIZE = 8;
|
|
|
|
public Legacy(String algo, String passwd)
|
|
throws NoSuchAlgorithmException, NoSuchPaddingException,
|
|
InvalidKeySpecException {
|
|
super(algo, PBE_SALT_SIZE);
|
|
|
|
SecretKeyFactory skf = SecretKeyFactory.getInstance(algo.split("/")[0]);
|
|
key = skf.generateSecret(new PBEKeySpec(passwd.toCharArray()));
|
|
|
|
aps = new PBEParameterSpec(getSalt(), ITERATION_COUNT);
|
|
|
|
ci = Cipher.getInstance(algo);
|
|
}
|
|
|
|
@Override
|
|
protected void initCipher(int mode) throws InvalidKeyException,
|
|
InvalidAlgorithmParameterException, InvalidParameterSpecException {
|
|
ci.init(mode, key, aps);
|
|
}
|
|
}
|
|
}
|