dorkbox/Utilities
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Updated dependencies for bouncycastle

Browse Source
This commit is contained in:
nathan 2015-11-15 20:29:12 +01:00
parent 1d3a9ff71b
commit f98fce7012
7 changed files with 87 additions and 87 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
Dorkbox-Util/test/dorkbox/util/crypto/AesByteBufTest.java
View File

@ -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);

32
Dorkbox-Util/test/dorkbox/util/crypto/AesTest.java
View File

@ -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) {

22
Dorkbox-Util/test/dorkbox/util/crypto/DsaTest.java
View File

@ -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");

62
Dorkbox-Util/test/dorkbox/util/crypto/EccTest.java
View File

@ -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");

14
Dorkbox-Util/test/dorkbox/util/crypto/RsaTest.java
View File

@ -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");
}
}

6
Dorkbox-Util/test/dorkbox/util/crypto/SCryptTest.java
View File

@ -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)));
}
}

6
Dorkbox-Util/test/dorkbox/util/crypto/x509Test.java
View File

@ -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();