jdk-sandbox: comparison jdk/test/java/security/MessageDigest/TestSameValue.java

equal deleted inserted replaced

-:bd8975d946b8
+:e31b47204f64
 /*
-* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 2015, 2016, 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.
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */
 import static java.lang.System.out;
 import java.nio.ByteBuffer;
 import java.security.DigestException;
 import java.security.MessageDigest;
-import java.util.Random;
+import java.security.NoSuchAlgorithmException;
+import java.security.Security;
+import jdk.testlibrary.RandomFactory;
 /**
 * @test
-* @bug 8050371
+* @bug 8050371 8156059
 * @summary Check md.digest(data) value whether same with digest output value
 *          with various update/digest methods.
 * @author Kevin Liu
 * @key randomness
+* @library /lib/testlibrary
 */
 public class TestSameValue {
 public static void main(String[] args) throws Exception {
 private void run() throws Exception {
 byte[] data = new byte[6706];
 MessageDigest md = null;
 // Initialize input data
-new Random().nextBytes(data);
+RandomFactory.getRandom().nextBytes(data);
-String[] providers = {
+String[] algorithmArr = { "SHA", "Sha", "MD5", "md5", "SHA-224",
-null, "SUN"
+"SHA-256", "SHA-384", "SHA-512", "SHA3-224", "SHA3-256",
-};
+"SHA3-384", "SHA3-512" };
-String[] algorithmArr = {
-"SHA", "Sha", "MD5", "md5", "SHA-224", "SHA-256", "SHA-384",
+for (String algorithm : algorithmArr) {
-"SHA-512"
+try {
-};
+md = MessageDigest.getInstance(algorithm);
-for (String algorithm: algorithmArr) {
+for (UpdateDigestMethod updateMethod : UpdateDigestMethod
-for (String provider: providers) {
-if (provider != null) {
-md = MessageDigest.getInstance(algorithm, provider);
-} else {
-md = MessageDigest.getInstance(algorithm);
-}
-for (UpdateDigestMethod updateMethod: UpdateDigestMethod
 .values()) {
 byte[] output = updateMethod.updateDigest(data, md);
 // Get the output and the "correct" one
 byte[] standard = md.digest(data);
 // Compare input and output
 if (!MessageDigest.isEqual(output, standard)) {
 throw new RuntimeException(
 "Test failed at algorithm/provider/numUpdate:"
-+ algorithm + "/" + provider + "/"
++ algorithm + "/" + md.getProvider()
-+ updateMethod);
++ "/" + updateMethod);
 }
 }
+} catch (NoSuchAlgorithmException nae) {
+if (algorithm.startsWith("SHA3") && !isSHA3supported()) {
+continue;
+} else {
+throw nae;
+}
 }
 }
-out.println("All " + algorithmArr.length
+out.println("All "
-* UpdateDigestMethod.values().length * providers.length
++ algorithmArr.length * UpdateDigestMethod.values().length
 + " tests Passed");
 }
+// SHA-3 hash algorithms are only supported by "SUN" provider
+// and "OracleUcrypto" provider on Solaris 12.0 or later
+// This method checks if system supports SHA-3
+private boolean isSHA3supported() {
+if (Security.getProvider("SUN") != null) {
+return true;
+}
+if (Security.getProvider("OracleUcrypto") != null
+&& "SunOS".equals(System.getProperty("os.name"))
+&& System.getProperty("os.version").compareTo("5.12") >= 0) {
+return true;
+}
+return false;
+}
 private static enum UpdateDigestMethod {
 /*
-* update the data one by one using method update(byte input) then
+* update the data one by one using method update(byte input) then do
-* do digest (giving the output buffer, offset, and the number of
+* digest (giving the output buffer, offset, and the number of bytes to
-* bytes to put in the output buffer)
+* put in the output buffer)
 */
 UPDATE_DIGEST_BUFFER {
 @Override
 public byte[] updateDigest(byte[] data, MessageDigest md)
 throws DigestException {
-for (byte element: data) {
+for (byte element : data) {
 md.update(element);
 }
 byte[] output = new byte[md.getDigestLength()];
 int len = md.digest(output, 0, output.length);
 if (len != output.length) {
 throw new RuntimeException(
 "ERROR" + ": digest length differs!");
 }
 return output;
 }
 },
 /*
-* update the data one by one using method update(byte input)
+* update the data one by one using method update(byte input) then do
-* then do digest
+* digest
 */
 UPDATE_DIGEST {
 @Override
 public byte[] updateDigest(byte[] data, MessageDigest md) {
-for (byte element: data) {
+for (byte element : data) {
 md.update(element);
 }
 return md.digest();
 }
 },
 md.update(data);
 byte[] output = new byte[md.getDigestLength()];
 int len = md.digest(output, 0, output.length);
 if (len != output.length) {
 throw new RuntimeException(
 "ERROR" + ": digest length differs!");
 }
 return output;
 }
 },
 return md.digest();
 }
 },
 /*
-* update the leading bytes (length is "data.length-LASTNBYTES")
+* update the leading bytes (length is "data.length-LASTNBYTES") at once
-* at once as a block, then do digest (do a final update using
+* as a block, then do digest (do a final update using the left
-* the left LASTNBYTES bytes which is passed as a parameter for
+* LASTNBYTES bytes which is passed as a parameter for the digest
-* the digest method, then complete the digest)
+* method, then complete the digest)
 */
 UPDATE_LEADING_BLOCK_DIGEST_REMAIN {
 @Override
 public byte[] updateDigest(byte[] data, MessageDigest md) {
 byte[] mainPart = new byte[data.length - LASTNBYTES];
 return md.digest(REMAIN);
 }
 },
 /*
-* update the data 2 bytes each time, after finishing updating,
+* update the data 2 bytes each time, after finishing updating, do
-* do digest (giving the output buffer, offset, and the number
+* digest (giving the output buffer, offset, and the number of bytes to
-* of bytes to put in the output buffer)
+* put in the output buffer)
 */
 UPDATE_BYTES_DIGEST_BUFFER {
 @Override
 public byte[] updateDigest(byte[] data, MessageDigest md)
 throws DigestException {
 }
 byte[] output = new byte[md.getDigestLength()];
 int len = md.digest(output, 0, output.length);
 if (len != output.length) {
 throw new RuntimeException(
 "ERROR" + ": digest length differs!");
 }
 return output;
 }
 },
 /*
-* update the data 2 bytes each time, after finishing updating,
+* update the data 2 bytes each time, after finishing updating, do
-* do digest
+* digest
 */
 UPDATE_BYTES_DIGEST {
 @Override
 public byte[] updateDigest(byte[] data, MessageDigest md) {
-for (int i=0;i<data.length/2;i++){
+for (int i = 0; i < data.length / 2; i++) {
-md.update(data,i*2,2);
+md.update(data, i * 2, 2);
 }
 return md.digest();
 }
 },
 /*
-* update the data one by one using method update(byte[] input,
+* update the data one by one using method update(byte[] input, int
-* int offset, int len) for the leading bytes (length is
+* offset, int len) for the leading bytes (length is
-* "data.length-LASTNBYTES"), then do digest (do a final
+* "data.length-LASTNBYTES"), then do digest (do a final update using
-* update using the left LASTNBYTES bytes which is passed
+* the left LASTNBYTES bytes which is passed as a parameter for digest
-* as a parameter for digest method then complete the digest)
+* method then complete the digest)
 */
 UPDATE_BUFFER_LEADING_DIGEST_REMAIN {
 @Override
 public byte[] updateDigest(byte[] data, MessageDigest md) {
 for (int i = 0; i < data.length - LASTNBYTES; i++) {
 return md.digest(REMAIN);
 }
 },
 /*
-* update the data one by one using method update(byte input)
+* update the data one by one using method update(byte input) for the
-* for the leading bytes (length is "data.length-LASTNBYTES"),
+* leading bytes (length is "data.length-LASTNBYTES"), then do digest
-* then do digest (do a final update using the left LASTNBYTES
+* (do a final update using the left LASTNBYTES bytes which is passed as
-* bytes which is passed as a parameter for digest method,
+* a parameter for digest method, then complete the digest)
-* then complete the digest)
 */
 UPDATE_LEADING_DIGEST_REMAIN {
 @Override
 public byte[] updateDigest(byte[] data, MessageDigest md) {
 for (int i = 0; i < data.length - LASTNBYTES; i++) {
 return md.digest(REMAIN);
 }
 },
 /*
-* update all the data at once as a ByteBuffer, then do digest
+* update all the data at once as a ByteBuffer, then do digest (giving
-* (giving the output buffer, offset, and the number of bytes
+* the output buffer, offset, and the number of bytes to put in the
-* to put in the output buffer)
+* output buffer)
 */
 UPDATE_BYTE_BUFFER_DIGEST_BUFFER {
 @Override
 public byte[] updateDigest(byte[] data, MessageDigest md)
 throws DigestException {
 md.update(ByteBuffer.wrap(data));
 byte[] output = new byte[md.getDigestLength()];
 int len = md.digest(output, 0, output.length);
 if (len != output.length) {
 throw new RuntimeException(
 "ERROR" + ": digest length differs!");
 }
 return output;
 }
 },
 return md.digest();
 }
 },
 /*
-* update the leading bytes (length is "data.length-LASTNBYTES")
+* update the leading bytes (length is "data.length-LASTNBYTES") at once
-* at once as a ByteBuffer, then do digest (do a final update
+* as a ByteBuffer, then do digest (do a final update using the left
-* using the left LASTNBYTES bytes which is passed as a parameter
+* LASTNBYTES bytes which is passed as a parameter for the digest
-* for the digest method, then complete the digest)
+* method, then complete the digest)
 */
 UPDATE_BYTE_BUFFER_LEADING_DIGEST_REMAIN {
 @Override
 public byte[] updateDigest(byte[] data, MessageDigest md) {
 byte[] mainPart = new byte[data.length - LASTNBYTES];

changeset 38761	e31b47204f64
parent 30046	cf2c86e1819e
child 45288	58be10a068c2