jdk-sandbox: comparison jdk/test/com/sun/crypto/provider/Cipher/AEAD/Encrypt.java

equal deleted inserted replaced

-:87b015c2cd36
+:734897b86adf
+/*
+* 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);
+}
+}