From f98fce70125511b2283f367f2950fa65318b18c7 Mon Sep 17 00:00:00 2001 From: nathan Date: Sun, 15 Nov 2015 20:29:12 +0100 Subject: [PATCH] Updated dependencies for bouncycastle --- .../dorkbox/util/crypto/AesByteBufTest.java | 32 +++++----- .../test/dorkbox/util/crypto/AesTest.java | 32 +++++----- .../test/dorkbox/util/crypto/DsaTest.java | 22 +++---- .../test/dorkbox/util/crypto/EccTest.java | 62 +++++++++---------- .../test/dorkbox/util/crypto/RsaTest.java | 14 ++--- .../test/dorkbox/util/crypto/SCryptTest.java | 6 +- .../test/dorkbox/util/crypto/x509Test.java | 6 +- 7 files changed, 87 insertions(+), 87 deletions(-) diff --git a/Dorkbox-Util/test/dorkbox/util/crypto/AesByteBufTest.java b/Dorkbox-Util/test/dorkbox/util/crypto/AesByteBufTest.java index 45d67f3..26bdd23 100644 --- a/Dorkbox-Util/test/dorkbox/util/crypto/AesByteBufTest.java +++ b/Dorkbox-Util/test/dorkbox/util/crypto/AesByteBufTest.java @@ -67,12 +67,12 @@ public class AesByteBufTest { ByteBuf source = Unpooled.wrappedBuffer(SOURCE); int length = SOURCE.length; ByteBuf encryptAES = Unpooled.buffer(1024); - int encryptLength = Crypto.AES.encrypt(aesEngine1, aesIVAndKey, source, encryptAES, length, logger); + int encryptLength = CryptoAES.encrypt(aesEngine1, aesIVAndKey, source, encryptAES, length, logger); byte[] encrypt = new byte[encryptLength]; System.arraycopy(encryptAES.array(), 0, encrypt, 0, encryptLength); - byte[] encrypt2 = Crypto.AES.encrypt(aesEngine2, key, iv, SOURCE, logger); + byte[] encrypt2 = CryptoAES.encrypt(aesEngine2, key, iv, SOURCE, logger); if (Arrays.equals(SOURCE, encrypt)) { @@ -105,13 +105,13 @@ public class AesByteBufTest { ByteBuf source = Unpooled.wrappedBuffer(SOURCE); int length = SOURCE.length; ByteBuf encryptAES = Unpooled.buffer(1024); - int encryptLength = Crypto.AES.encrypt(aesEngine1, aesIVAndKey, source, encryptAES, length, logger); + int encryptLength = CryptoAES.encrypt(aesEngine1, aesIVAndKey, source, encryptAES, length, logger); byte[] encrypt = new byte[encryptLength]; System.arraycopy(encryptAES.array(), 0, encrypt, 0, encryptLength); - byte[] encrypt2 = Crypto.AES.encrypt(aesEngine2, key, iv, SOURCE, logger); + byte[] encrypt2 = CryptoAES.encrypt(aesEngine2, key, iv, SOURCE, logger); if (Arrays.equals(SOURCE, encrypt)) { @@ -142,13 +142,13 @@ public class AesByteBufTest { ByteBuf source = Unpooled.wrappedBuffer(bytes); int length = bytes.length; ByteBuf encryptAES = Unpooled.buffer(1024); - int encryptLength = Crypto.AES.encrypt(aesEngine1, aesIVAndKey, source, encryptAES, length, logger); + int encryptLength = CryptoAES.encrypt(aesEngine1, aesIVAndKey, source, encryptAES, length, logger); byte[] encrypt = new byte[encryptLength]; System.arraycopy(encryptAES.array(), 0, encrypt, 0, encryptLength); - byte[] decrypt = Crypto.AES.decrypt(aesEngine2, key, iv, encrypt, logger); + byte[] decrypt = CryptoAES.decrypt(aesEngine2, key, iv, encrypt, logger); if (Arrays.equals(bytes, encrypt)) { @@ -177,16 +177,16 @@ public class AesByteBufTest { rand.nextBytes(key); // 256bit key (32 bytes) rand.nextBytes(iv); // 128bit block size (16 bytes) - final byte[] encrypt = Crypto.AES.encrypt(aesEngine1, key, iv, SOURCE, logger); + final byte[] encrypt = CryptoAES.encrypt(aesEngine1, key, iv, SOURCE, logger); final ByteBuf encryptAES = Unpooled.wrappedBuffer(encrypt); final int length = encrypt.length; - byte[] decrypt1 = Crypto.AES.decrypt(aesEngine1, key, iv, encrypt, logger); + byte[] decrypt1 = CryptoAES.decrypt(aesEngine1, key, iv, encrypt, logger); ParametersWithIV aesIVAndKey = new ParametersWithIV(new KeyParameter(key), iv); ByteBuf decryptAES = Unpooled.buffer(1024); - int decryptLength = Crypto.AES.decrypt(aesEngine2, aesIVAndKey, encryptAES, decryptAES, length, logger); + int decryptLength = CryptoAES.decrypt(aesEngine2, aesIVAndKey, encryptAES, decryptAES, length, logger); byte[] decrypt2 = new byte[decryptLength]; System.arraycopy(decryptAES.array(), 0, decrypt2, 0, decryptLength); @@ -221,17 +221,17 @@ public class AesByteBufTest { rand.nextBytes(key); // 256bit key (32 bytes) rand.nextBytes(iv); // 128bit block size (16 bytes) - final byte[] encrypt = Crypto.AES.encrypt(aesEngine1, key, iv, SOURCE, logger); + final byte[] encrypt = CryptoAES.encrypt(aesEngine1, key, iv, SOURCE, logger); final ByteBuf encryptAES = Unpooled.wrappedBuffer(encrypt); final int length = encrypt.length; - byte[] decrypt1 = Crypto.AES.decrypt(aesEngine1, key, iv, encrypt, logger); + byte[] decrypt1 = CryptoAES.decrypt(aesEngine1, key, iv, encrypt, logger); ParametersWithIV aesIVAndKey = new ParametersWithIV(new KeyParameter(key), iv); ByteBuf decryptAES = Unpooled.buffer(1024); - int decryptLength = Crypto.AES.decrypt(aesEngine2, aesIVAndKey, encryptAES, decryptAES, length, logger); + int decryptLength = CryptoAES.decrypt(aesEngine2, aesIVAndKey, encryptAES, decryptAES, length, logger); byte[] decrypt2 = new byte[decryptLength]; System.arraycopy(decryptAES.array(), 0, decrypt2, 0, decryptLength); @@ -266,14 +266,14 @@ public class AesByteBufTest { rand.nextBytes(iv); // 128bit block size (16 bytes) - byte[] encrypt = Crypto.AES.encrypt(aesEngine1, key, iv, SOURCE, logger); + byte[] encrypt = CryptoAES.encrypt(aesEngine1, key, iv, SOURCE, logger); ByteBuf encryptAES = Unpooled.wrappedBuffer(encrypt); int length = encrypt.length; ParametersWithIV aesIVAndKey = new ParametersWithIV(new KeyParameter(key), iv); ByteBuf decryptAES = Unpooled.buffer(1024); - int decryptLength = Crypto.AES.decrypt(aesEngine2, aesIVAndKey, encryptAES, decryptAES, length, logger); + int decryptLength = CryptoAES.decrypt(aesEngine2, aesIVAndKey, encryptAES, decryptAES, length, logger); byte[] decrypt = new byte[decryptLength]; System.arraycopy(decryptAES.array(), 0, decrypt, 0, decryptLength); @@ -303,14 +303,14 @@ public class AesByteBufTest { rand.nextBytes(iv); // 128bit block size (16 bytes) - byte[] encrypt = Crypto.AES.encrypt(aesEngine1, key, iv, SOURCE, logger); + byte[] encrypt = CryptoAES.encrypt(aesEngine1, key, iv, SOURCE, logger); ByteBuf encryptAES = Unpooled.wrappedBuffer(encrypt); int length = encrypt.length; ParametersWithIV aesIVAndKey = new ParametersWithIV(new KeyParameter(key), iv); ByteBuf decryptAES = Unpooled.buffer(1024); - int decryptLength = Crypto.AES.decrypt(aesEngine2, aesIVAndKey, encryptAES, decryptAES, length, logger); + int decryptLength = CryptoAES.decrypt(aesEngine2, aesIVAndKey, encryptAES, decryptAES, length, logger); byte[] decrypt = new byte[decryptLength]; System.arraycopy(decryptAES.array(), 0, decrypt, 0, decryptLength); diff --git a/Dorkbox-Util/test/dorkbox/util/crypto/AesTest.java b/Dorkbox-Util/test/dorkbox/util/crypto/AesTest.java index 8fbb533..0eff2a9 100644 --- a/Dorkbox-Util/test/dorkbox/util/crypto/AesTest.java +++ b/Dorkbox-Util/test/dorkbox/util/crypto/AesTest.java @@ -37,8 +37,8 @@ public class AesTest { rand.nextBytes(iv); // 128bit block size (16 bytes) - byte[] encryptAES = Crypto.AES.encrypt(aesEngine, key, iv, bytes, logger); - byte[] decryptAES = Crypto.AES.decrypt(aesEngine, key, iv, encryptAES, logger); + byte[] encryptAES = CryptoAES.encrypt(aesEngine, key, iv, bytes, logger); + byte[] decryptAES = CryptoAES.decrypt(aesEngine, key, iv, encryptAES, logger); if (Arrays.equals(bytes, encryptAES)) { fail("bytes should not be equal"); @@ -67,8 +67,8 @@ public class AesTest { rand.nextBytes(iv); // 16bit block size - byte[] encryptAES = Crypto.AES.encrypt(aesEngine, key, iv, bytes, logger); - byte[] decryptAES = Crypto.AES.decrypt(aesEngine, key, iv, encryptAES, logger); + byte[] encryptAES = CryptoAES.encrypt(aesEngine, key, iv, bytes, logger); + byte[] decryptAES = CryptoAES.decrypt(aesEngine, key, iv, encryptAES, logger); if (Arrays.equals(bytes, encryptAES)) { fail("bytes should not be equal"); @@ -97,7 +97,7 @@ public class AesTest { rand.nextBytes(iv); // 128bit block size - boolean success = Crypto.AES.encryptStream(aesEngine, key, iv, inputStream, outputStream, logger); + boolean success = CryptoAES.encryptStream(aesEngine, key, iv, inputStream, outputStream, logger); if (!success) { fail("crypto was not successful"); @@ -108,7 +108,7 @@ public class AesTest { inputStream = new ByteArrayInputStream(outputStream.toByteArray()); outputStream = new ByteArrayOutputStream(); - success = Crypto.AES.decryptStream(aesEngine, key, iv, inputStream, outputStream, logger); + success = CryptoAES.decryptStream(aesEngine, key, iv, inputStream, outputStream, logger); if (!success) { fail("crypto was not successful"); @@ -145,7 +145,7 @@ public class AesTest { rand.nextBytes(iv); // 128bit block size - boolean success = Crypto.AES.encryptStream(aesEngine, key, iv, inputStream, outputStream, logger); + boolean success = CryptoAES.encryptStream(aesEngine, key, iv, inputStream, outputStream, logger); if (!success) { fail("crypto was not successful"); @@ -156,7 +156,7 @@ public class AesTest { inputStream = new ByteArrayInputStream(outputStream.toByteArray()); outputStream = new ByteArrayOutputStream(); - success = Crypto.AES.decryptStream(aesEngine, key, iv, inputStream, outputStream, logger); + success = CryptoAES.decryptStream(aesEngine, key, iv, inputStream, outputStream, logger); if (!success) { @@ -190,8 +190,8 @@ public class AesTest { rand.nextBytes(iv); - byte[] encryptAES = Crypto.AES.encryptWithIV(aesEngine, key, iv, bytes, logger); - byte[] decryptAES = Crypto.AES.decryptWithIV(aesEngine, key, encryptAES, logger); + byte[] encryptAES = CryptoAES.encryptWithIV(aesEngine, key, iv, bytes, logger); + byte[] decryptAES = CryptoAES.decryptWithIV(aesEngine, key, encryptAES, logger); if (Arrays.equals(bytes, encryptAES)) { fail("bytes should not be equal"); @@ -220,8 +220,8 @@ public class AesTest { rand.nextBytes(iv); - byte[] encryptAES = Crypto.AES.encryptWithIV(aesEngine, key, iv, bytes, logger); - byte[] decryptAES = Crypto.AES.decryptWithIV(aesEngine, key, encryptAES, logger); + byte[] encryptAES = CryptoAES.encryptWithIV(aesEngine, key, iv, bytes, logger); + byte[] decryptAES = CryptoAES.decryptWithIV(aesEngine, key, encryptAES, logger); if (Arrays.equals(bytes, encryptAES)) { fail("bytes should not be equal"); @@ -250,7 +250,7 @@ public class AesTest { rand.nextBytes(iv); // 128bit block size - boolean success = Crypto.AES.encryptStreamWithIV(aesEngine, key, iv, inputStream, outputStream, logger); + boolean success = CryptoAES.encryptStreamWithIV(aesEngine, key, iv, inputStream, outputStream, logger); if (!success) { fail("crypto was not successful"); @@ -261,7 +261,7 @@ public class AesTest { inputStream = new ByteArrayInputStream(outputStream.toByteArray()); outputStream = new ByteArrayOutputStream(); - success = Crypto.AES.decryptStreamWithIV(aesEngine, key, inputStream, outputStream, logger); + success = CryptoAES.decryptStreamWithIV(aesEngine, key, inputStream, outputStream, logger); if (!success) { fail("crypto was not successful"); @@ -298,7 +298,7 @@ public class AesTest { rand.nextBytes(iv); // 128bit block size - boolean success = Crypto.AES.encryptStreamWithIV(aesEngine, key, iv, inputStream, outputStream, logger); + boolean success = CryptoAES.encryptStreamWithIV(aesEngine, key, iv, inputStream, outputStream, logger); if (!success) { fail("crypto was not successful"); @@ -309,7 +309,7 @@ public class AesTest { inputStream = new ByteArrayInputStream(outputStream.toByteArray()); outputStream = new ByteArrayOutputStream(); - success = Crypto.AES.decryptStreamWithIV(aesEngine, key, inputStream, outputStream, logger); + success = CryptoAES.decryptStreamWithIV(aesEngine, key, inputStream, outputStream, logger); if (!success) { diff --git a/Dorkbox-Util/test/dorkbox/util/crypto/DsaTest.java b/Dorkbox-Util/test/dorkbox/util/crypto/DsaTest.java index 67e804d..ea62e3c 100644 --- a/Dorkbox-Util/test/dorkbox/util/crypto/DsaTest.java +++ b/Dorkbox-Util/test/dorkbox/util/crypto/DsaTest.java @@ -34,14 +34,14 @@ public class DsaTest { public void Dsa() { byte[] bytes = "hello, my name is inigo montoya".getBytes(); - AsymmetricCipherKeyPair generateKeyPair = Crypto.DSA.generateKeyPair(new SecureRandom(entropySeed.getBytes()), 1024); + AsymmetricCipherKeyPair generateKeyPair = CryptoDSA.generateKeyPair(new SecureRandom(entropySeed.getBytes()), 1024); DSAPrivateKeyParameters privateKey = (DSAPrivateKeyParameters) generateKeyPair.getPrivate(); DSAPublicKeyParameters publicKey = (DSAPublicKeyParameters) generateKeyPair.getPublic(); - BigInteger[] signature = Crypto.DSA.generateSignature(privateKey, new SecureRandom(entropySeed.getBytes()), bytes); + BigInteger[] signature = CryptoDSA.generateSignature(privateKey, new SecureRandom(entropySeed.getBytes()), bytes); - boolean verify1 = Crypto.DSA.verifySignature(publicKey, bytes, signature); + boolean verify1 = CryptoDSA.verifySignature(publicKey, bytes, signature); if (!verify1) { fail("failed signature verification"); @@ -56,7 +56,7 @@ public class DsaTest { - boolean verify2 = Crypto.DSA.verifySignature(publicKey, bytes2, signature); + boolean verify2 = CryptoDSA.verifySignature(publicKey, bytes2, signature); if (verify2) { fail("failed signature verification with bad message"); @@ -66,7 +66,7 @@ public class DsaTest { @Test public void DsaJceSerializaion() throws IOException { - AsymmetricCipherKeyPair generateKeyPair = Crypto.DSA.generateKeyPair(new SecureRandom(entropySeed.getBytes()), 1024); + AsymmetricCipherKeyPair generateKeyPair = CryptoDSA.generateKeyPair(new SecureRandom(entropySeed.getBytes()), 1024); DSAPrivateKeyParameters privateKey = (DSAPrivateKeyParameters) generateKeyPair.getPrivate(); DSAPublicKeyParameters publicKey = (DSAPublicKeyParameters) generateKeyPair.getPublic(); @@ -99,16 +99,16 @@ public class DsaTest { byte[] bytes = "hello, my name is inigo montoya".getBytes(); - BigInteger[] signature = Crypto.DSA.generateSignature(privateKey, new SecureRandom(entropySeed.getBytes()), bytes); + BigInteger[] signature = CryptoDSA.generateSignature(privateKey, new SecureRandom(entropySeed.getBytes()), bytes); - boolean verify1 = Crypto.DSA.verifySignature(publicKey, bytes, signature); + boolean verify1 = CryptoDSA.verifySignature(publicKey, bytes, signature); if (!verify1) { fail("failed signature verification"); } - boolean verify2 = Crypto.DSA.verifySignature(publicKey2, bytes, signature); + boolean verify2 = CryptoDSA.verifySignature(publicKey2, bytes, signature); if (!verify2) { fail("failed signature verification"); @@ -117,16 +117,16 @@ public class DsaTest { // now reverse who signs what. - BigInteger[] signatureB = Crypto.DSA.generateSignature(privateKey2, new SecureRandom(entropySeed.getBytes()), bytes); + BigInteger[] signatureB = CryptoDSA.generateSignature(privateKey2, new SecureRandom(entropySeed.getBytes()), bytes); - boolean verifyB1 = Crypto.DSA.verifySignature(publicKey, bytes, signatureB); + boolean verifyB1 = CryptoDSA.verifySignature(publicKey, bytes, signatureB); if (!verifyB1) { fail("failed signature verification"); } - boolean verifyB2 = Crypto.DSA.verifySignature(publicKey2, bytes, signatureB); + boolean verifyB2 = CryptoDSA.verifySignature(publicKey2, bytes, signatureB); if (!verifyB2) { fail("failed signature verification"); diff --git a/Dorkbox-Util/test/dorkbox/util/crypto/EccTest.java b/Dorkbox-Util/test/dorkbox/util/crypto/EccTest.java index c7475d5..67164da 100644 --- a/Dorkbox-Util/test/dorkbox/util/crypto/EccTest.java +++ b/Dorkbox-Util/test/dorkbox/util/crypto/EccTest.java @@ -47,13 +47,13 @@ public class EccTest { public void EccStreamMode() throws IOException { SecureRandom secureRandom = new SecureRandom(); - AsymmetricCipherKeyPair key1 = Crypto.ECC.generateKeyPair(Crypto.ECC.p521_curve, secureRandom); - AsymmetricCipherKeyPair key2 = Crypto.ECC.generateKeyPair(Crypto.ECC.p521_curve, secureRandom); + AsymmetricCipherKeyPair key1 = CryptoECC.generateKeyPair(CryptoECC.p521_curve, secureRandom); + AsymmetricCipherKeyPair key2 = CryptoECC.generateKeyPair(CryptoECC.p521_curve, secureRandom); - IESParameters cipherParams = Crypto.ECC.generateSharedParameters(secureRandom); + IESParameters cipherParams = CryptoECC.generateSharedParameters(secureRandom); - IESEngine encrypt = Crypto.ECC.createEngine(); - IESEngine decrypt = Crypto.ECC.createEngine(); + IESEngine encrypt = CryptoECC.createEngine(); + IESEngine decrypt = CryptoECC.createEngine(); // note: we want an ecc key that is AT LEAST 512 bits! (which is equal to AES 256) @@ -69,8 +69,8 @@ public class EccTest { // test stream mode - byte[] encrypted = Crypto.ECC.encrypt(encrypt, private1, public2, cipherParams, message, logger); - byte[] plaintext = Crypto.ECC.decrypt(decrypt, private2, public1, cipherParams, encrypted, logger); + byte[] encrypted = CryptoECC.encrypt(encrypt, private1, public2, cipherParams, message, logger); + byte[] plaintext = CryptoECC.decrypt(decrypt, private2, public1, cipherParams, encrypted, logger); if (Arrays.equals(encrypted, message)) { fail("stream cipher test failed"); @@ -86,18 +86,18 @@ public class EccTest { // test AES encrypt mode SecureRandom secureRandom = new SecureRandom(); - AsymmetricCipherKeyPair key1 = Crypto.ECC.generateKeyPair(Crypto.ECC.p521_curve, secureRandom); - AsymmetricCipherKeyPair key2 = Crypto.ECC.generateKeyPair(Crypto.ECC.p521_curve, secureRandom); + AsymmetricCipherKeyPair key1 = CryptoECC.generateKeyPair(CryptoECC.p521_curve, secureRandom); + AsymmetricCipherKeyPair key2 = CryptoECC.generateKeyPair(CryptoECC.p521_curve, secureRandom); PaddedBufferedBlockCipher aesEngine1 = new PaddedBufferedBlockCipher(new CBCBlockCipher(new AESFastEngine())); PaddedBufferedBlockCipher aesEngine2 = new PaddedBufferedBlockCipher(new CBCBlockCipher(new AESFastEngine())); - IESWithCipherParameters cipherParams = Crypto.ECC.generateSharedParametersWithCipher(secureRandom); + IESWithCipherParameters cipherParams = CryptoECC.generateSharedParametersWithCipher(secureRandom); - IESEngine encrypt = Crypto.ECC.createEngine(aesEngine1); - IESEngine decrypt = Crypto.ECC.createEngine(aesEngine2); + IESEngine encrypt = CryptoECC.createEngine(aesEngine1); + IESEngine decrypt = CryptoECC.createEngine(aesEngine2); // note: we want an ecc key that is AT LEAST 512 bits! (which is equal to AES 256) @@ -111,8 +111,8 @@ public class EccTest { byte[] message = Hex.decode("123456784358754934597967249867359283792374987692348750276509765091834790abcdef123456784358754934597967249867359283792374987692348750276509765091834790abcdef123456784358754934597967249867359283792374987692348750276509765091834790abcdef"); // test stream mode - byte[] encrypted = Crypto.ECC.encrypt(encrypt, private1, public2, cipherParams, message, logger); - byte[] plaintext = Crypto.ECC.decrypt(decrypt, private2, public1, cipherParams, encrypted, logger); + byte[] encrypted = CryptoECC.encrypt(encrypt, private1, public2, cipherParams, message, logger); + byte[] plaintext = CryptoECC.decrypt(decrypt, private2, public1, cipherParams, encrypted, logger); if (Arrays.equals(encrypted, message)) { fail("stream cipher test failed"); @@ -128,8 +128,8 @@ public class EccTest { // test DH key exchange SecureRandom secureRandom = new SecureRandom(); - AsymmetricCipherKeyPair key1 = Crypto.ECC.generateKeyPair(Crypto.ECC.p521_curve, secureRandom); - AsymmetricCipherKeyPair key2 = Crypto.ECC.generateKeyPair(Crypto.ECC.p521_curve, secureRandom); + AsymmetricCipherKeyPair key1 = CryptoECC.generateKeyPair(CryptoECC.p521_curve, secureRandom); + AsymmetricCipherKeyPair key2 = CryptoECC.generateKeyPair(CryptoECC.p521_curve, secureRandom); BasicAgreement e1 = new ECDHCBasicAgreement(); BasicAgreement e2 = new ECDHCBasicAgreement(); @@ -149,7 +149,7 @@ public class EccTest { public void EccDsa() throws IOException { SecureRandom secureRandom = new SecureRandom(); - AsymmetricCipherKeyPair key1 = Crypto.ECC.generateKeyPair(Crypto.ECC.p521_curve, secureRandom); + AsymmetricCipherKeyPair key1 = CryptoECC.generateKeyPair(CryptoECC.p521_curve, secureRandom); ParametersWithRandom param = new ParametersWithRandom(key1.getPrivate(), new SecureRandom()); @@ -172,10 +172,10 @@ public class EccTest { public void EccSerialization() { SecureRandom secureRandom = new SecureRandom(); - AsymmetricCipherKeyPair key1 = Crypto.ECC.generateKeyPair(Crypto.ECC.p521_curve, secureRandom); + AsymmetricCipherKeyPair key1 = CryptoECC.generateKeyPair(CryptoECC.p521_curve, secureRandom); - IESParameters cipherAParams = Crypto.ECC.generateSharedParameters(secureRandom); - IESWithCipherParameters cipherBParams = Crypto.ECC.generateSharedParametersWithCipher(secureRandom); + IESParameters cipherAParams = CryptoECC.generateSharedParameters(secureRandom); + IESWithCipherParameters cipherBParams = CryptoECC.generateSharedParametersWithCipher(secureRandom); // note: we want an ecc key that is AT LEAST 512 bits! (which is equal to AES 256) @@ -203,7 +203,7 @@ public class EccTest { IESParameters cipherAParams2 = (IESParameters) kryo.readClassAndObject(input); - if (!Crypto.ECC.compare(cipherAParams, cipherAParams2)) { + if (!CryptoECC.compare(cipherAParams, cipherAParams2)) { fail("cipher parameters not equal"); } @@ -217,7 +217,7 @@ public class EccTest { input = new Input(new ByteArrayInputStream(outStream.toByteArray()), 4096); IESWithCipherParameters cipherBParams2 = (IESWithCipherParameters) kryo.readClassAndObject(input); - if (!Crypto.ECC.compare(cipherBParams, cipherBParams2)) { + if (!CryptoECC.compare(cipherBParams, cipherBParams2)) { fail("cipher parameters not equal"); } @@ -232,7 +232,7 @@ public class EccTest { input = new Input(new ByteArrayInputStream(outStream.toByteArray()), 4096); ECPrivateKeyParameters private2 = (ECPrivateKeyParameters) kryo.readClassAndObject(input); - if (!Crypto.ECC.compare(private1, private2)) { + if (!CryptoECC.compare(private1, private2)) { fail("private keys not equal"); } @@ -247,7 +247,7 @@ public class EccTest { input = new Input(new ByteArrayInputStream(outStream.toByteArray()), 4096); ECPublicKeyParameters public2 = (ECPublicKeyParameters) kryo.readClassAndObject(input); - if (!Crypto.ECC.compare(public1, public2)) { + if (!CryptoECC.compare(public1, public2)) { fail("public keys not equal"); } } @@ -255,7 +255,7 @@ public class EccTest { @Test public void EccJceSerialization() throws IOException { - AsymmetricCipherKeyPair generateKeyPair = Crypto.ECC.generateKeyPair(Crypto.ECC.p521_curve, new SecureRandom()); + AsymmetricCipherKeyPair generateKeyPair = CryptoECC.generateKeyPair(CryptoECC.p521_curve, new SecureRandom()); ECPrivateKeyParameters privateKey = (ECPrivateKeyParameters) generateKeyPair.getPrivate(); ECPublicKeyParameters publicKey = (ECPublicKeyParameters) generateKeyPair.getPublic(); @@ -280,15 +280,15 @@ public class EccTest { byte[] bytes = "hello, my name is inigo montoya".getBytes(); - BigInteger[] signature = Crypto.ECC.generateSignature("SHA384", privateKey, new SecureRandom(entropySeed.getBytes()), bytes); + BigInteger[] signature = CryptoECC.generateSignature("SHA384", privateKey, new SecureRandom(entropySeed.getBytes()), bytes); - boolean verify1 = Crypto.ECC.verifySignature("SHA384", publicKey, bytes, signature); + boolean verify1 = CryptoECC.verifySignature("SHA384", publicKey, bytes, signature); if (!verify1) { fail("failed signature verification"); } - boolean verify2 = Crypto.ECC.verifySignature("SHA384", publicKey2, bytes, signature); + boolean verify2 = CryptoECC.verifySignature("SHA384", publicKey2, bytes, signature); if (!verify2) { fail("failed signature verification"); @@ -297,15 +297,15 @@ public class EccTest { // now reverse who signs what. - BigInteger[] signatureB = Crypto.ECC.generateSignature("SHA384", privateKey2, new SecureRandom(entropySeed.getBytes()), bytes); + BigInteger[] signatureB = CryptoECC.generateSignature("SHA384", privateKey2, new SecureRandom(entropySeed.getBytes()), bytes); - boolean verifyB1 = Crypto.ECC.verifySignature("SHA384", publicKey, bytes, signatureB); + boolean verifyB1 = CryptoECC.verifySignature("SHA384", publicKey, bytes, signatureB); if (!verifyB1) { fail("failed signature verification"); } - boolean verifyB2 = Crypto.ECC.verifySignature("SHA384", publicKey2, bytes, signatureB); + boolean verifyB2 = CryptoECC.verifySignature("SHA384", publicKey2, bytes, signatureB); if (!verifyB2) { fail("failed signature verification"); diff --git a/Dorkbox-Util/test/dorkbox/util/crypto/RsaTest.java b/Dorkbox-Util/test/dorkbox/util/crypto/RsaTest.java index d477c94..884febd 100644 --- a/Dorkbox-Util/test/dorkbox/util/crypto/RsaTest.java +++ b/Dorkbox-Util/test/dorkbox/util/crypto/RsaTest.java @@ -37,7 +37,7 @@ public class RsaTest { public void Rsa() { byte[] bytes = "hello, my name is inigo montoya".getBytes(); - AsymmetricCipherKeyPair key = Crypto.RSA.generateKeyPair(new SecureRandom(entropySeed.getBytes()), 1024); + AsymmetricCipherKeyPair key = CryptoRSA.generateKeyPair(new SecureRandom(entropySeed.getBytes()), 1024); RSAKeyParameters public1 = (RSAKeyParameters) key.getPublic(); RSAPrivateCrtKeyParameters private1 = (RSAPrivateCrtKeyParameters) key.getPrivate(); @@ -48,8 +48,8 @@ public class RsaTest { OAEPEncoding rsaEngine = new OAEPEncoding(engine, digest); // test encrypt/decrypt - byte[] encryptRSA = Crypto.RSA.encrypt(rsaEngine, public1, bytes, logger); - byte[] decryptRSA = Crypto.RSA.decrypt(rsaEngine, private1, encryptRSA, logger); + byte[] encryptRSA = CryptoRSA.encrypt(rsaEngine, public1, bytes, logger); + byte[] decryptRSA = CryptoRSA.decrypt(rsaEngine, private1, encryptRSA, logger); if (Arrays.equals(bytes, encryptRSA)) { fail("bytes should not be equal"); @@ -62,8 +62,8 @@ public class RsaTest { // test signing/verification PSSSigner signer = new PSSSigner(engine, digest, digest.getDigestSize()); - byte[] signatureRSA = Crypto.RSA.sign(signer, private1, bytes, logger); - boolean verify = Crypto.RSA.verify(signer, public1, signatureRSA, bytes); + byte[] signatureRSA = CryptoRSA.sign(signer, private1, bytes, logger); + boolean verify = CryptoRSA.verify(signer, public1, signatureRSA, bytes); if (!verify) { fail("failed signature verification"); @@ -103,7 +103,7 @@ public class RsaTest { RSAKeyParameters public2 = (RSAKeyParameters) kryo.readClassAndObject(input); - if (!Crypto.RSA.compare(public1, public2)) { + if (!CryptoRSA.compare(public1, public2)) { fail("public keys not equal"); } @@ -119,7 +119,7 @@ public class RsaTest { RSAPrivateCrtKeyParameters private2 = (RSAPrivateCrtKeyParameters) kryo.readClassAndObject(input); - if (!Crypto.RSA.compare(private1, private2)) { + if (!CryptoRSA.compare(private1, private2)) { fail("private keys not equal"); } } diff --git a/Dorkbox-Util/test/dorkbox/util/crypto/SCryptTest.java b/Dorkbox-Util/test/dorkbox/util/crypto/SCryptTest.java index 4bbe8e7..ade2527 100644 --- a/Dorkbox-Util/test/dorkbox/util/crypto/SCryptTest.java +++ b/Dorkbox-Util/test/dorkbox/util/crypto/SCryptTest.java @@ -32,7 +32,7 @@ public class SCryptTest { dkLen = 64; DK = "FDBABE1C9D3472007856E7190D01E9FE7C6AD7CBC8237830E77376634B3731622EAF30D92E22A3886FF109279D9830DAC727AFB94A83EE6D8360CBDFA2CC0640"; - assertEquals(DK, Sys.bytesToHex(Crypto.SCrypt.encrypt(P, S, N, r, p, dkLen))); + assertEquals(DK, Sys.bytesToHex(CryptoSCrypt.encrypt(P, S, N, r, p, dkLen))); P = "pleaseletmein".getBytes("UTF-8"); @@ -43,7 +43,7 @@ public class SCryptTest { dkLen = 64; DK = "7023BDCB3AFD7348461C06CD81FD38EBFDA8FBBA904F8E3EA9B543F6545DA1F2D5432955613F0FCF62D49705242A9AF9E61E85DC0D651E40DFCF017B45575887"; - assertEquals(DK, Sys.bytesToHex(Crypto.SCrypt.encrypt(P, S, N, r, p, dkLen))); + assertEquals(DK, Sys.bytesToHex(CryptoSCrypt.encrypt(P, S, N, r, p, dkLen))); P = "pleaseletmein".getBytes("UTF-8"); @@ -54,6 +54,6 @@ public class SCryptTest { dkLen = 64; DK = "2101CB9B6A511AAEADDBBE09CF70F881EC568D574A2FFD4DABE5EE9820ADAA478E56FD8F4BA5D09FFA1C6D927C40F4C337304049E8A952FBCBF45C6FA77A41A4"; - assertEquals(DK, Sys.bytesToHex(Crypto.SCrypt.encrypt(P, S, N, r, p, dkLen))); + assertEquals(DK, Sys.bytesToHex(CryptoSCrypt.encrypt(P, S, N, r, p, dkLen))); } } diff --git a/Dorkbox-Util/test/dorkbox/util/crypto/x509Test.java b/Dorkbox-Util/test/dorkbox/util/crypto/x509Test.java index f7751f5..d213f2d 100644 --- a/Dorkbox-Util/test/dorkbox/util/crypto/x509Test.java +++ b/Dorkbox-Util/test/dorkbox/util/crypto/x509Test.java @@ -35,7 +35,7 @@ public class x509Test { BigInteger serialNumber = BigInteger.valueOf(System.currentTimeMillis()); // serial number for certificate - AsymmetricCipherKeyPair generateKeyPair = Crypto.ECC.generateKeyPair(Crypto.ECC.p521_curve, new SecureRandom()); // key name from Crypto class + AsymmetricCipherKeyPair generateKeyPair = CryptoECC.generateKeyPair(CryptoECC.p521_curve, new SecureRandom()); // key name from Crypto class ECPrivateKeyParameters privateKey = (ECPrivateKeyParameters) generateKeyPair.getPrivate(); ECPublicKeyParameters publicKey = (ECPublicKeyParameters) generateKeyPair.getPublic(); @@ -79,7 +79,7 @@ public class x509Test { @SuppressWarnings("deprecation") - AsymmetricCipherKeyPair generateKeyPair = Crypto.DSA.generateKeyPair(new SecureRandom(entropySeed.getBytes()), 1024); + AsymmetricCipherKeyPair generateKeyPair = CryptoDSA.generateKeyPair(new SecureRandom(entropySeed.getBytes()), 1024); DSAPrivateKeyParameters privateKey = (DSAPrivateKeyParameters) generateKeyPair.getPrivate(); @@ -123,7 +123,7 @@ public class x509Test { BigInteger serialNumber = BigInteger.valueOf(System.currentTimeMillis()); // serial number for certificate @SuppressWarnings("deprecation") - AsymmetricCipherKeyPair generateKeyPair = Crypto.RSA.generateKeyPair(new SecureRandom(entropySeed.getBytes()), 1024); + AsymmetricCipherKeyPair generateKeyPair = CryptoRSA.generateKeyPair(new SecureRandom(entropySeed.getBytes()), 1024); RSAPrivateCrtKeyParameters privateKey = (RSAPrivateCrtKeyParameters) generateKeyPair.getPrivate(); RSAKeyParameters publicKey = (RSAKeyParameters) generateKeyPair.getPublic();