/*
 * 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);
    }
}