diff --git a/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/ECDSASignatureFunction.java b/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/ECDSASignatureFunction.java index 11ef1217..c1cf9bdb 100644 --- a/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/ECDSASignatureFunction.java +++ b/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/ECDSASignatureFunction.java @@ -21,8 +21,8 @@ public class ECDSASignatureFunction implements SignatureFunction { } @Override - public byte[] retrievePubKeyBytes(byte[] privKeyBytes) { - return new byte[0]; + public PubKey retrievePubKey(PrivKey privKey) { + return null; } @Override diff --git a/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/ED25519SignatureFunction.java b/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/ED25519SignatureFunction.java index ed9200f5..3925e857 100644 --- a/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/ED25519SignatureFunction.java +++ b/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/ED25519SignatureFunction.java @@ -83,14 +83,23 @@ public class ED25519SignatureFunction implements SignatureFunction { } @Override - public byte[] retrievePubKeyBytes(byte[] privKeyBytes) { - - byte[] rawPrivKeyBytes = resolvePrivKey(privKeyBytes).getRawKeyBytes(); + public PubKey retrievePubKey(PrivKey privKey) { + byte[] rawPrivKeyBytes = privKey.getRawKeyBytes(); EdDSAParameterSpec spec = EdDSANamedCurveTable.getByName(EdDSANamedCurveTable.CURVE_ED25519_SHA512); EdDSAPrivateKeySpec privateKeySpec = new EdDSAPrivateKeySpec(rawPrivKeyBytes, spec); byte[] rawPubKeyBytes = privateKeySpec.getA().toByteArray(); - return new PubKey(ED25519, rawPubKeyBytes).toBytes(); + return new PubKey(ED25519, rawPubKeyBytes); } +// +// @Override +// public byte[] retrievePubKey(byte[] privKeyBytes) { +// +// byte[] rawPrivKeyBytes = resolvePrivKey(privKeyBytes).getRawKeyBytes(); +// EdDSAParameterSpec spec = EdDSANamedCurveTable.getByName(EdDSANamedCurveTable.CURVE_ED25519_SHA512); +// EdDSAPrivateKeySpec privateKeySpec = new EdDSAPrivateKeySpec(rawPrivKeyBytes, spec); +// byte[] rawPubKeyBytes = privateKeySpec.getA().toByteArray(); +// return new PubKey(ED25519, rawPubKeyBytes).toBytes(); +// } @Override public boolean supportPrivKey(byte[] privKeyBytes) { diff --git a/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/RSACryptoFunction.java b/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/RSACryptoFunction.java index d921a398..96472fa1 100644 --- a/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/RSACryptoFunction.java +++ b/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/RSACryptoFunction.java @@ -24,18 +24,18 @@ public class RSACryptoFunction implements AsymmetricEncryptionFunction, Signatur } @Override - public SignatureDigest sign(PrivKey privKey, byte[] data) { + public PubKey retrievePubKey(PrivKey privKey) { return null; } @Override - public boolean verify(SignatureDigest digest, PubKey pubKey, byte[] data) { - return false; + public SignatureDigest sign(PrivKey privKey, byte[] data) { + return null; } @Override - public byte[] retrievePubKeyBytes(byte[] privKeyBytes) { - return new byte[0]; + public boolean verify(SignatureDigest digest, PubKey pubKey, byte[] data) { + return false; } @Override diff --git a/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/asymmetric/AsymmtricCryptographyImplTest.java b/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/asymmetric/AsymmtricCryptographyImplTest.java index 57021aeb..fcfaf36f 100644 --- a/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/asymmetric/AsymmtricCryptographyImplTest.java +++ b/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/asymmetric/AsymmtricCryptographyImplTest.java @@ -698,7 +698,7 @@ // byte[] expectedPrivKeyBytes = keyPair.getPrivKey().toBytes(); // byte[] expectedPubKeyBytes = keyPair.getPubKey().toBytes(); // -// byte[] pubKeyBytes = asymmetricCrypto.retrievePubKeyBytes(expectedPrivKeyBytes); +// byte[] pubKeyBytes = asymmetricCrypto.retrievePubKey(expectedPrivKeyBytes); // // assertArrayEquals(expectedPubKeyBytes,pubKeyBytes); // @@ -711,7 +711,7 @@ // expectedPrivKeyBytes = keyPair.getPrivKey().toBytes(); // expectedPubKeyBytes = keyPair.getPubKey().toBytes(); // -// pubKeyBytes = asymmetricCrypto.retrievePubKeyBytes(expectedPrivKeyBytes); +// pubKeyBytes = asymmetricCrypto.retrievePubKey(expectedPrivKeyBytes); // // assertArrayEquals(expectedPubKeyBytes,pubKeyBytes); // @@ -724,7 +724,7 @@ // expectedPrivKeyBytes = keyPair.getPrivKey().toBytes(); // expectedPubKeyBytes = keyPair.getPubKey().toBytes(); // -// pubKeyBytes = asymmetricCrypto.retrievePubKeyBytes(expectedPrivKeyBytes); +// pubKeyBytes = asymmetricCrypto.retrievePubKey(expectedPrivKeyBytes); // // assertArrayEquals(expectedPubKeyBytes,pubKeyBytes); // diff --git a/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/AESEncryptionFunctionTest.java b/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/AESEncryptionFunctionTest.java index b841a50a..596f2c00 100644 --- a/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/AESEncryptionFunctionTest.java +++ b/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/AESEncryptionFunctionTest.java @@ -11,6 +11,8 @@ import java.io.InputStream; import java.io.OutputStream; import java.util.Random; +import static com.jd.blockchain.crypto.CryptoAlgorithm.ENCRYPTION_ALGORITHM; +import static com.jd.blockchain.crypto.CryptoAlgorithm.SYMMETRIC_KEY; import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC; import static org.junit.Assert.*; @@ -58,7 +60,7 @@ public class AESEncryptionFunctionTest { assertEquals(128 / 8, symmetricKey.getRawKeyBytes().length); assertEquals(algorithm.name(),symmetricKey.getAlgorithm().name()); - assertEquals(algorithm.toString(),symmetricKey.getAlgorithm().toString()); + assertEquals(algorithm.code(),symmetricKey.getAlgorithm().code()); assertEquals(2 + 1 + 128 / 8, symmetricKey.toBytes().length); byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); @@ -89,8 +91,8 @@ public class AESEncryptionFunctionTest { byte[] ciphertextBytes = ciphertext.toBytes(); assertEquals(2 + 16 + 1024 , ciphertextBytes.length); CryptoAlgorithm ciphertextAlgo = ciphertext.getAlgorithm(); - assertEquals(algorithm.name(),ciphertext.getAlgorithm().name()); - assertEquals(algorithm.toString(),ciphertext.getAlgorithm().toString()); + assertEquals("AES",ciphertextAlgo.name()); + assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 26 & 0x00FF)),ciphertextAlgo.code()); byte[] algoBytes = CryptoAlgorithm.toBytes(ciphertextAlgo); byte[] rawCiphertextBytes = ciphertext.getRawCiphertext(); @@ -150,6 +152,7 @@ public class AESEncryptionFunctionTest { @Test public void supportSymmetricKeyTest(){ + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); assertNotNull(algorithm); @@ -173,6 +176,7 @@ public class AESEncryptionFunctionTest { @Test public void resolveSymmetricKeyTest(){ + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); assertNotNull(algorithm); @@ -186,10 +190,9 @@ public class AESEncryptionFunctionTest { assertEquals(SYMMETRIC.CODE,resolvedKey.getKeyType().CODE); assertEquals(128 / 8, resolvedKey.getRawKeyBytes().length); - - assertEquals(algorithm.name(),resolvedKey.getAlgorithm().name()); - assertEquals(algorithm.toString(),resolvedKey.getAlgorithm().toString()); - + assertEquals("AES",resolvedKey.getAlgorithm().name()); + assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 26 & 0x00FF)),resolvedKey.getAlgorithm().code()); + assertArrayEquals(symmetricKeyBytes,resolvedKey.toBytes()); algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); assertNotNull(algorithm); @@ -257,18 +260,29 @@ public class AESEncryptionFunctionTest { Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey,data); byte[] ciphertextBytes = ciphertext.toBytes(); - assertTrue(symmetricEncryptionFunction.supportCiphertext(ciphertextBytes)); + + Ciphertext resolvedCiphertext = symmetricEncryptionFunction.resolveCiphertext(ciphertextBytes); + + assertEquals(1024 + 16 , resolvedCiphertext.getRawCiphertext().length); + assertEquals("AES",resolvedCiphertext.getAlgorithm().name()); + assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 26 & 0x00FF)),resolvedCiphertext.getAlgorithm().code()); + assertArrayEquals(ciphertextBytes,resolvedCiphertext.toBytes()); + + assertArrayEquals(ciphertext.toBytes(),resolvedCiphertext.toBytes()); + assertArrayEquals(ciphertext.getRawCiphertext(),resolvedCiphertext.getRawCiphertext()); + assertEquals(ciphertext.getAlgorithm().name(),resolvedCiphertext.getAlgorithm().name()); + assertEquals(ciphertext.getAlgorithm().code(),resolvedCiphertext.getAlgorithm().code()); algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); assertNotNull(algorithm); byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); - byte[] rawCiphertextBytes = ciphertext.toBytes(); + byte[] rawCiphertextBytes = ciphertext.getRawCiphertext(); byte[] ripemd160CiphertextBytes = BytesUtils.concat(algoBytes,rawCiphertextBytes); Class expectedException = CryptoException.class; Exception actualEx = null; try { - symmetricEncryptionFunction.resolveSymmetricKey(ripemd160CiphertextBytes); + symmetricEncryptionFunction.resolveCiphertext(ripemd160CiphertextBytes); } catch (Exception e) { actualEx = e; } diff --git a/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/ED25519SignatureFunctionTest.java b/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/ED25519SignatureFunctionTest.java index 723f2818..a675f5a1 100644 --- a/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/ED25519SignatureFunctionTest.java +++ b/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/ED25519SignatureFunctionTest.java @@ -1,9 +1,6 @@ package test.com.jd.blockchain.crypto.service.classic; -import com.jd.blockchain.crypto.CryptoAlgorithm; -import com.jd.blockchain.crypto.CryptoServiceProviders; -import com.jd.blockchain.crypto.PrivKey; -import com.jd.blockchain.crypto.PubKey; +import com.jd.blockchain.crypto.*; import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair; import com.jd.blockchain.crypto.asymmetric.SignatureDigest; import com.jd.blockchain.crypto.asymmetric.SignatureFunction; @@ -12,6 +9,8 @@ import org.junit.Test; import java.util.Random; +import static com.jd.blockchain.crypto.CryptoAlgorithm.ASYMMETRIC_KEY; +import static com.jd.blockchain.crypto.CryptoAlgorithm.SIGNATURE_ALGORITHM; import static com.jd.blockchain.crypto.CryptoKeyType.PRIVATE; import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; import static org.junit.Assert.*; @@ -23,6 +22,7 @@ import static org.junit.Assert.*; * @date 2019-04-01, 14:01 */ public class ED25519SignatureFunctionTest { + @Test public void getAlgorithmTest(){ @@ -53,7 +53,6 @@ public class ED25519SignatureFunctionTest { SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); - CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); PubKey pubKey = keyPair.getPubKey(); @@ -65,9 +64,9 @@ public class ED25519SignatureFunctionTest { assertEquals(32, privKey.getRawKeyBytes().length); assertEquals(algorithm.name(),pubKey.getAlgorithm().name()); - assertEquals(algorithm.toString(),pubKey.getAlgorithm().toString()); + assertEquals(algorithm.code(),pubKey.getAlgorithm().code()); assertEquals(algorithm.name(),privKey.getAlgorithm().name()); - assertEquals(algorithm.toString(),privKey.getAlgorithm().toString()); + assertEquals(algorithm.code(),privKey.getAlgorithm().code()); assertEquals(2 + 1 + 32, pubKey.toBytes().length); assertEquals(2 + 1 + 32, privKey.toBytes().length); @@ -79,12 +78,29 @@ public class ED25519SignatureFunctionTest { byte[] rawPrivKeyBytes = privKey.getRawKeyBytes(); assertArrayEquals(BytesUtils.concat(algoBytes,pubKeyTypeBytes,rawPubKeyBytes),pubKey.toBytes()); assertArrayEquals(BytesUtils.concat(algoBytes,privKeyTypeBytes,rawPrivKeyBytes),privKey.toBytes()); + } + @Test + public void retrievePubKeyTest(){ + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("ed25519"); + assertNotNull(algorithm); - } + SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PubKey pubKey = keyPair.getPubKey(); + PrivKey privKey = keyPair.getPrivKey(); + PubKey retrievedPubKey = signatureFunction.retrievePubKey(privKey); + + assertEquals(pubKey.getKeyType(),retrievedPubKey.getKeyType()); + assertEquals(pubKey.getRawKeyBytes().length, retrievedPubKey.getRawKeyBytes().length); + assertEquals(pubKey.getAlgorithm().name(),retrievedPubKey.getAlgorithm().name()); + assertEquals(pubKey.getAlgorithm().code(),retrievedPubKey.getAlgorithm().code()); + assertArrayEquals(pubKey.toBytes(),retrievedPubKey.toBytes()); + } @Test public void signTest(){ @@ -107,8 +123,9 @@ public class ED25519SignatureFunctionTest { assertEquals(2 + 64, signatureBytes.length); CryptoAlgorithm signatureAlgo = signatureDigest.getAlgorithm(); - assertEquals(algorithm.name(),signatureDigest.getAlgorithm().name()); - assertEquals(algorithm.toString(),signatureDigest.getAlgorithm().toString()); + assertEquals("ED25519",signatureAlgo.name()); + assertEquals((short) (SIGNATURE_ALGORITHM | ASYMMETRIC_KEY | ((byte) 21 & 0x00FF)), + signatureAlgo.code()); byte[] algoBytes = CryptoAlgorithm.toBytes(signatureAlgo); byte[] rawSinatureBytes = signatureDigest.getRawDigest(); @@ -144,7 +161,6 @@ public class ED25519SignatureFunctionTest { SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); - CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); PrivKey privKey = keyPair.getPrivKey(); @@ -162,108 +178,186 @@ public class ED25519SignatureFunctionTest { assertFalse(signatureFunction.supportPrivKey(ripemd160PubKeyBytes)); } -// @Test -// public void resolveSymmetricKeyTest(){ -// CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); -// assertNotNull(algorithm); -// -// SymmetricEncryptionFunction symmetricEncryptionFunction = -// CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); -// -// SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); -// byte[] symmetricKeyBytes = symmetricKey.toBytes(); -// -// SymmetricKey resolvedKey = symmetricEncryptionFunction.resolveSymmetricKey(symmetricKeyBytes); -// -// assertEquals(SYMMETRIC.CODE,resolvedKey.getKeyType().CODE); -// assertEquals(128 / 8, resolvedKey.getRawKeyBytes().length); -// -// assertEquals(algorithm.name(),resolvedKey.getAlgorithm().name()); -// assertEquals(algorithm.toString(),resolvedKey.getAlgorithm().toString()); -// -// -// algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); -// assertNotNull(algorithm); -// byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); -// byte[] pubKeyTypeBytes = new byte[] {PUBLIC.CODE}; -// byte[] rawKeyBytes = symmetricKey.getRawKeyBytes(); -// byte[] ripemd160KeyBytes = BytesUtils.concat(algoBytes,pubKeyTypeBytes,rawKeyBytes); -// -// -// Class expectedException = CryptoException.class; -// Exception actualEx = null; -// try { -// symmetricEncryptionFunction.resolveSymmetricKey(ripemd160KeyBytes); -// } catch (Exception e) { -// actualEx = e; -// } -// assertNotNull(actualEx); -// assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); -// } -// -// @Test -// public void supportCiphertextTest(){ -// -// byte[] data = new byte[1024]; -// Random random = new Random(); -// random.nextBytes(data); -// -// CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); -// assertNotNull(algorithm); -// -// SymmetricEncryptionFunction symmetricEncryptionFunction = -// CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); -// -// SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); -// -// Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey,data); -// -// byte[] ciphertextBytes = ciphertext.toBytes(); -// assertTrue(symmetricEncryptionFunction.supportCiphertext(ciphertextBytes)); -// -// algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); -// assertNotNull(algorithm); -// byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); -// byte[] rawCiphertextBytes = ciphertext.toBytes(); -// byte[] ripemd160CiphertextBytes = BytesUtils.concat(algoBytes,rawCiphertextBytes); -// -// assertFalse(symmetricEncryptionFunction.supportCiphertext(ripemd160CiphertextBytes)); -// } -// -// @Test -// public void resolveCiphertextTest(){ -// -// byte[] data = new byte[1024]; -// Random random = new Random(); -// random.nextBytes(data); -// -// CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); -// assertNotNull(algorithm); -// -// SymmetricEncryptionFunction symmetricEncryptionFunction = -// CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); -// -// SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); -// -// Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey,data); -// -// byte[] ciphertextBytes = ciphertext.toBytes(); -// assertTrue(symmetricEncryptionFunction.supportCiphertext(ciphertextBytes)); -// -// algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); -// assertNotNull(algorithm); -// byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); -// byte[] rawCiphertextBytes = ciphertext.toBytes(); -// byte[] ripemd160CiphertextBytes = BytesUtils.concat(algoBytes,rawCiphertextBytes); -// -// Class expectedException = CryptoException.class; -// Exception actualEx = null; -// try { -// symmetricEncryptionFunction.resolveSymmetricKey(ripemd160CiphertextBytes); -// } catch (Exception e) { -// actualEx = e; -// } -// assertNotNull(actualEx); -// assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); -// } + @Test + public void resolvePrivKeyTest(){ + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("ed25519"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); + + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PrivKey privKey = keyPair.getPrivKey(); + byte[] privKeyBytes = privKey.toBytes(); + + PrivKey resolvedPrivKey = signatureFunction.resolvePrivKey(privKeyBytes); + + assertEquals(PRIVATE.CODE,resolvedPrivKey.getKeyType().CODE); + assertEquals(32, resolvedPrivKey.getRawKeyBytes().length); + assertEquals("ED25519",resolvedPrivKey.getAlgorithm().name()); + assertEquals((short) (SIGNATURE_ALGORITHM | ASYMMETRIC_KEY | ((byte) 21 & 0x00FF)), + resolvedPrivKey.getAlgorithm().code()); + assertArrayEquals(privKeyBytes,resolvedPrivKey.toBytes()); + + algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); + assertNotNull(algorithm); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] pubKeyTypeBytes = new byte[] {PUBLIC.CODE}; + byte[] rawKeyBytes = privKey.getRawKeyBytes(); + byte[] ripemd160PubKeyBytes = BytesUtils.concat(algoBytes,pubKeyTypeBytes,rawKeyBytes); + + Class expectedException = CryptoException.class; + Exception actualEx = null; + try { + signatureFunction.resolvePrivKey(ripemd160PubKeyBytes); + } catch (Exception e) { + actualEx = e; + } + assertNotNull(actualEx); + assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); + } + + @Test + public void supportPubKeyTest(){ + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("ed25519"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); + + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PubKey pubKey = keyPair.getPubKey(); + byte[] pubKeyBytes = pubKey.toBytes(); + + assertTrue(signatureFunction.supportPubKey(pubKeyBytes)); + + algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); + assertNotNull(algorithm); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] privKeyTypeBytes = new byte[] {PRIVATE.CODE}; + byte[] rawKeyBytes = pubKey.getRawKeyBytes(); + byte[] ripemd160PrivKeyBytes = BytesUtils.concat(algoBytes,privKeyTypeBytes,rawKeyBytes); + + assertFalse(signatureFunction.supportPubKey(ripemd160PrivKeyBytes)); + } + + @Test + public void resolvePubKeyTest(){ + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("ed25519"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); + + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PubKey pubKey = keyPair.getPubKey(); + byte[] pubKeyBytes = pubKey.toBytes(); + + PubKey resolvedPubKey = signatureFunction.resolvePubKey(pubKeyBytes); + + assertEquals(PUBLIC.CODE,resolvedPubKey.getKeyType().CODE); + assertEquals(32, resolvedPubKey.getRawKeyBytes().length); + assertEquals("ED25519",resolvedPubKey.getAlgorithm().name()); + assertEquals((short) (SIGNATURE_ALGORITHM | ASYMMETRIC_KEY | ((byte) 21 & 0x00FF)), + resolvedPubKey.getAlgorithm().code()); + assertArrayEquals(pubKeyBytes,resolvedPubKey.toBytes()); + + algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); + assertNotNull(algorithm); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] privKeyTypeBytes = new byte[] {PRIVATE.CODE}; + byte[] rawKeyBytes = pubKey.getRawKeyBytes(); + byte[] ripemd160PrivKeyBytes = BytesUtils.concat(algoBytes,privKeyTypeBytes,rawKeyBytes); + + + Class expectedException = CryptoException.class; + Exception actualEx = null; + try { + signatureFunction.resolvePrivKey(ripemd160PrivKeyBytes); + } catch (Exception e) { + actualEx = e; + } + assertNotNull(actualEx); + assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); + } + + @Test + public void supportDigestTest(){ + + byte[] data = new byte[1024]; + Random random = new Random(); + random.nextBytes(data); + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("ed25519"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = + CryptoServiceProviders.getSignatureFunction(algorithm); + + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PrivKey privKey = keyPair.getPrivKey(); + + SignatureDigest signatureDigest = signatureFunction.sign(privKey,data); + + byte[] signatureDigestBytes = signatureDigest.toBytes(); + assertTrue(signatureFunction.supportDigest(signatureDigestBytes)); + + algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); + assertNotNull(algorithm); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] rawDigestBytes = signatureDigest.toBytes(); + byte[] ripemd160SignatureBytes = BytesUtils.concat(algoBytes,rawDigestBytes); + + assertFalse(signatureFunction.supportDigest(ripemd160SignatureBytes)); + } + + @Test + public void resolveDigestTest(){ + + byte[] data = new byte[1024]; + Random random = new Random(); + random.nextBytes(data); + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("ed25519"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = + CryptoServiceProviders.getSignatureFunction(algorithm); + + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PrivKey privKey = keyPair.getPrivKey(); + + SignatureDigest signatureDigest = signatureFunction.sign(privKey,data); + + byte[] signatureDigestBytes = signatureDigest.toBytes(); + + SignatureDigest resolvedSignatureDigest = signatureFunction.resolveDigest(signatureDigestBytes); + + assertEquals(64, resolvedSignatureDigest.getRawDigest().length); + assertEquals("ED25519",resolvedSignatureDigest.getAlgorithm().name()); + assertEquals((short) (SIGNATURE_ALGORITHM | ASYMMETRIC_KEY | ((byte) 21 & 0x00FF)), + resolvedSignatureDigest.getAlgorithm().code()); + assertArrayEquals(signatureDigestBytes,resolvedSignatureDigest.toBytes()); + + algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); + assertNotNull(algorithm); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] rawDigestBytes = signatureDigest.getRawDigest(); + byte[] ripemd160SignatureDigestBytes = BytesUtils.concat(algoBytes,rawDigestBytes); + + Class expectedException = CryptoException.class; + Exception actualEx = null; + try { + signatureFunction.resolveDigest(ripemd160SignatureDigestBytes); + } catch (Exception e) { + actualEx = e; + } + assertNotNull(actualEx); + assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); + } } diff --git a/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/RIPEMD160HashFunctionTest.java b/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/RIPEMD160HashFunctionTest.java index d33870b8..aeab812e 100644 --- a/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/RIPEMD160HashFunctionTest.java +++ b/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/RIPEMD160HashFunctionTest.java @@ -10,6 +10,7 @@ import org.junit.Test; import java.util.Random; +import static com.jd.blockchain.crypto.CryptoAlgorithm.HASH_ALGORITHM; import static org.junit.Assert.*; import static org.junit.Assert.assertEquals; @@ -132,11 +133,10 @@ public class RIPEMD160HashFunctionTest { HashDigest resolvedDigest = hashFunction.resolveHashDigest(digestBytes); - assertArrayEquals(digest.toBytes(),resolvedDigest.toBytes()); - assertArrayEquals(digest.getRawDigest(),resolvedDigest.getRawDigest()); - assertEquals(digest.getAlgorithm().name(),resolvedDigest.getAlgorithm().name()); - assertEquals(digest.getAlgorithm().code(),resolvedDigest.getAlgorithm().code()); - + assertEquals(160 / 8,resolvedDigest.getRawDigest().length); + assertEquals("RIPEMD160",resolvedDigest.getAlgorithm().name()); + assertEquals((short) (HASH_ALGORITHM | ((byte) 25 & 0x00FF)),resolvedDigest.getAlgorithm().code()); + assertArrayEquals(digestBytes,resolvedDigest.toBytes()); algorithm = CryptoServiceProviders.getAlgorithm("aes"); assertNotNull(algorithm); diff --git a/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/SHA256HashFunctionTest.java b/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/SHA256HashFunctionTest.java index 7bbe3ff5..a074d190 100644 --- a/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/SHA256HashFunctionTest.java +++ b/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/SHA256HashFunctionTest.java @@ -10,6 +10,7 @@ import org.junit.Test; import java.util.Random; +import static com.jd.blockchain.crypto.CryptoAlgorithm.HASH_ALGORITHM; import static org.junit.Assert.*; /** @@ -132,11 +133,10 @@ public class SHA256HashFunctionTest { HashDigest resolvedDigest = hashFunction.resolveHashDigest(digestBytes); - assertArrayEquals(digest.toBytes(),resolvedDigest.toBytes()); - assertArrayEquals(digest.getRawDigest(),resolvedDigest.getRawDigest()); - assertEquals(digest.getAlgorithm().name(),resolvedDigest.getAlgorithm().name()); - assertEquals(digest.getAlgorithm().code(),resolvedDigest.getAlgorithm().code()); - + assertEquals(256 / 8,resolvedDigest.getRawDigest().length); + assertEquals("SHA256",resolvedDigest.getAlgorithm().name()); + assertEquals((short) (HASH_ALGORITHM | ((byte) 24 & 0x00FF)),resolvedDigest.getAlgorithm().code()); + assertArrayEquals(digestBytes,resolvedDigest.toBytes()); algorithm = CryptoServiceProviders.getAlgorithm("aes"); assertNotNull(algorithm); diff --git a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/asymmetric/AsymmetricCryptography.java b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/asymmetric/AsymmetricCryptography.java index 21b855e1..c893d890 100644 --- a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/asymmetric/AsymmetricCryptography.java +++ b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/asymmetric/AsymmetricCryptography.java @@ -69,7 +69,7 @@ // * @param privKeyBytes 包含算法标识、密钥掩码和私钥的字节数组 // * @return 包含算法标识、密钥掩码和公钥的字节数组 // */ -// byte[] retrievePubKeyBytes(byte[] privKeyBytes); +// byte[] retrievePubKey(byte[] privKeyBytes); // // byte[] tryRetrievePubKeyBytes(byte[] privKeyBytes); // diff --git a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/asymmetric/AsymmetricEncryptionFunction.java b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/asymmetric/AsymmetricEncryptionFunction.java index 04d8d525..9e970cee 100644 --- a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/asymmetric/AsymmetricEncryptionFunction.java +++ b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/asymmetric/AsymmetricEncryptionFunction.java @@ -26,12 +26,12 @@ public interface AsymmetricEncryptionFunction extends CryptoKeyPairGenerator, Cr byte[] decrypt(PrivKey privKey, Ciphertext ciphertext); /** - * 使用字节数组形式的私钥生成字节数组形式的公钥； + * 使用私钥恢复公钥； * - * @param privKeyBytes 包含算法标识、密钥掩码和私钥的字节数组 - * @return 包含算法标识、密钥掩码和公钥的字节数组 + * @param privKey PrivKey形式的私钥信息 + * @return PubKey形式的公钥信息 */ - byte[] retrievePubKeyBytes(byte[] privKeyBytes); + PubKey retrievePubKey(PrivKey privKey); /** * 校验私钥格式是否满足要求； diff --git a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/asymmetric/SignatureFunction.java b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/asymmetric/SignatureFunction.java index 355f6df7..c82a868d 100644 --- a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/asymmetric/SignatureFunction.java +++ b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/asymmetric/SignatureFunction.java @@ -25,12 +25,12 @@ public interface SignatureFunction extends CryptoKeyPairGenerator, CryptoFunctio boolean verify(SignatureDigest digest, PubKey pubKey, byte[] data); /** - * 使用字节数组形式的私钥生成字节数组形式的公钥； + * 使用私钥恢复公钥； * - * @param privKeyBytes 包含算法标识、密钥掩码和私钥的字节数组 - * @return 包含算法标识、密钥掩码和公钥的字节数组 + * @param privKey PrivKey形式的私钥信息 + * @return PubKey形式的公钥信息 */ - byte[] retrievePubKeyBytes(byte[] privKeyBytes); + PubKey retrievePubKey(PrivKey privKey); /** * 校验私钥格式是否满足要求； diff --git a/source/crypto/crypto-sm/src/main/java/com/jd/blockchain/crypto/service/sm/SM2CryptoFunction.java b/source/crypto/crypto-sm/src/main/java/com/jd/blockchain/crypto/service/sm/SM2CryptoFunction.java index 1c57ec37..1efac884 100644 --- a/source/crypto/crypto-sm/src/main/java/com/jd/blockchain/crypto/service/sm/SM2CryptoFunction.java +++ b/source/crypto/crypto-sm/src/main/java/com/jd/blockchain/crypto/service/sm/SM2CryptoFunction.java @@ -79,13 +79,20 @@ public class SM2CryptoFunction implements AsymmetricEncryptionFunction, Signatur } @Override - public byte[] retrievePubKeyBytes(byte[] privKeyBytes) { - - byte[] rawPrivKeyBytes = resolvePrivKey(privKeyBytes).getRawKeyBytes(); + public PubKey retrievePubKey(PrivKey privKey) { + byte[] rawPrivKeyBytes = privKey.getRawKeyBytes(); byte[] rawPubKeyBytes = SM2Utils.retrievePublicKey(rawPrivKeyBytes); - return new PubKey(SM2, rawPubKeyBytes).toBytes(); + return new PubKey(SM2, rawPubKeyBytes); } +// @Override +// public byte[] retrievePubKey(byte[] privKeyBytes) { +// +// byte[] rawPrivKeyBytes = resolvePrivKey(privKeyBytes).getRawKeyBytes(); +// byte[] rawPubKeyBytes = SM2Utils.retrievePublicKey(rawPrivKeyBytes); +// return new PubKey(SM2, rawPubKeyBytes).toBytes(); +// } + @Override public boolean supportPrivKey(byte[] privKeyBytes) { // 验证输入字节数组长度=算法标识长度+密钥类型长度+密钥长度，密钥数据的算法标识对应SM2算法，并且密钥类型是私钥 diff --git a/source/crypto/crypto-sm/src/test/java/test/com/jd/blockchain/crypto/service/sm/SM2CyptoFunctionTest.java b/source/crypto/crypto-sm/src/test/java/test/com/jd/blockchain/crypto/service/sm/SM2CyptoFunctionTest.java index 8e52ec27..4226910d 100644 --- a/source/crypto/crypto-sm/src/test/java/test/com/jd/blockchain/crypto/service/sm/SM2CyptoFunctionTest.java +++ b/source/crypto/crypto-sm/src/test/java/test/com/jd/blockchain/crypto/service/sm/SM2CyptoFunctionTest.java @@ -1,5 +1,20 @@ package test.com.jd.blockchain.crypto.service.sm; +import com.jd.blockchain.crypto.*; +import com.jd.blockchain.crypto.asymmetric.AsymmetricEncryptionFunction; +import com.jd.blockchain.crypto.asymmetric.CryptoKeyPair; +import com.jd.blockchain.crypto.asymmetric.SignatureDigest; +import com.jd.blockchain.crypto.asymmetric.SignatureFunction; +import com.jd.blockchain.utils.io.BytesUtils; +import org.junit.Test; + +import java.util.Random; + +import static com.jd.blockchain.crypto.CryptoAlgorithm.*; +import static com.jd.blockchain.crypto.CryptoKeyType.PRIVATE; +import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; +import static org.junit.Assert.*; + /** * @author zhanglin33 * @title: SM2CyptoFunctionTest @@ -7,4 +22,480 @@ package test.com.jd.blockchain.crypto.service.sm; * @date 2019-04-03, 16:32 */ public class SM2CyptoFunctionTest { + + @Test + public void getAlgorithmTest(){ + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); + + + assertEquals(signatureFunction.getAlgorithm().name(), algorithm.name()); + assertEquals(signatureFunction.getAlgorithm().code(), algorithm.code()); + + algorithm = CryptoServiceProviders.getAlgorithm("sM2"); + assertNotNull(algorithm); + + assertEquals(signatureFunction.getAlgorithm().name(), algorithm.name()); + assertEquals(signatureFunction.getAlgorithm().code(), algorithm.code()); + + algorithm = CryptoServiceProviders.getAlgorithm("sm22"); + assertNull(algorithm); + } + + @Test + public void generateKeyPairTest(){ + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); + + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PubKey pubKey = keyPair.getPubKey(); + PrivKey privKey = keyPair.getPrivKey(); + + assertEquals(PUBLIC.CODE,pubKey.getKeyType().CODE); + assertEquals(65, pubKey.getRawKeyBytes().length); + assertEquals(PRIVATE.CODE,privKey.getKeyType().CODE); + assertEquals(32, privKey.getRawKeyBytes().length); + + assertEquals(algorithm.name(),pubKey.getAlgorithm().name()); + assertEquals(algorithm.code(),pubKey.getAlgorithm().code()); + assertEquals(algorithm.name(),privKey.getAlgorithm().name()); + assertEquals(algorithm.code(),privKey.getAlgorithm().code()); + + assertEquals(2 + 1 + 65, pubKey.toBytes().length); + assertEquals(2 + 1 + 32, privKey.toBytes().length); + + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] pubKeyTypeBytes = new byte[] {PUBLIC.CODE}; + byte[] privKeyTypeBytes = new byte[] {PRIVATE.CODE}; + byte[] rawPubKeyBytes = pubKey.getRawKeyBytes(); + byte[] rawPrivKeyBytes = privKey.getRawKeyBytes(); + assertArrayEquals(BytesUtils.concat(algoBytes,pubKeyTypeBytes,rawPubKeyBytes),pubKey.toBytes()); + assertArrayEquals(BytesUtils.concat(algoBytes,privKeyTypeBytes,rawPrivKeyBytes),privKey.toBytes()); + } + + @Test + public void retrievePubKeyTest(){ + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); + + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PubKey pubKey = keyPair.getPubKey(); + PrivKey privKey = keyPair.getPrivKey(); + + PubKey retrievedPubKey = signatureFunction.retrievePubKey(privKey); + + assertEquals(pubKey.getKeyType(),retrievedPubKey.getKeyType()); + assertEquals(pubKey.getRawKeyBytes().length, retrievedPubKey.getRawKeyBytes().length); + assertEquals(pubKey.getAlgorithm().name(),retrievedPubKey.getAlgorithm().name()); + assertEquals(pubKey.getAlgorithm().code(),retrievedPubKey.getAlgorithm().code()); + assertArrayEquals(pubKey.toBytes(),retrievedPubKey.toBytes()); + } + + @Test + public void signTest(){ + + byte[] data = new byte[1024]; + Random random = new Random(); + random.nextBytes(data); + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); + + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PrivKey privKey = keyPair.getPrivKey(); + SignatureDigest signatureDigest = signatureFunction.sign(privKey,data); + + byte[] signatureBytes = signatureDigest.toBytes(); + + assertEquals(2 + 64, signatureBytes.length); + CryptoAlgorithm signatureAlgo = signatureDigest.getAlgorithm(); + assertEquals(algorithm.name(),signatureDigest.getAlgorithm().name()); + assertEquals(algorithm.code(),signatureDigest.getAlgorithm().code()); + + assertEquals("SM2",signatureAlgo.name()); + assertEquals((short) (SIGNATURE_ALGORITHM | ENCRYPTION_ALGORITHM | ASYMMETRIC_KEY | ((byte) 2 & 0x00FF)), + signatureAlgo.code()); + + byte[] algoBytes = CryptoAlgorithm.toBytes(signatureAlgo); + byte[] rawSinatureBytes = signatureDigest.getRawDigest(); + assertArrayEquals(BytesUtils.concat(algoBytes,rawSinatureBytes),signatureBytes); + } + + @Test + public void verifyTest(){ + byte[] data = new byte[1024]; + Random random = new Random(); + random.nextBytes(data); + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); + + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PubKey pubKey = keyPair.getPubKey(); + PrivKey privKey = keyPair.getPrivKey(); + SignatureDigest signatureDigest = signatureFunction.sign(privKey,data); + + assertTrue(signatureFunction.verify(signatureDigest,pubKey,data)); + } + + @Test + public void encryptTest(){ + + byte[] data = new byte[1024]; + Random random = new Random(); + random.nextBytes(data); + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); + assertNotNull(algorithm); + + AsymmetricEncryptionFunction asymmetricEncryptionFunction = + CryptoServiceProviders.getAsymmetricEncryptionFunction(algorithm); + + CryptoKeyPair keyPair = asymmetricEncryptionFunction.generateKeyPair(); + + PubKey pubKey = keyPair.getPubKey(); + + Ciphertext ciphertext =asymmetricEncryptionFunction.encrypt(pubKey,data); + + byte[] ciphertextBytes = ciphertext.toBytes(); + assertEquals(2 + 65 + 256 / 8 + 1024, ciphertextBytes.length); + CryptoAlgorithm ciphertextAlgo = ciphertext.getAlgorithm(); + assertEquals("SM2",ciphertext.getAlgorithm().name()); + assertEquals((short) (SIGNATURE_ALGORITHM | ENCRYPTION_ALGORITHM | ASYMMETRIC_KEY | ((byte) 2 & 0x00FF)), + ciphertextAlgo.code()); + + byte[] algoBytes = CryptoAlgorithm.toBytes(ciphertextAlgo); + byte[] rawCiphertextBytes = ciphertext.getRawCiphertext(); + assertArrayEquals(BytesUtils.concat(algoBytes,rawCiphertextBytes),ciphertextBytes); + } + + + @Test + public void decryptTest(){ + + byte[] data = new byte[1024]; + Random random = new Random(); + random.nextBytes(data); + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); + assertNotNull(algorithm); + + AsymmetricEncryptionFunction asymmetricEncryptionFunction = + CryptoServiceProviders.getAsymmetricEncryptionFunction(algorithm); + + CryptoKeyPair keyPair = asymmetricEncryptionFunction.generateKeyPair(); + + PubKey pubKey = keyPair.getPubKey(); + PrivKey privKey = keyPair.getPrivKey(); + + Ciphertext ciphertext =asymmetricEncryptionFunction.encrypt(pubKey,data); + + byte[] decryptedPlaintext = asymmetricEncryptionFunction.decrypt(privKey,ciphertext); + + assertArrayEquals(data,decryptedPlaintext); + } + + + @Test + public void supportPrivKeyTest(){ + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); + + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PrivKey privKey = keyPair.getPrivKey(); + byte[] privKeyBytes = privKey.toBytes(); + + assertTrue(signatureFunction.supportPrivKey(privKeyBytes)); + + algorithm = CryptoServiceProviders.getAlgorithm("sm3"); + assertNotNull(algorithm); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] pubKeyTypeBytes = new byte[] {PUBLIC.CODE}; + byte[] rawKeyBytes = privKey.getRawKeyBytes(); + byte[] sm3PubKeyBytes = BytesUtils.concat(algoBytes,pubKeyTypeBytes,rawKeyBytes); + + assertFalse(signatureFunction.supportPrivKey(sm3PubKeyBytes)); + } + + @Test + public void resolvePrivKeyTest(){ + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); + + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PrivKey privKey = keyPair.getPrivKey(); + byte[] privKeyBytes = privKey.toBytes(); + + PrivKey resolvedPrivKey = signatureFunction.resolvePrivKey(privKeyBytes); + + assertEquals(PRIVATE.CODE,resolvedPrivKey.getKeyType().CODE); + assertEquals(32, resolvedPrivKey.getRawKeyBytes().length); + assertEquals("SM2",resolvedPrivKey.getAlgorithm().name()); + assertEquals((short) (SIGNATURE_ALGORITHM | ENCRYPTION_ALGORITHM | ASYMMETRIC_KEY | ((byte) 2 & 0x00FF)), + resolvedPrivKey.getAlgorithm().code()); + assertArrayEquals(privKeyBytes,resolvedPrivKey.toBytes()); + + algorithm = CryptoServiceProviders.getAlgorithm("sm3"); + assertNotNull(algorithm); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] pubKeyTypeBytes = new byte[] {PUBLIC.CODE}; + byte[] rawKeyBytes = privKey.getRawKeyBytes(); + byte[] sm3PubKeyBytes = BytesUtils.concat(algoBytes,pubKeyTypeBytes,rawKeyBytes); + + Class expectedException = CryptoException.class; + Exception actualEx = null; + try { + signatureFunction.resolvePrivKey(sm3PubKeyBytes); + } catch (Exception e) { + actualEx = e; + } + assertNotNull(actualEx); + assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); + } + + @Test + public void supportPubKeyTest(){ + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); + + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PubKey pubKey = keyPair.getPubKey(); + byte[] pubKeyBytes = pubKey.toBytes(); + + assertTrue(signatureFunction.supportPubKey(pubKeyBytes)); + + algorithm = CryptoServiceProviders.getAlgorithm("sm3"); + assertNotNull(algorithm); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] privKeyTypeBytes = new byte[] {PRIVATE.CODE}; + byte[] rawKeyBytes = pubKey.getRawKeyBytes(); + byte[] sm3PrivKeyBytes = BytesUtils.concat(algoBytes,privKeyTypeBytes,rawKeyBytes); + + assertFalse(signatureFunction.supportPubKey(sm3PrivKeyBytes)); + } + + @Test + public void resolvePubKeyTest(){ + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); + + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PubKey pubKey = keyPair.getPubKey(); + byte[] pubKeyBytes = pubKey.toBytes(); + + PubKey resolvedPubKey = signatureFunction.resolvePubKey(pubKeyBytes); + + assertEquals(PUBLIC.CODE,resolvedPubKey.getKeyType().CODE); + assertEquals(65, resolvedPubKey.getRawKeyBytes().length); + assertEquals("SM2",resolvedPubKey.getAlgorithm().name()); + assertEquals((short) (SIGNATURE_ALGORITHM | ENCRYPTION_ALGORITHM | ASYMMETRIC_KEY | ((byte) 2 & 0x00FF)), + resolvedPubKey.getAlgorithm().code()); + assertArrayEquals(pubKeyBytes,resolvedPubKey.toBytes()); + + algorithm = CryptoServiceProviders.getAlgorithm("sm3"); + assertNotNull(algorithm); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] privKeyTypeBytes = new byte[] {PRIVATE.CODE}; + byte[] rawKeyBytes = pubKey.getRawKeyBytes(); + byte[] sm3PrivKeyBytes = BytesUtils.concat(algoBytes,privKeyTypeBytes,rawKeyBytes); + + Class expectedException = CryptoException.class; + Exception actualEx = null; + try { + signatureFunction.resolvePrivKey(sm3PrivKeyBytes); + } catch (Exception e) { + actualEx = e; + } + assertNotNull(actualEx); + assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); + } + + @Test + public void supportDigestTest(){ + + byte[] data = new byte[1024]; + Random random = new Random(); + random.nextBytes(data); + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = + CryptoServiceProviders.getSignatureFunction(algorithm); + + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PrivKey privKey = keyPair.getPrivKey(); + + SignatureDigest signatureDigest = signatureFunction.sign(privKey,data); + + byte[] signatureDigestBytes = signatureDigest.toBytes(); + assertTrue(signatureFunction.supportDigest(signatureDigestBytes)); + + algorithm = CryptoServiceProviders.getAlgorithm("sm3"); + assertNotNull(algorithm); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] rawDigestBytes = signatureDigest.toBytes(); + byte[] sm3SignatureBytes = BytesUtils.concat(algoBytes,rawDigestBytes); + + assertFalse(signatureFunction.supportDigest(sm3SignatureBytes)); + } + + @Test + public void resolveDigestTest(){ + + byte[] data = new byte[1024]; + Random random = new Random(); + random.nextBytes(data); + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); + assertNotNull(algorithm); + + SignatureFunction signatureFunction = + CryptoServiceProviders.getSignatureFunction(algorithm); + + CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); + + PrivKey privKey = keyPair.getPrivKey(); + + SignatureDigest signatureDigest = signatureFunction.sign(privKey,data); + + byte[] signatureDigestBytes = signatureDigest.toBytes(); + + SignatureDigest resolvedSignatureDigest = signatureFunction.resolveDigest(signatureDigestBytes); + + assertEquals(64, resolvedSignatureDigest.getRawDigest().length); + assertEquals("SM2",resolvedSignatureDigest.getAlgorithm().name()); + assertEquals((short) (SIGNATURE_ALGORITHM | ENCRYPTION_ALGORITHM | ASYMMETRIC_KEY | ((byte) 2 & 0x00FF)), + resolvedSignatureDigest.getAlgorithm().code()); + assertArrayEquals(signatureDigestBytes,resolvedSignatureDigest.toBytes()); + + algorithm = CryptoServiceProviders.getAlgorithm("sm3"); + assertNotNull(algorithm); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] rawDigestBytes = signatureDigest.getRawDigest(); + byte[] sm3SignatureDigestBytes = BytesUtils.concat(algoBytes,rawDigestBytes); + + Class expectedException = CryptoException.class; + Exception actualEx = null; + try { + signatureFunction.resolveDigest(sm3SignatureDigestBytes); + } catch (Exception e) { + actualEx = e; + } + assertNotNull(actualEx); + assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); + } + + @Test + public void supportCiphertextTest(){ + + byte[] data = new byte[1024]; + Random random = new Random(); + random.nextBytes(data); + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); + assertNotNull(algorithm); + + AsymmetricEncryptionFunction asymmetricEncryptionFunction = + CryptoServiceProviders.getAsymmetricEncryptionFunction(algorithm); + + CryptoKeyPair keyPair = asymmetricEncryptionFunction.generateKeyPair(); + + PubKey pubKey = keyPair.getPubKey(); + + Ciphertext ciphertext =asymmetricEncryptionFunction.encrypt(pubKey,data); + + byte[] ciphertextBytes = ciphertext.toBytes(); + + assertTrue(asymmetricEncryptionFunction.supportCiphertext(ciphertextBytes)); + + algorithm = CryptoServiceProviders.getAlgorithm("sm3"); + assertNotNull(algorithm); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] rawCiphertextBytes = ciphertext.toBytes(); + byte[] sm3CiphertextBytes = BytesUtils.concat(algoBytes,rawCiphertextBytes); + + assertFalse(asymmetricEncryptionFunction.supportCiphertext(sm3CiphertextBytes)); + } + + @Test + public void resolveCiphertextTest(){ + + byte[] data = new byte[1024]; + Random random = new Random(); + random.nextBytes(data); + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); + assertNotNull(algorithm); + + AsymmetricEncryptionFunction asymmetricEncryptionFunction = + CryptoServiceProviders.getAsymmetricEncryptionFunction(algorithm); + + CryptoKeyPair keyPair = asymmetricEncryptionFunction.generateKeyPair(); + + PubKey pubKey = keyPair.getPubKey(); + + Ciphertext ciphertext =asymmetricEncryptionFunction.encrypt(pubKey,data); + + byte[] ciphertextBytes = ciphertext.toBytes(); + + Ciphertext resolvedCiphertext = asymmetricEncryptionFunction.resolveCiphertext(ciphertextBytes); + + assertEquals(65 + 256 / 8 + 1024, resolvedCiphertext.getRawCiphertext().length); + assertEquals("SM2",resolvedCiphertext.getAlgorithm().name()); + assertEquals((short) (SIGNATURE_ALGORITHM | ENCRYPTION_ALGORITHM | ASYMMETRIC_KEY | ((byte) 2 & 0x00FF)), + resolvedCiphertext.getAlgorithm().code()); + assertArrayEquals(ciphertextBytes,resolvedCiphertext.toBytes()); + + algorithm = CryptoServiceProviders.getAlgorithm("sm3"); + assertNotNull(algorithm); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] rawCiphertextBytes = ciphertext.getRawCiphertext(); + byte[] sm3CiphertextBytes = BytesUtils.concat(algoBytes,rawCiphertextBytes); + + Class expectedException = CryptoException.class; + Exception actualEx = null; + try { + asymmetricEncryptionFunction.resolveCiphertext(sm3CiphertextBytes); + } catch (Exception e) { + actualEx = e; + } + assertNotNull(actualEx); + assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); + } + } diff --git a/source/crypto/crypto-sm/src/test/java/test/com/jd/blockchain/crypto/service/sm/SM3HashFunctionTest.java b/source/crypto/crypto-sm/src/test/java/test/com/jd/blockchain/crypto/service/sm/SM3HashFunctionTest.java index 1aea2610..1cf8a5b0 100644 --- a/source/crypto/crypto-sm/src/test/java/test/com/jd/blockchain/crypto/service/sm/SM3HashFunctionTest.java +++ b/source/crypto/crypto-sm/src/test/java/test/com/jd/blockchain/crypto/service/sm/SM3HashFunctionTest.java @@ -10,6 +10,7 @@ import org.junit.Test; import java.util.Random; +import static com.jd.blockchain.crypto.CryptoAlgorithm.HASH_ALGORITHM; import static org.junit.Assert.*; /** @@ -130,11 +131,10 @@ public class SM3HashFunctionTest { HashDigest resolvedDigest = hashFunction.resolveHashDigest(digestBytes); - assertArrayEquals(digest.toBytes(),resolvedDigest.toBytes()); - assertArrayEquals(digest.getRawDigest(),resolvedDigest.getRawDigest()); - assertEquals(digest.getAlgorithm().name(),resolvedDigest.getAlgorithm().name()); - assertEquals(digest.getAlgorithm().code(),resolvedDigest.getAlgorithm().code()); - + assertEquals(256 / 8,resolvedDigest.getRawDigest().length); + assertEquals("SM3",resolvedDigest.getAlgorithm().name()); + assertEquals((short) (HASH_ALGORITHM | ((byte) 3 & 0x00FF)),resolvedDigest.getAlgorithm().code()); + assertArrayEquals(digestBytes,resolvedDigest.toBytes()); algorithm = CryptoServiceProviders.getAlgorithm("sm4"); assertNotNull(algorithm); @@ -151,21 +151,5 @@ public class SM3HashFunctionTest { } assertNotNull(actualEx); assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); -// -// algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); -// assertNotNull(algorithm); -// algoBytes = CryptoAlgorithm.toBytes(algorithm); -// rawDigestBytes = digest.getRawDigest(); -// byte[] ripemd160DigestBytes = BytesUtils.concat(algoBytes,rawDigestBytes); -// -// expectedException = CryptoException.class; -// actualEx = null; -// try { -// hashFunction.resolveHashDigest(ripemd160DigestBytes); -// } catch (Exception e) { -// actualEx = e; -// } -// assertNotNull(actualEx); -// assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); } } diff --git a/source/crypto/crypto-sm/src/test/java/test/com/jd/blockchain/crypto/service/sm/SM4EncryptionFunctionTest.java b/source/crypto/crypto-sm/src/test/java/test/com/jd/blockchain/crypto/service/sm/SM4EncryptionFunctionTest.java index 002b9e74..9aa99b7d 100644 --- a/source/crypto/crypto-sm/src/test/java/test/com/jd/blockchain/crypto/service/sm/SM4EncryptionFunctionTest.java +++ b/source/crypto/crypto-sm/src/test/java/test/com/jd/blockchain/crypto/service/sm/SM4EncryptionFunctionTest.java @@ -7,6 +7,8 @@ import org.junit.Test; import java.util.Random; +import static com.jd.blockchain.crypto.CryptoAlgorithm.ENCRYPTION_ALGORITHM; +import static com.jd.blockchain.crypto.CryptoAlgorithm.SYMMETRIC_KEY; import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC; import static org.junit.Assert.*; @@ -53,7 +55,7 @@ public class SM4EncryptionFunctionTest { assertEquals(128 / 8, symmetricKey.getRawKeyBytes().length); assertEquals(algorithm.name(),symmetricKey.getAlgorithm().name()); - assertEquals(algorithm.toString(),symmetricKey.getAlgorithm().toString()); + assertEquals(algorithm.code(),symmetricKey.getAlgorithm().code()); assertEquals(2 + 1 + 128 / 8, symmetricKey.toBytes().length); byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); @@ -84,8 +86,8 @@ public class SM4EncryptionFunctionTest { byte[] ciphertextBytes = ciphertext.toBytes(); assertEquals(2 + 16 +16 + 1024 , ciphertextBytes.length); CryptoAlgorithm ciphertextAlgo = ciphertext.getAlgorithm(); - assertEquals(algorithm.name(),symmetricKey.getAlgorithm().name()); - assertEquals(algorithm.toString(),symmetricKey.getAlgorithm().toString()); + assertEquals("SM4",ciphertextAlgo.name()); + assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 4 & 0x00FF)),ciphertextAlgo.code()); byte[] algoBytes = CryptoAlgorithm.toBytes(ciphertextAlgo); byte[] rawCiphertextBytes = ciphertext.getRawCiphertext(); @@ -181,9 +183,9 @@ public class SM4EncryptionFunctionTest { assertEquals(SYMMETRIC.CODE,resolvedKey.getKeyType().CODE); assertEquals(128 / 8, resolvedKey.getRawKeyBytes().length); - - assertEquals(algorithm.name(),resolvedKey.getAlgorithm().name()); - assertEquals(algorithm.toString(),resolvedKey.getAlgorithm().toString()); + assertEquals("SM4",resolvedKey.getAlgorithm().name()); + assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 4 & 0x00FF)),resolvedKey.getAlgorithm().code()); + assertArrayEquals(symmetricKeyBytes,resolvedKey.toBytes()); algorithm = CryptoServiceProviders.getAlgorithm("sm3"); @@ -229,9 +231,9 @@ public class SM4EncryptionFunctionTest { assertNotNull(algorithm); byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); byte[] rawCiphertextBytes = ciphertext.toBytes(); - byte[] ripemd160CiphertextBytes = BytesUtils.concat(algoBytes,rawCiphertextBytes); + byte[] sm3CiphertextBytes = BytesUtils.concat(algoBytes,rawCiphertextBytes); - assertFalse(symmetricEncryptionFunction.supportCiphertext(ripemd160CiphertextBytes)); + assertFalse(symmetricEncryptionFunction.supportCiphertext(sm3CiphertextBytes)); } @Test @@ -252,18 +254,24 @@ public class SM4EncryptionFunctionTest { Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey,data); byte[] ciphertextBytes = ciphertext.toBytes(); - assertTrue(symmetricEncryptionFunction.supportCiphertext(ciphertextBytes)); + + Ciphertext resolvedCiphertext = symmetricEncryptionFunction.resolveCiphertext(ciphertextBytes); + + assertEquals(1024 + 16 + 16, resolvedCiphertext.getRawCiphertext().length); + assertEquals("SM4",resolvedCiphertext.getAlgorithm().name()); + assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 4 & 0x00FF)),resolvedCiphertext.getAlgorithm().code()); + assertArrayEquals(ciphertextBytes,resolvedCiphertext.toBytes()); algorithm = CryptoServiceProviders.getAlgorithm("sm3"); assertNotNull(algorithm); byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); - byte[] rawCiphertextBytes = ciphertext.toBytes(); - byte[] ripemd160CiphertextBytes = BytesUtils.concat(algoBytes,rawCiphertextBytes); + byte[] rawCiphertextBytes = ciphertext.getRawCiphertext(); + byte[] sm3CiphertextBytes = BytesUtils.concat(algoBytes,rawCiphertextBytes); Class expectedException = CryptoException.class; Exception actualEx = null; try { - symmetricEncryptionFunction.resolveSymmetricKey(ripemd160CiphertextBytes); + symmetricEncryptionFunction.resolveCiphertext(sm3CiphertextBytes); } catch (Exception e) { actualEx = e; }