754 lines
29 KiB
Java
754 lines
29 KiB
Java
|
/*
|
||
|
|
* Copyright (c) 2007, 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.nio.ByteBuffer;
|
||
|
|
import java.security.AlgorithmParameters;
|
||
|
|
import java.security.Provider;
|
||
|
|
import java.security.Security;
|
||
|
|
import java.util.ArrayList;
|
||
|
|
import java.util.Arrays;
|
||
|
|
import java.util.List;
|
||
|
|
import javax.crypto.SecretKey;
|
||
|
|
import javax.crypto.Cipher;
|
||
|
|
import javax.crypto.KeyGenerator;
|
||
|
|
|
||
|
|
/*
|
||
|
|
* @test
|
||
|
|
* @bug 8048596
|
||
|
|
* @summary AEAD encryption/decryption test
|
||
|
|
*/
|
||
|
|
|
||
|
|
/*
|
||
|
|
* The test does the following:
|
||
|
|
* - create an input text and additional data
|
||
|
|
* - generate a secret key
|
||
|
|
* - instantiate a cipher according to the GCM transformation
|
||
|
|
* - generate an outputText using a single-part encryption/decryption
|
||
|
|
* in AEAD mode
|
||
|
|
* - perform 16 different combinations of multiple-part encryption/decryption
|
||
|
|
* operation in AEAD mode (in encryption mode new Cipher object is created
|
||
|
|
* and initialized with the same secret key and parameters)
|
||
|
|
* - check that all 17 results are equal
|
||
|
|
*
|
||
|
|
* Combinations:
|
||
|
|
*
|
||
|
|
* combination #1
|
||
|
|
* updateAAD(byte[] src)
|
||
|
|
* update(byte[], int, int)
|
||
|
|
* doFinal(byte[], int, int)
|
||
|
|
*
|
||
|
|
* combination #2
|
||
|
|
* updateAAD(byte[] src)
|
||
|
|
* update(byte[], int, int)
|
||
|
|
* doFinal(byte[], int, int, byte[], int)
|
||
|
|
*
|
||
|
|
* combination #3
|
||
|
|
* updateAAD(byte[] src)
|
||
|
|
* update(byte[], int, int, byte[], int)
|
||
|
|
* doFinal(byte[], int, int)
|
||
|
|
*
|
||
|
|
* combination #4
|
||
|
|
* updateAAD(byte[] src)
|
||
|
|
* update(byte[], int, int, byte[], int)
|
||
|
|
* doFinal(byte[], int, int, byte[], int)
|
||
|
|
*
|
||
|
|
* combination #5 - #8 are similar to #1 -#4,
|
||
|
|
* but with updateAAD(byte[] src, int offset, int len)
|
||
|
|
*
|
||
|
|
* combination #9 - #12 are similar to #1 - #4,
|
||
|
|
* but with updateAAD(ByteBuffer src)
|
||
|
|
*
|
||
|
|
* combination #13 - #16 are similar to #9 - #12 but with directly allocated
|
||
|
|
* ByteBuffer and update(ByteBuffer input, ByteBuffer output)
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
public class Encrypt {
|
||
|
|
|
||
|
|
private static final String ALGORITHMS[] = { "AES", "Rijndael" };
|
||
|
|
private static final int KEY_STRENGTHS[] = { 128, 192, 256 };
|
||
|
|
private static final int TEXT_LENGTHS[] = { 0, 256, 1024 };
|
||
|
|
private static final int AAD_LENGTHS[] = { 0, 8, 128, 256, 1024 };
|
||
|
|
private static final int ARRAY_OFFSET = 8;
|
||
|
|
|
||
|
|
private final String transformation;
|
||
|
|
private final Provider provider;
|
||
|
|
private final SecretKey key;
|
||
|
|
private final int textLength;
|
||
|
|
private final int AADLength;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @param provider Security provider
|
||
|
|
* @param algorithm Security algorithm to test
|
||
|
|
* @param mode The mode (GCM is only expected)
|
||
|
|
* @param padding Algorithm padding
|
||
|
|
* @param keyStrength key length
|
||
|
|
* @param textLength Plain text length
|
||
|
|
* @param AADLength Additional data length
|
||
|
|
*/
|
||
|
|
public Encrypt(Provider provider, String algorithm, String mode,
|
||
|
|
String padding, int keyStrength, int textLength, int AADLength)
|
||
|
|
throws Exception {
|
||
|
|
|
||
|
|
// init a secret Key
|
||
|
|
KeyGenerator kg = KeyGenerator.getInstance(algorithm, provider);
|
||
|
|
kg.init(keyStrength);
|
||
|
|
key = kg.generateKey();
|
||
|
|
|
||
|
|
this.provider = provider;
|
||
|
|
this.transformation = algorithm + "/" + mode + "/" + padding;
|
||
|
|
this.textLength = textLength;
|
||
|
|
this.AADLength = AADLength;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static void main(String[] args) throws Exception {
|
||
|
|
Provider p = Security.getProvider("SunJCE");
|
||
|
|
for (String alg : ALGORITHMS) {
|
||
|
|
for (int keyStrength : KEY_STRENGTHS) {
|
||
|
|
if (keyStrength > Cipher.getMaxAllowedKeyLength(alg)) {
|
||
|
|
// skip this if this key length is larger than what's
|
||
|
|
// configured in the JCE jurisdiction policy files
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
for (int textLength : TEXT_LENGTHS) {
|
||
|
|
for (int AADLength : AAD_LENGTHS) {
|
||
|
|
Encrypt test = new Encrypt(p, alg,
|
||
|
|
"GCM", "NoPadding", keyStrength, textLength,
|
||
|
|
AADLength);
|
||
|
|
Cipher cipher = test.createCipher(Cipher.ENCRYPT_MODE,
|
||
|
|
null);
|
||
|
|
AlgorithmParameters params = cipher.getParameters();
|
||
|
|
test.doTest(params);
|
||
|
|
System.out.println("Test " + alg + ":"
|
||
|
|
+ keyStrength + ":" + textLength + ":"
|
||
|
|
+ AADLength + " passed");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public void doTest(AlgorithmParameters params) throws Exception {
|
||
|
|
System.out.println("Test transformation = " + transformation
|
||
|
|
+ ", textLength = " + textLength
|
||
|
|
+ ", AADLength = " + AADLength);
|
||
|
|
byte[] input = Helper.generateBytes(textLength);
|
||
|
|
byte[] AAD = Helper.generateBytes(AADLength);
|
||
|
|
byte[] result = execute(Cipher.ENCRYPT_MODE, AAD, input, params);
|
||
|
|
result = execute(Cipher.DECRYPT_MODE, AAD, result, params);
|
||
|
|
if (!Arrays.equals(input, result)) {
|
||
|
|
throw new RuntimeException("Test failed");
|
||
|
|
}
|
||
|
|
System.out.println("Test passed");
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Create a Cipher object for the requested encryption/decryption mode.
|
||
|
|
*
|
||
|
|
* @param mode encryption or decryption mode
|
||
|
|
* @return Cipher object initiated to perform requested mode operation
|
||
|
|
*/
|
||
|
|
private Cipher createCipher(int mode, AlgorithmParameters params)
|
||
|
|
throws Exception {
|
||
|
|
Cipher ci;
|
||
|
|
if (Cipher.ENCRYPT_MODE == mode) {
|
||
|
|
// create a new Cipher object for encryption
|
||
|
|
ci = Cipher.getInstance(transformation, provider);
|
||
|
|
|
||
|
|
// initiate it with the saved parameters
|
||
|
|
if (params != null) {
|
||
|
|
ci.init(Cipher.ENCRYPT_MODE, key, params);
|
||
|
|
} else {
|
||
|
|
// initiate the cipher without parameters
|
||
|
|
ci.init(Cipher.ENCRYPT_MODE, key);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
// it is expected that parameters already generated
|
||
|
|
// before decryption
|
||
|
|
ci = Cipher.getInstance(transformation, provider);
|
||
|
|
ci.init(Cipher.DECRYPT_MODE, key, params);
|
||
|
|
}
|
||
|
|
|
||
|
|
return ci;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Test AEAD combinations
|
||
|
|
*
|
||
|
|
* @param mode decryption or encryption
|
||
|
|
* @param AAD additional data for AEAD operations
|
||
|
|
* @param inputText plain text to decrypt/encrypt
|
||
|
|
* @return output text after encrypt/decrypt
|
||
|
|
*/
|
||
|
|
public byte[] execute(int mode, byte[] AAD, byte[] inputText,
|
||
|
|
AlgorithmParameters params) throws Exception {
|
||
|
|
|
||
|
|
Cipher cipher = createCipher(mode, params);
|
||
|
|
|
||
|
|
// results of each combination will be saved in the outputTexts
|
||
|
|
List<byte[]> outputTexts = new ArrayList<>();
|
||
|
|
|
||
|
|
// generate a standard outputText using a single-part en/de-cryption
|
||
|
|
cipher.updateAAD(AAD);
|
||
|
|
byte[] output = cipher.doFinal(inputText);
|
||
|
|
|
||
|
|
// execute multiple-part encryption/decryption combinations
|
||
|
|
combination_1(outputTexts, mode, AAD, inputText, params);
|
||
|
|
combination_2(outputTexts, mode, AAD, inputText, params);
|
||
|
|
combination_3(outputTexts, mode, AAD, inputText, params);
|
||
|
|
combination_4(outputTexts, mode, AAD, inputText, params);
|
||
|
|
combination_5(outputTexts, mode, AAD, inputText, params);
|
||
|
|
combination_6(outputTexts, mode, AAD, inputText, params);
|
||
|
|
combination_7(outputTexts, mode, AAD, inputText, params);
|
||
|
|
combination_8(outputTexts, mode, AAD, inputText, params);
|
||
|
|
combination_9(outputTexts, mode, AAD, inputText, params);
|
||
|
|
combination_10(outputTexts, mode, AAD, inputText, params);
|
||
|
|
combination_11(outputTexts, mode, AAD, inputText, params);
|
||
|
|
combination_12(outputTexts, mode, AAD, inputText, params);
|
||
|
|
combination_13(outputTexts, mode, AAD, inputText, params);
|
||
|
|
combination_14(outputTexts, mode, AAD, inputText, params);
|
||
|
|
combination_15(outputTexts, mode, AAD, inputText, params);
|
||
|
|
combination_16(outputTexts, mode, AAD, inputText, params);
|
||
|
|
|
||
|
|
for (int k = 0; k < outputTexts.size(); k++) {
|
||
|
|
if (!Arrays.equals(output, outputTexts.get(k))) {
|
||
|
|
throw new RuntimeException("Combination #" + k + " failed");
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return output;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #1:
|
||
|
|
* updateAAD(byte[] src)
|
||
|
|
* update(byte[], int, int)
|
||
|
|
* doFinal(byte[], int, int)
|
||
|
|
*/
|
||
|
|
private void combination_1(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
Cipher c = createCipher(mode, params);
|
||
|
|
c.updateAAD(AAD);
|
||
|
|
byte[] part11 = c.update(plainText, 0, plainText.length);
|
||
|
|
int part11_length = part11 == null ? 0 : part11.length;
|
||
|
|
byte[] part12 = c.doFinal();
|
||
|
|
byte[] outputText1 = new byte[part11_length + part12.length];
|
||
|
|
if (part11 != null) {
|
||
|
|
System.arraycopy(part11, 0, outputText1, 0, part11_length);
|
||
|
|
}
|
||
|
|
System.arraycopy(part12, 0, outputText1, part11_length, part12.length);
|
||
|
|
results.add(outputText1);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #2:
|
||
|
|
* updateAAD(byte[] src)
|
||
|
|
* update(byte[], int, int)
|
||
|
|
* doFinal(byte[], int, int, byte[], int)
|
||
|
|
*/
|
||
|
|
private void combination_2(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
Cipher c = createCipher(mode, params);
|
||
|
|
c.updateAAD(AAD);
|
||
|
|
int t = 0;
|
||
|
|
int offset = 0;
|
||
|
|
if (plainText.length > ARRAY_OFFSET) {
|
||
|
|
t = plainText.length - ARRAY_OFFSET;
|
||
|
|
offset = ARRAY_OFFSET;
|
||
|
|
}
|
||
|
|
byte[] part21 = c.update(plainText, 0, t);
|
||
|
|
byte[] part22 = new byte[c.getOutputSize(plainText.length)];
|
||
|
|
int len2 = c.doFinal(plainText, t, offset, part22, 0);
|
||
|
|
int part21Length = part21 != null ? part21.length : 0;
|
||
|
|
byte[] outputText2 = new byte[part21Length + len2];
|
||
|
|
if (part21 != null) {
|
||
|
|
System.arraycopy(part21, 0, outputText2, 0, part21Length);
|
||
|
|
}
|
||
|
|
System.arraycopy(part22, 0, outputText2, part21Length, len2);
|
||
|
|
results.add(outputText2);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #3
|
||
|
|
* updateAAD(byte[] src)
|
||
|
|
* update(byte[], int, int, byte[], int)
|
||
|
|
* doFinal(byte[], int, int)
|
||
|
|
*/
|
||
|
|
private void combination_3(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
Cipher ci = createCipher(mode, params);
|
||
|
|
ci.updateAAD(AAD);
|
||
|
|
byte[] part31 = new byte[ci.getOutputSize(plainText.length)];
|
||
|
|
int offset = plainText.length > ARRAY_OFFSET ? ARRAY_OFFSET : 0;
|
||
|
|
int len = ci.update(plainText, 0, plainText.length - offset, part31, 0);
|
||
|
|
byte[] part32 = ci.doFinal(plainText, plainText.length - offset,
|
||
|
|
offset);
|
||
|
|
byte[] outputText3 = new byte[len + part32.length];
|
||
|
|
System.arraycopy(part31, 0, outputText3, 0, len);
|
||
|
|
System.arraycopy(part32, 0, outputText3, len, part32.length);
|
||
|
|
results.add(outputText3);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #4:
|
||
|
|
* updateAAD(byte[] src)
|
||
|
|
* update(byte[], int, int, byte[], int)
|
||
|
|
* doFinal(byte[], int, int, byte[], int)
|
||
|
|
*/
|
||
|
|
private void combination_4(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
Cipher ci = createCipher(mode, params);
|
||
|
|
ci.updateAAD(AAD);
|
||
|
|
byte[] part41 = new byte[ci.getOutputSize(plainText.length)];
|
||
|
|
int offset = plainText.length > ARRAY_OFFSET ? ARRAY_OFFSET : 0;
|
||
|
|
int len = ci.update(plainText, 0, plainText.length - offset, part41, 0);
|
||
|
|
int rest4 = ci.doFinal(plainText, plainText.length - offset, offset,
|
||
|
|
part41, len);
|
||
|
|
byte[] outputText4 = new byte[len + rest4];
|
||
|
|
System.arraycopy(part41, 0, outputText4, 0, outputText4.length);
|
||
|
|
results.add(outputText4);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #5:
|
||
|
|
* updateAAD(byte[] src, int offset, int len)
|
||
|
|
* update(byte[], int, int)
|
||
|
|
* doFinal(byte[], int, int)
|
||
|
|
*/
|
||
|
|
private void combination_5(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
Cipher c = createCipher(mode, params);
|
||
|
|
c.updateAAD(AAD, 0, AAD.length);
|
||
|
|
byte[] part51 = c.update(plainText, 0, plainText.length);
|
||
|
|
byte[] part52 = c.doFinal();
|
||
|
|
int part51Length = part51 != null ? part51.length : 0;
|
||
|
|
byte[] outputText5 = new byte[part51Length + part52.length];
|
||
|
|
if (part51 != null) {
|
||
|
|
System.arraycopy(part51, 0, outputText5, 0, part51Length);
|
||
|
|
}
|
||
|
|
System.arraycopy(part52, 0, outputText5, part51Length, part52.length);
|
||
|
|
results.add(outputText5);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #6:
|
||
|
|
* updateAAD(byte[] src, int offset, int len)
|
||
|
|
* updateAAD(byte[] src, int offset, int len)
|
||
|
|
* update(byte[], int, int) doFinal(byte[], int, int, byte[], int)
|
||
|
|
*/
|
||
|
|
private void combination_6(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
Cipher c = createCipher(mode, params);
|
||
|
|
c.updateAAD(AAD, 0, AAD.length / 2);
|
||
|
|
c.updateAAD(AAD, AAD.length / 2, AAD.length - AAD.length / 2);
|
||
|
|
int t = 0;
|
||
|
|
int offset = 0;
|
||
|
|
if (plainText.length > ARRAY_OFFSET) {
|
||
|
|
t = plainText.length - ARRAY_OFFSET;
|
||
|
|
offset = ARRAY_OFFSET;
|
||
|
|
}
|
||
|
|
byte[] part61 = c.update(plainText, 0, t);
|
||
|
|
byte[] part62 = new byte[c.getOutputSize(plainText.length)];
|
||
|
|
int len = c.doFinal(plainText, t, offset, part62, 0);
|
||
|
|
int part61Length = part61 != null ? part61.length : 0;
|
||
|
|
byte[] outputText6 = new byte[part61Length + len];
|
||
|
|
if (part61 != null) {
|
||
|
|
System.arraycopy(part61, 0, outputText6, 0, part61Length);
|
||
|
|
}
|
||
|
|
System.arraycopy(part62, 0, outputText6, part61Length, len);
|
||
|
|
results.add(outputText6);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #7
|
||
|
|
* updateAAD(byte[] src, int offset, int len)
|
||
|
|
* updateAAD(byte[] src, src.length, 0)
|
||
|
|
* update(byte[], int, int, byte[], int) doFinal(byte[],int, int)
|
||
|
|
*/
|
||
|
|
private void combination_7(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
Cipher ci = createCipher(mode, params);
|
||
|
|
ci.updateAAD(AAD, 0, AAD.length);
|
||
|
|
ci.updateAAD(AAD, AAD.length, 0);
|
||
|
|
byte[] part71 = new byte[ci.getOutputSize(plainText.length)];
|
||
|
|
int offset = plainText.length > ARRAY_OFFSET ? ARRAY_OFFSET : 0;
|
||
|
|
int len = ci.update(plainText, 0, plainText.length - offset, part71, 0);
|
||
|
|
byte[] part72 = ci.doFinal(plainText, plainText.length - offset, offset);
|
||
|
|
byte[] outputText7 = new byte[len + part72.length];
|
||
|
|
System.arraycopy(part71, 0, outputText7, 0, len);
|
||
|
|
System.arraycopy(part72, 0, outputText7, len, part72.length);
|
||
|
|
results.add(outputText7);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #8:
|
||
|
|
* updateAAD(byte[] src, 0, 0)
|
||
|
|
* updateAAD(byte[] src, 0, src.length)
|
||
|
|
* update(byte[], int, int, byte[], int)
|
||
|
|
* doFinal(byte[], int, int, byte[], int)
|
||
|
|
*/
|
||
|
|
private void combination_8(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
Cipher ci = createCipher(mode, params);
|
||
|
|
ci.updateAAD(AAD, 0, 0);
|
||
|
|
ci.updateAAD(AAD, 0, AAD.length);
|
||
|
|
byte[] part81 = new byte[ci.getOutputSize(plainText.length)];
|
||
|
|
int offset = plainText.length > ARRAY_OFFSET ? ARRAY_OFFSET : 0;
|
||
|
|
int len = ci.update(plainText, 0, plainText.length - offset, part81, 0);
|
||
|
|
int rest = ci.doFinal(plainText, plainText.length - offset, offset,
|
||
|
|
part81, len);
|
||
|
|
byte[] outputText8 = new byte[len + rest];
|
||
|
|
System.arraycopy(part81, 0, outputText8, 0, outputText8.length);
|
||
|
|
results.add(outputText8);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #9:
|
||
|
|
* updateAAD(ByteBuffer src)
|
||
|
|
* update(byte[], int, int) doFinal(byte[], int, int)
|
||
|
|
*/
|
||
|
|
private void combination_9(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
|
||
|
|
// prepare ByteBuffer to test
|
||
|
|
ByteBuffer buf = ByteBuffer.allocate(AAD.length);
|
||
|
|
buf.put(AAD);
|
||
|
|
buf.position(0);
|
||
|
|
buf.limit(AAD.length);
|
||
|
|
|
||
|
|
// Get Cipher object and do the combination
|
||
|
|
Cipher c = createCipher(mode, params);
|
||
|
|
c.updateAAD(buf);
|
||
|
|
byte[] part91 = c.update(plainText, 0, plainText.length);
|
||
|
|
int part91_length = part91 == null ? 0 : part91.length;
|
||
|
|
byte[] part92 = c.doFinal();
|
||
|
|
byte[] outputText9 = new byte[part91_length + part92.length];
|
||
|
|
|
||
|
|
// form result of the combination
|
||
|
|
if (part91 != null) {
|
||
|
|
System.arraycopy(part91, 0, outputText9, 0, part91_length);
|
||
|
|
}
|
||
|
|
System.arraycopy(part92, 0, outputText9, part91_length, part92.length);
|
||
|
|
results.add(outputText9);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #10:
|
||
|
|
* updateAAD(ByteBuffer src)
|
||
|
|
* updateAAD(ByteBuffer src) update(byte[], int, int)
|
||
|
|
* doFinal(byte[], int, int, byte[], int)
|
||
|
|
*/
|
||
|
|
private void combination_10(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
|
||
|
|
// prepare ByteBuffer to test
|
||
|
|
ByteBuffer buf = ByteBuffer.allocate(AAD.length);
|
||
|
|
buf.put(AAD);
|
||
|
|
buf.position(0);
|
||
|
|
buf.limit(AAD.length / 2);
|
||
|
|
|
||
|
|
// get a Cipher object and do the combination
|
||
|
|
Cipher c = createCipher(mode, params);
|
||
|
|
|
||
|
|
// process the first half of AAD data
|
||
|
|
c.updateAAD(buf);
|
||
|
|
|
||
|
|
// process the rest of AAD data
|
||
|
|
buf.limit(AAD.length);
|
||
|
|
c.updateAAD(buf);
|
||
|
|
|
||
|
|
// prapare variables for the combination
|
||
|
|
int t = 0;
|
||
|
|
int offset = 0;
|
||
|
|
if (plainText.length > ARRAY_OFFSET) {
|
||
|
|
t = plainText.length - ARRAY_OFFSET;
|
||
|
|
offset = ARRAY_OFFSET;
|
||
|
|
}
|
||
|
|
|
||
|
|
// encrypt the text
|
||
|
|
byte[] part10_1 = c.update(plainText, 0, t);
|
||
|
|
int part10_1_Length = part10_1 != null ? part10_1.length : 0;
|
||
|
|
byte[] part10_2 = new byte[c.getOutputSize(plainText.length)];
|
||
|
|
int len2 = c.doFinal(plainText, t, offset, part10_2, 0);
|
||
|
|
|
||
|
|
// form the combination's result
|
||
|
|
byte[] outputText10 = new byte[part10_1_Length + len2];
|
||
|
|
if (part10_1 != null) {
|
||
|
|
System.arraycopy(part10_1, 0, outputText10, 0, part10_1_Length);
|
||
|
|
}
|
||
|
|
System.arraycopy(part10_2, 0, outputText10, part10_1_Length, len2);
|
||
|
|
results.add(outputText10);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #11
|
||
|
|
* updateAAD(ByteBuffer src1)
|
||
|
|
* updateAAD(ByteBuffer src2)
|
||
|
|
* update(byte[],int, int, byte[], int)
|
||
|
|
* doFinal(byte[], int, int)
|
||
|
|
*/
|
||
|
|
private void combination_11(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
|
||
|
|
// prepare ByteBuffer1 to test
|
||
|
|
ByteBuffer buf1 = ByteBuffer.allocate(AAD.length / 2);
|
||
|
|
buf1.put(AAD, 0, AAD.length / 2);
|
||
|
|
buf1.position(0);
|
||
|
|
buf1.limit(AAD.length / 2);
|
||
|
|
|
||
|
|
// get a Cipher object and do combination
|
||
|
|
Cipher ci = createCipher(mode, params);
|
||
|
|
|
||
|
|
// process the first half of AAD data
|
||
|
|
ci.updateAAD(buf1);
|
||
|
|
|
||
|
|
// prepare ByteBuffer2 to test
|
||
|
|
ByteBuffer buf2 = ByteBuffer.allocate(AAD.length - AAD.length / 2);
|
||
|
|
buf2.put(AAD, AAD.length / 2, AAD.length - AAD.length / 2);
|
||
|
|
buf2.position(0);
|
||
|
|
buf2.limit(AAD.length - AAD.length / 2);
|
||
|
|
|
||
|
|
// process the rest of AAD data
|
||
|
|
ci.updateAAD(buf2);
|
||
|
|
|
||
|
|
// encrypt plain text
|
||
|
|
byte[] part11_1 = new byte[ci.getOutputSize(plainText.length)];
|
||
|
|
int offset = plainText.length > ARRAY_OFFSET ? ARRAY_OFFSET : 0;
|
||
|
|
int len_11 = ci.update(plainText, 0, plainText.length - offset,
|
||
|
|
part11_1, 0);
|
||
|
|
byte[] part11_2 = ci.doFinal(plainText, plainText.length - offset,
|
||
|
|
offset);
|
||
|
|
byte[] outputText11 = new byte[len_11 + part11_2.length];
|
||
|
|
System.arraycopy(part11_1, 0, outputText11, 0, len_11);
|
||
|
|
System.arraycopy(part11_2, 0, outputText11, len_11, part11_2.length);
|
||
|
|
results.add(outputText11);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #12:
|
||
|
|
* updateAAD(ByteBuffer src)
|
||
|
|
* updateAAD(ByteBuffer emptyByteBuffer)
|
||
|
|
* update(byte[], int, int, byte[], int)
|
||
|
|
* doFinal(byte[], int, int, byte[], int)
|
||
|
|
*/
|
||
|
|
private void combination_12(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
|
||
|
|
// prepare ByteBuffer to test
|
||
|
|
ByteBuffer buf = ByteBuffer.allocate(AAD.length);
|
||
|
|
buf.put(AAD);
|
||
|
|
buf.position(0);
|
||
|
|
buf.limit(AAD.length);
|
||
|
|
Cipher ci = createCipher(mode, params);
|
||
|
|
ci.updateAAD(buf);
|
||
|
|
|
||
|
|
// prepare an empty ByteBuffer
|
||
|
|
ByteBuffer emptyBuf = ByteBuffer.allocate(0);
|
||
|
|
emptyBuf.put(new byte[0]);
|
||
|
|
ci.updateAAD(emptyBuf);
|
||
|
|
byte[] part12_1 = new byte[ci.getOutputSize(plainText.length)];
|
||
|
|
int offset = plainText.length > ARRAY_OFFSET ? ARRAY_OFFSET : 0;
|
||
|
|
int len12 = ci.update(plainText, 0, plainText.length - offset,
|
||
|
|
part12_1, 0);
|
||
|
|
int rest12 = ci.doFinal(plainText, plainText.length - offset, offset,
|
||
|
|
part12_1, len12);
|
||
|
|
byte[] outputText12 = new byte[len12 + rest12];
|
||
|
|
System.arraycopy(part12_1, 0, outputText12, 0, outputText12.length);
|
||
|
|
results.add(outputText12);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #13:
|
||
|
|
* updateAAD(ByteBuffer src), where src is directly allocated
|
||
|
|
* update(ByteBuffer input, ByteBuffer out)
|
||
|
|
* doFinal(ByteBuffer input, ByteBuffer out)
|
||
|
|
*/
|
||
|
|
private void combination_13(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
Cipher c = createCipher(mode, params);
|
||
|
|
|
||
|
|
// prepare ByteBuffer to test
|
||
|
|
ByteBuffer buf = ByteBuffer.allocateDirect(AAD.length);
|
||
|
|
buf.put(AAD);
|
||
|
|
buf.position(0);
|
||
|
|
buf.limit(AAD.length);
|
||
|
|
c.updateAAD(buf);
|
||
|
|
|
||
|
|
// prepare buffers to encrypt/decrypt
|
||
|
|
ByteBuffer in = ByteBuffer.allocateDirect(plainText.length);
|
||
|
|
in.put(plainText);
|
||
|
|
in.position(0);
|
||
|
|
in.limit(plainText.length);
|
||
|
|
ByteBuffer output = ByteBuffer.allocateDirect(
|
||
|
|
c.getOutputSize(in.limit()));
|
||
|
|
output.position(0);
|
||
|
|
output.limit(c.getOutputSize(in.limit()));
|
||
|
|
|
||
|
|
// process input text
|
||
|
|
c.update(in, output);
|
||
|
|
c.doFinal(in, output);
|
||
|
|
int resultSize = output.position();
|
||
|
|
byte[] result13 = new byte[resultSize];
|
||
|
|
output.position(0);
|
||
|
|
output.limit(resultSize);
|
||
|
|
output.get(result13, 0, resultSize);
|
||
|
|
results.add(result13);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #14:
|
||
|
|
* updateAAD(ByteBuffer src) updateAAD(ByteBuffer src),
|
||
|
|
* where src is directly allocated
|
||
|
|
* update(ByteBuffer input, ByteBuffer out)
|
||
|
|
* doFinal(ByteBuffer input, ByteBuffer out)
|
||
|
|
*/
|
||
|
|
private void combination_14(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
Cipher c = createCipher(mode, params);
|
||
|
|
// prepare ByteBuffer to test
|
||
|
|
ByteBuffer buf = ByteBuffer.allocateDirect(AAD.length);
|
||
|
|
buf.put(AAD);
|
||
|
|
|
||
|
|
// process the first half of AAD data
|
||
|
|
buf.position(0);
|
||
|
|
buf.limit(AAD.length / 2);
|
||
|
|
c.updateAAD(buf);
|
||
|
|
|
||
|
|
// process the rest of AAD data
|
||
|
|
buf.limit(AAD.length);
|
||
|
|
c.updateAAD(buf);
|
||
|
|
|
||
|
|
// prepare buffers to encrypt/decrypt
|
||
|
|
ByteBuffer in = ByteBuffer.allocate(plainText.length);
|
||
|
|
in.put(plainText);
|
||
|
|
in.position(0);
|
||
|
|
in.limit(plainText.length);
|
||
|
|
ByteBuffer out = ByteBuffer.allocate(c.getOutputSize(in.limit()));
|
||
|
|
out.position(0);
|
||
|
|
out.limit(c.getOutputSize(in.limit()));
|
||
|
|
|
||
|
|
// process input text
|
||
|
|
c.update(in, out);
|
||
|
|
c.doFinal(in, out);
|
||
|
|
int resultSize = out.position();
|
||
|
|
byte[] result14 = new byte[resultSize];
|
||
|
|
out.position(0);
|
||
|
|
out.limit(resultSize);
|
||
|
|
out.get(result14, 0, resultSize);
|
||
|
|
results.add(result14);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #15
|
||
|
|
* updateAAD(ByteBuffer src1), where src1 is directly allocated
|
||
|
|
* updateAAD(ByteBuffer src2), where src2 is directly allocated
|
||
|
|
* doFinal(ByteBuffer input, ByteBuffer out)
|
||
|
|
*/
|
||
|
|
private void combination_15(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
Cipher c = createCipher(mode, params);
|
||
|
|
|
||
|
|
// prepare ByteBuffer1 to test
|
||
|
|
ByteBuffer buf1 = ByteBuffer.allocateDirect(AAD.length / 2);
|
||
|
|
buf1.put(AAD, 0, AAD.length / 2);
|
||
|
|
buf1.position(0);
|
||
|
|
buf1.limit(AAD.length / 2);
|
||
|
|
|
||
|
|
// process the first half of AAD data
|
||
|
|
c.updateAAD(buf1);
|
||
|
|
|
||
|
|
// prepare ByteBuffer2 to test
|
||
|
|
ByteBuffer buf2 = ByteBuffer.allocateDirect(
|
||
|
|
AAD.length - AAD.length / 2);
|
||
|
|
buf2.put(AAD, AAD.length / 2, AAD.length - AAD.length / 2);
|
||
|
|
buf2.position(0);
|
||
|
|
buf2.limit(AAD.length - AAD.length / 2);
|
||
|
|
|
||
|
|
// process the rest of AAD data
|
||
|
|
c.updateAAD(buf2);
|
||
|
|
|
||
|
|
// prepare buffers to encrypt/decrypt
|
||
|
|
ByteBuffer in = ByteBuffer.allocateDirect(plainText.length);
|
||
|
|
in.put(plainText);
|
||
|
|
in.position(0);
|
||
|
|
in.limit(plainText.length);
|
||
|
|
ByteBuffer output = ByteBuffer.allocateDirect(
|
||
|
|
c.getOutputSize(in.limit()));
|
||
|
|
output.position(0);
|
||
|
|
output.limit(c.getOutputSize(in.limit()));
|
||
|
|
|
||
|
|
// process input text
|
||
|
|
c.doFinal(in, output);
|
||
|
|
int resultSize = output.position();
|
||
|
|
byte[] result15 = new byte[resultSize];
|
||
|
|
output.position(0);
|
||
|
|
output.limit(resultSize);
|
||
|
|
output.get(result15, 0, resultSize);
|
||
|
|
results.add(result15);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
* Execute multiple-part encryption/decryption combination #16:
|
||
|
|
* updateAAD(ByteBuffer src)
|
||
|
|
* updateAAD(ByteBuffer emptyByteBuffer)
|
||
|
|
* update(ByteBuffer input, ByteBuffer out)
|
||
|
|
* doFinal(EmptyByteBuffer, ByteBuffer out)
|
||
|
|
*/
|
||
|
|
private void combination_16(List<byte[]> results, int mode, byte[] AAD,
|
||
|
|
byte[] plainText, AlgorithmParameters params) throws Exception {
|
||
|
|
Cipher c = createCipher(mode, params);
|
||
|
|
|
||
|
|
// prepare ByteBuffer to test
|
||
|
|
ByteBuffer buf = ByteBuffer.allocateDirect(AAD.length);
|
||
|
|
buf.put(AAD);
|
||
|
|
buf.position(0);
|
||
|
|
buf.limit(AAD.length);
|
||
|
|
c.updateAAD(buf);
|
||
|
|
|
||
|
|
// prepare empty ByteBuffer
|
||
|
|
ByteBuffer emptyBuf = ByteBuffer.allocateDirect(0);
|
||
|
|
emptyBuf.put(new byte[0]);
|
||
|
|
c.updateAAD(emptyBuf);
|
||
|
|
|
||
|
|
// prepare buffers to encrypt/decrypt
|
||
|
|
ByteBuffer in = ByteBuffer.allocateDirect(plainText.length);
|
||
|
|
in.put(plainText);
|
||
|
|
in.position(0);
|
||
|
|
in.limit(plainText.length);
|
||
|
|
ByteBuffer output = ByteBuffer.allocateDirect(
|
||
|
|
c.getOutputSize(in.limit()));
|
||
|
|
output.position(0);
|
||
|
|
output.limit(c.getOutputSize(in.limit()));
|
||
|
|
|
||
|
|
// process input text with an empty buffer
|
||
|
|
c.update(in, output);
|
||
|
|
ByteBuffer emptyBuf2 = ByteBuffer.allocate(0);
|
||
|
|
emptyBuf2.put(new byte[0]);
|
||
|
|
c.doFinal(emptyBuf2, output);
|
||
|
|
int resultSize = output.position();
|
||
|
|
byte[] result16 = new byte[resultSize];
|
||
|
|
output.position(0);
|
||
|
|
output.limit(resultSize);
|
||
|
|
output.get(result16, 0, resultSize);
|
||
|
|
results.add(result16);
|
||
|
|
}
|
||
|
|
}
|