test/jdk/com/sun/crypto/provider/Cipher/AEAD/ReadWriteSkip.java - platform/libcore - Git at Google

 /*
  * 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.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.security.GeneralSecurityException;
 import java.security.NoSuchAlgorithmException;
 import java.util.Arrays;
 import javax.crypto.Cipher;
 import javax.crypto.CipherInputStream;
 import javax.crypto.CipherOutputStream;
 import javax.crypto.KeyGenerator;
 import javax.crypto.SecretKey;

 /*
  * @test
  * @bug 8048596
  * @summary Test CICO AEAD read/write/skip operations
  */
 public class ReadWriteSkip {

     static enum BufferType {
         BYTE_ARRAY_BUFFERING, INT_BYTE_BUFFERING
     }

     static final int KEY_LENGTHS[] = {128, 192, 256};
     static final int TXT_LENGTHS[] = {800, 0};
     static final int AAD_LENGTHS[] = {0, 100};
     static final int BLOCK = 50;
     static final int SAVE = 45;
     static final int DISCARD = BLOCK - SAVE;
     static final String PROVIDER = "SunJCE";
     static final String AES = "AES";
     static final String GCM = "GCM";
     static final String PADDING = "NoPadding";
     static final String TRANSFORM = AES + "/" + GCM + "/" + PADDING;

     final SecretKey key;
     final byte[] plaintext;
     final byte[] AAD;
     final int textLength;;
     final int keyLength;
     Cipher encryptCipher;
     Cipher decryptCipher;
     CipherInputStream ciInput;

     public static void main(String[] args) throws Exception {
         boolean success = true;
         for (int keyLength : KEY_LENGTHS) {
             if (keyLength > Cipher.getMaxAllowedKeyLength(TRANSFORM)) {
                 // skip this if this key length is larger than what's
                 // configured in the jce jurisdiction policy files
                 continue;
             }
             for (int textLength : TXT_LENGTHS) {
                 for (int AADLength : AAD_LENGTHS) {
                     System.out.println("Key length = " + keyLength
                             + ", text length = " + textLength
                             + ", AAD length = " + AADLength);
                     try {
                         run(keyLength, textLength, AADLength);
                         System.out.println("Test case passed");
                     } catch (Exception e) {
                         System.out.println("Test case failed: " + e);
                         success = false;
                     }
                 }
             }
         }

         if (!success) {
             throw new RuntimeException("At least one test case failed");
         }

         System.out.println("Test passed");
     }

     ReadWriteSkip(int keyLength, int textLength, int AADLength)
             throws Exception {
         this.keyLength = keyLength;
         this.textLength = textLength;

         // init AAD
         this.AAD = Helper.generateBytes(AADLength);

         // init a secret Key
         KeyGenerator kg = KeyGenerator.getInstance(AES, PROVIDER);
         kg.init(this.keyLength);
         this.key = kg.generateKey();

         this.plaintext = Helper.generateBytes(textLength);
     }

     final void doTest(BufferType type) throws Exception {
         // init ciphers
         encryptCipher = createCipher(Cipher.ENCRYPT_MODE);
         decryptCipher = createCipher(Cipher.DECRYPT_MODE);

         // init cipher input stream
         ciInput = new CipherInputStream(new ByteArrayInputStream(plaintext),
                 encryptCipher);

         runTest(type);
     }

     void runTest(BufferType type) throws Exception {}

     private Cipher createCipher(int mode) throws GeneralSecurityException {
         Cipher cipher = Cipher.getInstance(TRANSFORM, PROVIDER);
         if (mode == Cipher.ENCRYPT_MODE) {
             cipher.init(Cipher.ENCRYPT_MODE, key);
         } else {
             if (encryptCipher != null) {
                 cipher.init(Cipher.DECRYPT_MODE, key,
                         encryptCipher.getParameters());
             } else {
                 throw new RuntimeException("Can't create a cipher");
             }
         }
         cipher.updateAAD(AAD);
         return cipher;
     }

     /*
      * Run test cases
      */
     static void run(int keyLength, int textLength, int AADLength)
             throws Exception {
         new ReadWriteTest(keyLength, textLength, AADLength)
                 .doTest(BufferType.BYTE_ARRAY_BUFFERING);
         new ReadWriteTest(keyLength, textLength, AADLength)
                 .doTest(BufferType.INT_BYTE_BUFFERING);
         new SkipTest(keyLength, textLength, AADLength)
                 .doTest(BufferType.BYTE_ARRAY_BUFFERING);
         new SkipTest(keyLength, textLength, AADLength)
                 .doTest(BufferType.INT_BYTE_BUFFERING);
     }

     static void check(byte[] first, byte[] second) {
         if (!Arrays.equals(first, second)) {
             throw new RuntimeException("Arrays are not equal");
         }
     }

     /*
      * CICO AEAD read/write functional test.
      *
      * Check if encrypt/decrypt operations work correctly.
      *
      * Test scenario:
      *   - initializes plain text
      *   - for given AEAD algorithm instantiates encrypt and decrypt Ciphers
      *   - instantiates CipherInputStream with the encrypt Cipher
      *   - instantiates CipherOutputStream with the decrypt Cipher
      *   - performs reading from the CipherInputStream (encryption data)
      *     and writing to the CipherOutputStream (decryption). As a result,
      *     output of the CipherOutputStream should be equal
      *     with original plain text
      *   - check if the original plain text is equal to output
      *     of the CipherOutputStream
      *   - if it is equal the test passes, otherwise it fails
      */
     static class ReadWriteTest extends ReadWriteSkip {

         public ReadWriteTest(int keyLength, int textLength, int AADLength)
                 throws Exception {
             super(keyLength, textLength, AADLength);
         }

         @Override
         public void runTest(BufferType bufType) throws IOException,
                 GeneralSecurityException {

             ByteArrayOutputStream baOutput = new ByteArrayOutputStream();
             try (CipherOutputStream ciOutput = new CipherOutputStream(baOutput,
                     decryptCipher)) {
                 if (bufType == BufferType.BYTE_ARRAY_BUFFERING) {
                     doByteTest(ciOutput);
                 } else {
                     doIntTest(ciOutput);
                 }
             }

             check(plaintext, baOutput.toByteArray());
         }

         /*
          * Implements byte array buffering type test case
          */
         public void doByteTest(CipherOutputStream out) throws IOException {
             byte[] buffer = Helper.generateBytes(textLength + 1);
             int len = ciInput.read(buffer);
             while (len != -1) {
                 out.write(buffer, 0, len);
                 len = ciInput.read(buffer);
             }
         }

         /*
          * Implements integer buffering type test case
          */
         public void doIntTest(CipherOutputStream out) throws IOException {
             int buffer = ciInput.read();
             while (buffer != -1) {
                 out.write(buffer);
                 buffer = ciInput.read();
             }
         }
     }

     /*
      * CICO AEAD SKIP functional test.
      *
      * Checks if the encrypt/decrypt operations work correctly
      * when skip() method is used.
      *
      * Test scenario:
      *   - initializes a plain text
      *   - initializes ciphers
      *   - initializes cipher streams
      *   - split plain text to TEXT_SIZE/BLOCK blocks
      *   - read from CipherInputStream2 one block at time
      *   - the last DISCARD = BLOCK - SAVE bytes are skipping for each block
      *   - therefore, plain text data go through CipherInputStream1 (encrypting)
      *     and CipherInputStream2 (decrypting)
      *   - as a result, output should equal to the original text
      *     except DISCART byte for each block
      *   - check result buffers
      */
     static class SkipTest extends ReadWriteSkip {

         private final int numberOfBlocks;
         private final byte[] outputText;

         public SkipTest(int keyLength, int textLength, int AADLength)
                 throws Exception {
             super(keyLength, textLength, AADLength);
             numberOfBlocks = this.textLength / BLOCK;
             outputText = new byte[numberOfBlocks * SAVE];
         }

         private void doByteTest(int blockNum, CipherInputStream cis)
                 throws IOException {
             int index = blockNum * SAVE;
             int len = cis.read(outputText, index, SAVE);
             index += len;
             int read = 0;
             while (len != SAVE && read != -1) {
                 read = cis.read(outputText, index, SAVE - len);
                 len += read;
                 index += read;
             }
         }

         private void doIntTest(int blockNum, CipherInputStream cis)
                 throws IOException {
             int i = blockNum * SAVE;
             for (int j = 0; j < SAVE && i < outputText.length; j++, i++) {
                 int b = cis.read();
                 if (b != -1) {
                     outputText[i] = (byte) b;
                 }
             }
         }

         @Override
         public void runTest(BufferType type) throws IOException,
                 NoSuchAlgorithmException {
             try (CipherInputStream cis = new CipherInputStream(ciInput,
                     decryptCipher)) {
                 for (int i = 0; i < numberOfBlocks; i++) {
                     if (type == BufferType.BYTE_ARRAY_BUFFERING) {
                         doByteTest(i, cis);
                     } else {
                         doIntTest(i, cis);
                     }
                     if (cis.available() >= DISCARD) {
                         cis.skip(DISCARD);
                     } else {
                         for (int k = 0; k < DISCARD; k++) {
                             cis.read();
                         }
                     }
                 }
             }

             byte[] expectedText = new byte[numberOfBlocks * SAVE];
             for (int m = 0; m < numberOfBlocks; m++) {
                 for (int n = 0; n < SAVE; n++) {
                     expectedText[m * SAVE + n] = plaintext[m * BLOCK + n];
                 }
             }
             check(expectedText, outputText);
         }
     }
 }
	/*
	* 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.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.security.GeneralSecurityException;
	import java.security.NoSuchAlgorithmException;
	import java.util.Arrays;
	import javax.crypto.Cipher;
	import javax.crypto.CipherInputStream;
	import javax.crypto.CipherOutputStream;
	import javax.crypto.KeyGenerator;
	import javax.crypto.SecretKey;

	/*
	* @test
	* @bug 8048596
	* @summary Test CICO AEAD read/write/skip operations
	*/
	public class ReadWriteSkip {

	static enum BufferType {
	BYTE_ARRAY_BUFFERING, INT_BYTE_BUFFERING
	}

	static final int KEY_LENGTHS[] = {128, 192, 256};
	static final int TXT_LENGTHS[] = {800, 0};
	static final int AAD_LENGTHS[] = {0, 100};
	static final int BLOCK = 50;
	static final int SAVE = 45;
	static final int DISCARD = BLOCK - SAVE;
	static final String PROVIDER = "SunJCE";
	static final String AES = "AES";
	static final String GCM = "GCM";
	static final String PADDING = "NoPadding";
	static final String TRANSFORM = AES + "/" + GCM + "/" + PADDING;

	final SecretKey key;
	final byte[] plaintext;
	final byte[] AAD;
	final int textLength;;
	final int keyLength;
	Cipher encryptCipher;
	Cipher decryptCipher;
	CipherInputStream ciInput;

	public static void main(String[] args) throws Exception {
	boolean success = true;
	for (int keyLength : KEY_LENGTHS) {
	if (keyLength > Cipher.getMaxAllowedKeyLength(TRANSFORM)) {
	// skip this if this key length is larger than what's
	// configured in the jce jurisdiction policy files
	continue;
	}
	for (int textLength : TXT_LENGTHS) {
	for (int AADLength : AAD_LENGTHS) {
	System.out.println("Key length = " + keyLength
	+ ", text length = " + textLength
	+ ", AAD length = " + AADLength);
	try {
	run(keyLength, textLength, AADLength);
	System.out.println("Test case passed");
	} catch (Exception e) {
	System.out.println("Test case failed: " + e);
	success = false;
	}
	}
	}
	}

	if (!success) {
	throw new RuntimeException("At least one test case failed");
	}

	System.out.println("Test passed");
	}

	ReadWriteSkip(int keyLength, int textLength, int AADLength)
	throws Exception {
	this.keyLength = keyLength;
	this.textLength = textLength;

	// init AAD
	this.AAD = Helper.generateBytes(AADLength);

	// init a secret Key
	KeyGenerator kg = KeyGenerator.getInstance(AES, PROVIDER);
	kg.init(this.keyLength);
	this.key = kg.generateKey();

	this.plaintext = Helper.generateBytes(textLength);
	}

	final void doTest(BufferType type) throws Exception {
	// init ciphers
	encryptCipher = createCipher(Cipher.ENCRYPT_MODE);
	decryptCipher = createCipher(Cipher.DECRYPT_MODE);

	// init cipher input stream
	ciInput = new CipherInputStream(new ByteArrayInputStream(plaintext),
	encryptCipher);

	runTest(type);
	}

	void runTest(BufferType type) throws Exception {}

	private Cipher createCipher(int mode) throws GeneralSecurityException {
	Cipher cipher = Cipher.getInstance(TRANSFORM, PROVIDER);
	if (mode == Cipher.ENCRYPT_MODE) {
	cipher.init(Cipher.ENCRYPT_MODE, key);
	} else {
	if (encryptCipher != null) {
	cipher.init(Cipher.DECRYPT_MODE, key,
	encryptCipher.getParameters());
	} else {
	throw new RuntimeException("Can't create a cipher");
	}
	}
	cipher.updateAAD(AAD);
	return cipher;
	}

	/*
	* Run test cases
	*/
	static void run(int keyLength, int textLength, int AADLength)
	throws Exception {
	new ReadWriteTest(keyLength, textLength, AADLength)
	.doTest(BufferType.BYTE_ARRAY_BUFFERING);
	new ReadWriteTest(keyLength, textLength, AADLength)
	.doTest(BufferType.INT_BYTE_BUFFERING);
	new SkipTest(keyLength, textLength, AADLength)
	.doTest(BufferType.BYTE_ARRAY_BUFFERING);
	new SkipTest(keyLength, textLength, AADLength)
	.doTest(BufferType.INT_BYTE_BUFFERING);
	}

	static void check(byte[] first, byte[] second) {
	if (!Arrays.equals(first, second)) {
	throw new RuntimeException("Arrays are not equal");
	}
	}

	/*
	* CICO AEAD read/write functional test.
	*
	* Check if encrypt/decrypt operations work correctly.
	*
	* Test scenario:
	* - initializes plain text
	* - for given AEAD algorithm instantiates encrypt and decrypt Ciphers
	* - instantiates CipherInputStream with the encrypt Cipher
	* - instantiates CipherOutputStream with the decrypt Cipher
	* - performs reading from the CipherInputStream (encryption data)
	* and writing to the CipherOutputStream (decryption). As a result,
	* output of the CipherOutputStream should be equal
	* with original plain text
	* - check if the original plain text is equal to output
	* of the CipherOutputStream
	* - if it is equal the test passes, otherwise it fails
	*/
	static class ReadWriteTest extends ReadWriteSkip {

	public ReadWriteTest(int keyLength, int textLength, int AADLength)
	throws Exception {
	super(keyLength, textLength, AADLength);
	}

	@Override
	public void runTest(BufferType bufType) throws IOException,
	GeneralSecurityException {

	ByteArrayOutputStream baOutput = new ByteArrayOutputStream();
	try (CipherOutputStream ciOutput = new CipherOutputStream(baOutput,
	decryptCipher)) {
	if (bufType == BufferType.BYTE_ARRAY_BUFFERING) {
	doByteTest(ciOutput);
	} else {
	doIntTest(ciOutput);
	}
	}

	check(plaintext, baOutput.toByteArray());
	}

	/*
	* Implements byte array buffering type test case
	*/
	public void doByteTest(CipherOutputStream out) throws IOException {
	byte[] buffer = Helper.generateBytes(textLength + 1);
	int len = ciInput.read(buffer);
	while (len != -1) {
	out.write(buffer, 0, len);
	len = ciInput.read(buffer);
	}
	}

	/*
	* Implements integer buffering type test case
	*/
	public void doIntTest(CipherOutputStream out) throws IOException {
	int buffer = ciInput.read();
	while (buffer != -1) {
	out.write(buffer);
	buffer = ciInput.read();
	}
	}
	}

	/*
	* CICO AEAD SKIP functional test.
	*
	* Checks if the encrypt/decrypt operations work correctly
	* when skip() method is used.
	*
	* Test scenario:
	* - initializes a plain text
	* - initializes ciphers
	* - initializes cipher streams
	* - split plain text to TEXT_SIZE/BLOCK blocks
	* - read from CipherInputStream2 one block at time
	* - the last DISCARD = BLOCK - SAVE bytes are skipping for each block
	* - therefore, plain text data go through CipherInputStream1 (encrypting)
	* and CipherInputStream2 (decrypting)
	* - as a result, output should equal to the original text
	* except DISCART byte for each block
	* - check result buffers
	*/
	static class SkipTest extends ReadWriteSkip {

	private final int numberOfBlocks;
	private final byte[] outputText;

	public SkipTest(int keyLength, int textLength, int AADLength)
	throws Exception {
	super(keyLength, textLength, AADLength);
	numberOfBlocks = this.textLength / BLOCK;
	outputText = new byte[numberOfBlocks * SAVE];
	}

	private void doByteTest(int blockNum, CipherInputStream cis)
	throws IOException {
	int index = blockNum * SAVE;
	int len = cis.read(outputText, index, SAVE);
	index += len;
	int read = 0;
	while (len != SAVE && read != -1) {
	read = cis.read(outputText, index, SAVE - len);
	len += read;
	index += read;
	}
	}

	private void doIntTest(int blockNum, CipherInputStream cis)
	throws IOException {
	int i = blockNum * SAVE;
	for (int j = 0; j < SAVE && i < outputText.length; j++, i++) {
	int b = cis.read();
	if (b != -1) {
	outputText[i] = (byte) b;
	}
	}
	}

	@Override
	public void runTest(BufferType type) throws IOException,
	NoSuchAlgorithmException {
	try (CipherInputStream cis = new CipherInputStream(ciInput,
	decryptCipher)) {
	for (int i = 0; i < numberOfBlocks; i++) {
	if (type == BufferType.BYTE_ARRAY_BUFFERING) {
	doByteTest(i, cis);
	} else {
	doIntTest(i, cis);
	}
	if (cis.available() >= DISCARD) {
	cis.skip(DISCARD);
	} else {
	for (int k = 0; k < DISCARD; k++) {
	cis.read();
	}
	}
	}
	}

	byte[] expectedText = new byte[numberOfBlocks * SAVE];
	for (int m = 0; m < numberOfBlocks; m++) {
	for (int n = 0; n < SAVE; n++) {
	expectedText[m * SAVE + n] = plaintext[m * BLOCK + n];
	}
	}
	check(expectedText, outputText);
	}
	}
	}