diff --git a/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/AESEncryptionFunction.java b/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/AESEncryptionFunction.java index 939eef78..c4cb74ad 100644 --- a/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/AESEncryptionFunction.java +++ b/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/AESEncryptionFunction.java @@ -2,7 +2,7 @@ package com.jd.blockchain.crypto.service.classic; import static com.jd.blockchain.crypto.BaseCryptoKey.KEY_TYPE_BYTES; import static com.jd.blockchain.crypto.CryptoBytes.ALGORYTHM_CODE_SIZE; -import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC_KEY; +import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC; import java.io.IOException; import java.io.InputStream; @@ -184,7 +184,7 @@ public class AESEncryptionFunction implements SymmetricEncryptionFunction { public boolean supportSymmetricKey(byte[] symmetricKeyBytes) { // 验证输入字节数组长度=算法标识长度+密钥类型长度+密钥长度，字节数组的算法标识对应AES算法且密钥密钥类型是对称密钥 return symmetricKeyBytes.length == SYMMETRICKEY_LENGTH && CryptoAlgorithm.match(AES, symmetricKeyBytes) - && symmetricKeyBytes[ALGORYTHM_CODE_SIZE] == SYMMETRIC_KEY.CODE; + && symmetricKeyBytes[ALGORYTHM_CODE_SIZE] == SYMMETRIC.CODE; } @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 1d60c2e8..e19779d4 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 @@ -2,8 +2,8 @@ package com.jd.blockchain.crypto.service.classic; import static com.jd.blockchain.crypto.BaseCryptoKey.KEY_TYPE_BYTES; import static com.jd.blockchain.crypto.CryptoBytes.ALGORYTHM_CODE_SIZE; -import static com.jd.blockchain.crypto.CryptoKeyType.PRIV_KEY; -import static com.jd.blockchain.crypto.CryptoKeyType.PUB_KEY; +import static com.jd.blockchain.crypto.CryptoKeyType.PRIVATE; +import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; import java.security.KeyPair; @@ -96,7 +96,7 @@ public class ED25519SignatureFunction implements SignatureFunction { public boolean supportPrivKey(byte[] privKeyBytes) { // 验证输入字节数组长度=算法标识长度+密钥类型长度+密钥长度，密钥数据的算法标识对应ED25519签名算法，并且密钥类型是私钥 return privKeyBytes.length == PRIVKEY_LENGTH && CryptoAlgorithm.match(ED25519, privKeyBytes) - && privKeyBytes[ALGORYTHM_CODE_SIZE] == PRIV_KEY.CODE; + && privKeyBytes[ALGORYTHM_CODE_SIZE] == PRIVATE.CODE; } @Override @@ -109,7 +109,7 @@ public class ED25519SignatureFunction implements SignatureFunction { public boolean supportPubKey(byte[] pubKeyBytes) { // 验证输入字节数组长度=算法标识长度+密钥类型长度+密钥长度，密钥数据的算法标识对应ED25519签名算法，并且密钥类型是公钥 return pubKeyBytes.length == PUBKEY_LENGTH && CryptoAlgorithm.match(ED25519, pubKeyBytes) - && pubKeyBytes[ALGORYTHM_CODE_SIZE] == PUB_KEY.CODE; + && pubKeyBytes[ALGORYTHM_CODE_SIZE] == PUBLIC.CODE; } 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 091938cd..57021aeb 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 @@ -1,7 +1,7 @@ //package test.com.jd.blockchain.crypto.asymmetric; // -//import static com.jd.blockchain.crypto.CryptoKeyType.PRIV_KEY; -//import static com.jd.blockchain.crypto.CryptoKeyType.PUB_KEY; +//import static com.jd.blockchain.crypto.CryptoKeyType.PRIVATE; +//import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; //import static org.junit.Assert.assertArrayEquals; //import static org.junit.Assert.assertEquals; //import static org.junit.Assert.assertNotNull; @@ -207,8 +207,8 @@ // assertEquals(expectedPubKeyLength,rawPubKeyBytes.length); // assertEquals(expectedPrivKeyLength,rawPrivKeyBytes.length); // -// assertArrayEquals(BytesUtils.concat(new byte[]{algorithm.CODE},new byte[]{CryptoKeyType.PUB_KEY.CODE},rawPubKeyBytes), pubKeyBytes); -// assertArrayEquals(BytesUtils.concat(new byte[]{algorithm.CODE},new byte[]{CryptoKeyType.PRIV_KEY.CODE},rawPrivKeyBytes), privKeyBytes); +// assertArrayEquals(BytesUtils.concat(new byte[]{algorithm.CODE},new byte[]{CryptoKeyType.PUBLIC.CODE},rawPubKeyBytes), pubKeyBytes); +// assertArrayEquals(BytesUtils.concat(new byte[]{algorithm.CODE},new byte[]{CryptoKeyType.PRIVATE.CODE},rawPrivKeyBytes), privKeyBytes); // // SignatureDigest signatureDigest = sf.sign(privKey,data); // byte[] rawDigest = signatureDigest.getRawDigest(); @@ -414,8 +414,8 @@ // assertEquals(expectedPubKeyLength,rawPubKeyBytes.length); // assertEquals(expectedPrivKeyLength,rawPrivKeyBytes.length); // -// assertArrayEquals(BytesUtils.concat(new byte[]{algorithm.CODE},new byte[]{CryptoKeyType.PUB_KEY.CODE},rawPubKeyBytes), pubKeyBytes); -// assertArrayEquals(BytesUtils.concat(new byte[]{algorithm.CODE},new byte[]{CryptoKeyType.PRIV_KEY.CODE},rawPrivKeyBytes), privKeyBytes); +// assertArrayEquals(BytesUtils.concat(new byte[]{algorithm.CODE},new byte[]{CryptoKeyType.PUBLIC.CODE},rawPubKeyBytes), pubKeyBytes); +// assertArrayEquals(BytesUtils.concat(new byte[]{algorithm.CODE},new byte[]{CryptoKeyType.PRIVATE.CODE},rawPrivKeyBytes), privKeyBytes); // // Ciphertext ciphertext = aef.encrypt(pubKey,data); // byte[] rawCiphertextBytes = ciphertext.getRawCiphertext(); @@ -753,7 +753,7 @@ // verifyResolvePubKey(asymmetricCrypto,algorithm,32,pubKeyBytesWithWrongAlgCode,IllegalArgumentException.class); // // byte[] pubKeyBytesWithWrongKeyType= pubKeyBytes; -// pubKeyBytesWithWrongKeyType[1] = PRIV_KEY.CODE; +// pubKeyBytesWithWrongKeyType[1] = PRIVATE.CODE; // verifyResolvePubKey(asymmetricCrypto,algorithm,32,pubKeyBytesWithWrongKeyType,IllegalArgumentException.class); // // pubKeyBytes = null; @@ -777,7 +777,7 @@ // verifyResolvePubKey(asymmetricCrypto,algorithm,65,pubKeyBytesWithWrongAlgCode,IllegalArgumentException.class); // // pubKeyBytesWithWrongKeyType= pubKeyBytes; -// pubKeyBytesWithWrongKeyType[1] = PRIV_KEY.CODE; +// pubKeyBytesWithWrongKeyType[1] = PRIVATE.CODE; // verifyResolvePubKey(asymmetricCrypto,algorithm,65,pubKeyBytesWithWrongKeyType,IllegalArgumentException.class); // // pubKeyBytes = null; @@ -800,7 +800,7 @@ // verifyResolvePubKey(asymmetricCrypto,algorithm,32,pubKeyBytesWithWrongAlgCode,IllegalArgumentException.class); // // pubKeyBytesWithWrongKeyType= pubKeyBytes; -// pubKeyBytesWithWrongKeyType[1] = PRIV_KEY.CODE; +// pubKeyBytesWithWrongKeyType[1] = PRIVATE.CODE; // verifyResolvePubKey(asymmetricCrypto,algorithm,32,pubKeyBytesWithWrongKeyType,IllegalArgumentException.class); // // pubKeyBytes = null; @@ -863,7 +863,7 @@ // verifyResolvePrivKey(asymmetricCrypto,algorithm,32,privKeyBytesWithWrongAlgCode,IllegalArgumentException.class); // // byte[] privKeyBytesWithWrongKeyType = privKeyBytes; -// privKeyBytesWithWrongKeyType[1] = PUB_KEY.CODE; +// privKeyBytesWithWrongKeyType[1] = PUBLIC.CODE; // verifyResolvePrivKey(asymmetricCrypto,algorithm,32,privKeyBytesWithWrongKeyType,IllegalArgumentException.class); // // privKeyBytes = null; @@ -887,7 +887,7 @@ // verifyResolvePrivKey(asymmetricCrypto,algorithm,32,privKeyBytesWithWrongAlgCode,IllegalArgumentException.class); // // privKeyBytesWithWrongKeyType = privKeyBytes; -// privKeyBytesWithWrongKeyType[1] = PUB_KEY.CODE; +// privKeyBytesWithWrongKeyType[1] = PUBLIC.CODE; // verifyResolvePrivKey(asymmetricCrypto,algorithm,32,privKeyBytesWithWrongKeyType,IllegalArgumentException.class); // // privKeyBytes = null; @@ -910,7 +910,7 @@ // verifyResolvePrivKey(asymmetricCrypto,algorithm,32,privKeyBytesWithWrongAlgCode,IllegalArgumentException.class); // // privKeyBytesWithWrongKeyType = privKeyBytes; -// privKeyBytesWithWrongKeyType[1] = PUB_KEY.CODE; +// privKeyBytesWithWrongKeyType[1] = PUBLIC.CODE; // verifyResolvePrivKey(asymmetricCrypto,algorithm,32,privKeyBytesWithWrongKeyType,IllegalArgumentException.class); // // privKeyBytes = null; 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 fd52129c..a031a882 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 @@ -1,5 +1,20 @@ package test.com.jd.blockchain.crypto.service.classic; +import com.jd.blockchain.crypto.*; +import com.jd.blockchain.crypto.symmetric.SymmetricEncryptionFunction; +import com.jd.blockchain.utils.io.BytesUtils; +import org.junit.Test; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.InputStream; +import java.io.OutputStream; +import java.util.Random; + +import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; +import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC; +import static org.junit.Assert.*; + /** * @author zhanglin33 * @title: AESEncryptionFunctionTest @@ -7,4 +22,257 @@ package test.com.jd.blockchain.crypto.service.classic; * @date 2019-04-01, 13:57 */ public class AESEncryptionFunctionTest { + + @Test + public void getAlgorithmTest(){ + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); + assertNotNull(algorithm); + + SymmetricEncryptionFunction symmetricEncryptionFunction = + CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); + + assertEquals(symmetricEncryptionFunction.getAlgorithm().name(), algorithm.name()); + assertEquals(symmetricEncryptionFunction.getAlgorithm().code(), algorithm.code()); + + algorithm = CryptoServiceProviders.getAlgorithm("AES"); + assertNotNull(algorithm); + + assertEquals(symmetricEncryptionFunction.getAlgorithm().name(), algorithm.name()); + assertEquals(symmetricEncryptionFunction.getAlgorithm().code(), algorithm.code()); + + algorithm = CryptoServiceProviders.getAlgorithm("aess"); + assertNull(algorithm); + } + + @Test + public void generateSymmetricKeyTest(){ + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); + assertNotNull(algorithm); + + SymmetricEncryptionFunction symmetricEncryptionFunction = + CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); + + SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); + + assertEquals(SYMMETRIC.CODE,symmetricKey.getKeyType().CODE); + assertEquals(128 / 8, symmetricKey.getRawKeyBytes().length); + + assertEquals(algorithm.name(),symmetricKey.getAlgorithm().name()); + assertEquals(algorithm.toString(),symmetricKey.getAlgorithm().toString()); + + assertEquals(2 + 1 + 128 / 8, symmetricKey.toBytes().length); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] keyTypeBytes = new byte[] {SYMMETRIC.CODE}; + byte[] rawKeyBytes = symmetricKey.getRawKeyBytes(); + assertArrayEquals(BytesUtils.concat(algoBytes,keyTypeBytes,rawKeyBytes),symmetricKey.toBytes()); + } + + + + @Test + public void encryptTest(){ + + 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(); + assertEquals(2 + 16 + 1024 , ciphertextBytes.length); + CryptoAlgorithm ciphertextAlgo = ciphertext.getAlgorithm(); + assertEquals(algorithm.name(),symmetricKey.getAlgorithm().name()); + assertEquals(algorithm.toString(),symmetricKey.getAlgorithm().toString()); + + 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("aes"); + assertNotNull(algorithm); + + SymmetricEncryptionFunction symmetricEncryptionFunction = + CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); + + SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); + + Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey,data); + + byte[] decryptedPlaintext = symmetricEncryptionFunction.decrypt(symmetricKey,ciphertext); + + assertArrayEquals(data,decryptedPlaintext); + } + +// @Test +// public void streamEncryptTest(){ +// +// byte[] data = new byte[1024]; +// Random random = new Random(); +// random.nextBytes(data); +// +// +// InputStream inputStream = new ByteArrayInputStream(data); +// OutputStream outputStream = new ByteArrayOutputStream(); +// +// CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); +// assertNotNull(algorithm); +// +// SymmetricEncryptionFunction symmetricEncryptionFunction = +// CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); +// +// SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); +// +// symmetricEncryptionFunction.encrypt(symmetricKey,inputStream,outputStream); +// +// assertNotNull(outputStream); +// +// +// } + + + + @Test + public void supportSymmetricKeyTest(){ + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); + assertNotNull(algorithm); + + SymmetricEncryptionFunction symmetricEncryptionFunction = + CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); + + SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); + byte[] symmetricKeyBytes = symmetricKey.toBytes(); + + assertTrue(symmetricEncryptionFunction.supportSymmetricKey(symmetricKeyBytes)); + + 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); + + assertFalse(symmetricEncryptionFunction.supportSymmetricKey(ripemd160KeyBytes)); + } + + @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())); + } } diff --git a/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/symmetric/SymmetricCryptographyImplTest.java b/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/symmetric/SymmetricCryptographyImplTest.java index efcdd3d8..ff0a009e 100644 --- a/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/symmetric/SymmetricCryptographyImplTest.java +++ b/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/symmetric/SymmetricCryptographyImplTest.java @@ -16,8 +16,8 @@ //import java.io.OutputStream; //import java.util.Random; // -//import static com.jd.blockchain.crypto.CryptoKeyType.PRIV_KEY; -//import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC_KEY; +//import static com.jd.blockchain.crypto.CryptoKeyType.PRIVATE; +//import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC; //import static org.junit.Assert.*; // //public class SymmetricCryptographyImplTest { @@ -147,7 +147,7 @@ // //验证SymmetricKey的getRawKeyBytes方法 // assertEquals(16, symmetricKey.getRawKeyBytes().length); // //验证SymmetricKey的toBytes方法 -// assertArrayEquals(BytesUtils.concat(new byte[]{algorithm.CODE},new byte[]{SYMMETRIC_KEY.CODE},symmetricKey.getRawKeyBytes()), symmetricKey.toBytes()); +// assertArrayEquals(BytesUtils.concat(new byte[]{algorithm.CODE},new byte[]{SYMMETRIC.CODE},symmetricKey.getRawKeyBytes()), symmetricKey.toBytes()); // // // Ciphertext ciphertext = sef.encrypt(symmetricKey,data); @@ -393,7 +393,7 @@ // byte[] key = new byte[16]; // randomKey.nextBytes(key); // -// byte[] symmetricKeyBytes = BytesUtils.concat(new byte[]{algorithm.CODE},new byte[]{SYMMETRIC_KEY.CODE},key); +// byte[] symmetricKeyBytes = BytesUtils.concat(new byte[]{algorithm.CODE},new byte[]{SYMMETRIC.CODE},key); // verifyResolveSymmetricKey(symmetricCrypto,algorithm,symmetricKeyBytes,null); // // byte[] truncatedSymmetricKeyBytes = new byte[symmetricKeyBytes.length-2]; @@ -406,7 +406,7 @@ // // byte[] symmetricKeyBytesWithWrongKeyType= symmetricKeyBytes; // System.arraycopy(symmetricKeyBytes,0,symmetricKeyBytesWithWrongKeyType,0,symmetricKeyBytesWithWrongKeyType.length); -// symmetricKeyBytesWithWrongKeyType[1] = PRIV_KEY.CODE; +// symmetricKeyBytesWithWrongKeyType[1] = PRIVATE.CODE; // verifyResolveSymmetricKey(symmetricCrypto,algorithm,symmetricKeyBytesWithWrongKeyType,IllegalArgumentException.class); // // symmetricKeyBytes = null; @@ -415,7 +415,7 @@ // // //test SM4 // algorithm = CryptoAlgorithm.SM4; -// symmetricKeyBytes = BytesUtils.concat(new byte[]{algorithm.CODE},new byte[]{SYMMETRIC_KEY.CODE},key); +// symmetricKeyBytes = BytesUtils.concat(new byte[]{algorithm.CODE},new byte[]{SYMMETRIC.CODE},key); // // verifyResolveSymmetricKey(symmetricCrypto,algorithm,symmetricKeyBytes,null); // @@ -429,7 +429,7 @@ // // symmetricKeyBytesWithWrongKeyType= symmetricKeyBytes; // System.arraycopy(symmetricKeyBytes,0,symmetricKeyBytesWithWrongKeyType,0,symmetricKeyBytesWithWrongKeyType.length); -// symmetricKeyBytesWithWrongKeyType[1] = PRIV_KEY.CODE; +// symmetricKeyBytesWithWrongKeyType[1] = PRIVATE.CODE; // verifyResolveSymmetricKey(symmetricCrypto,algorithm,symmetricKeyBytesWithWrongKeyType,IllegalArgumentException.class); // // symmetricKeyBytes = null; diff --git a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/CryptoKeyType.java b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/CryptoKeyType.java index 61dcbe28..2416e815 100644 --- a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/CryptoKeyType.java +++ b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/CryptoKeyType.java @@ -5,17 +5,17 @@ public enum CryptoKeyType { /** * 非对称密钥的公钥 */ - PUB_KEY((byte)0x01), + PUBLIC((byte)0x01), /** * 非对称密钥的私钥； */ - PRIV_KEY((byte)0x02), + PRIVATE((byte)0x02), /** * 对称密钥； */ - SYMMETRIC_KEY((byte)0x03); + SYMMETRIC((byte)0x03); public final byte CODE; diff --git a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/PrivKey.java b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/PrivKey.java index 96c622f3..f1c7466d 100644 --- a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/PrivKey.java +++ b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/PrivKey.java @@ -10,7 +10,7 @@ public class PrivKey extends BaseCryptoKey { private static final long serialVersionUID = 6265440395252295646L; public PrivKey(CryptoAlgorithm algorithm, byte[] rawCryptoBytes) { - super(algorithm, rawCryptoBytes, CryptoKeyType.PRIV_KEY); + super(algorithm, rawCryptoBytes, CryptoKeyType.PRIVATE); } public PrivKey(byte[] cryptoBytes) { @@ -19,6 +19,6 @@ public class PrivKey extends BaseCryptoKey { @Override public CryptoKeyType getKeyType() { - return CryptoKeyType.PRIV_KEY; + return CryptoKeyType.PRIVATE; } } \ No newline at end of file diff --git a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/PubKey.java b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/PubKey.java index ed228888..f38f48bb 100644 --- a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/PubKey.java +++ b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/PubKey.java @@ -11,7 +11,7 @@ public class PubKey extends BaseCryptoKey { private static final long serialVersionUID = -2055071197736385328L; public PubKey(CryptoAlgorithm algorithm, byte[] rawCryptoBytes) { - super(algorithm, rawCryptoBytes, CryptoKeyType.PUB_KEY); + super(algorithm, rawCryptoBytes, CryptoKeyType.PUBLIC); } public PubKey(byte[] cryptoBytes) { @@ -20,6 +20,6 @@ public class PubKey extends BaseCryptoKey { @Override public CryptoKeyType getKeyType() { - return CryptoKeyType.PUB_KEY; + return CryptoKeyType.PUBLIC; } } \ No newline at end of file diff --git a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/SymmetricKey.java b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/SymmetricKey.java index 5dc9f1f4..f335b8ae 100644 --- a/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/SymmetricKey.java +++ b/source/crypto/crypto-framework/src/main/java/com/jd/blockchain/crypto/SymmetricKey.java @@ -1,6 +1,6 @@ package com.jd.blockchain.crypto; -import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC_KEY; +import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC; /** * 单密钥； @@ -13,7 +13,7 @@ public class SymmetricKey extends BaseCryptoKey { private static final long serialVersionUID = 5055547663903904933L; public SymmetricKey(CryptoAlgorithm algorithm, byte[] rawKeyBytes) { - super(algorithm, rawKeyBytes, SYMMETRIC_KEY); + super(algorithm, rawKeyBytes, SYMMETRIC); } public SymmetricKey(byte[] keyBytes) { @@ -22,7 +22,7 @@ public class SymmetricKey extends BaseCryptoKey { @Override public CryptoKeyType getKeyType() { - return SYMMETRIC_KEY; + return SYMMETRIC; } } 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 2c2c1fb2..8a5c66a7 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 @@ -2,8 +2,8 @@ package com.jd.blockchain.crypto.service.sm; import static com.jd.blockchain.crypto.BaseCryptoKey.KEY_TYPE_BYTES; import static com.jd.blockchain.crypto.CryptoBytes.ALGORYTHM_CODE_SIZE; -import static com.jd.blockchain.crypto.CryptoKeyType.PRIV_KEY; -import static com.jd.blockchain.crypto.CryptoKeyType.PUB_KEY; +import static com.jd.blockchain.crypto.CryptoKeyType.PRIVATE; +import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; import com.jd.blockchain.crypto.*; import org.bouncycastle.crypto.AsymmetricCipherKeyPair; @@ -90,7 +90,7 @@ public class SM2CryptoFunction implements AsymmetricEncryptionFunction, Signatur public boolean supportPrivKey(byte[] privKeyBytes) { // 验证输入字节数组长度=算法标识长度+密钥类型长度+密钥长度，密钥数据的算法标识对应SM2算法，并且密钥类型是私钥 return privKeyBytes.length == PRIVKEY_LENGTH && CryptoAlgorithm.match(SM2, privKeyBytes) - && privKeyBytes[ALGORYTHM_CODE_SIZE] == PRIV_KEY.CODE; + && privKeyBytes[ALGORYTHM_CODE_SIZE] == PRIVATE.CODE; } @Override @@ -103,7 +103,7 @@ public class SM2CryptoFunction implements AsymmetricEncryptionFunction, Signatur public boolean supportPubKey(byte[] pubKeyBytes) { // 验证输入字节数组长度=算法标识长度+密钥类型长度+椭圆曲线点长度，密钥数据的算法标识对应SM2算法，并且密钥类型是公钥 return pubKeyBytes.length == PUBKEY_LENGTH && CryptoAlgorithm.match(SM2, pubKeyBytes) - && pubKeyBytes[ALGORYTHM_CODE_SIZE] == PUB_KEY.CODE; + && pubKeyBytes[ALGORYTHM_CODE_SIZE] == PUBLIC.CODE; } @Override diff --git a/source/crypto/crypto-sm/src/main/java/com/jd/blockchain/crypto/service/sm/SM4EncryptionFunction.java b/source/crypto/crypto-sm/src/main/java/com/jd/blockchain/crypto/service/sm/SM4EncryptionFunction.java index 59fdfb90..626a4512 100644 --- a/source/crypto/crypto-sm/src/main/java/com/jd/blockchain/crypto/service/sm/SM4EncryptionFunction.java +++ b/source/crypto/crypto-sm/src/main/java/com/jd/blockchain/crypto/service/sm/SM4EncryptionFunction.java @@ -2,7 +2,7 @@ package com.jd.blockchain.crypto.service.sm; import static com.jd.blockchain.crypto.BaseCryptoKey.KEY_TYPE_BYTES; import static com.jd.blockchain.crypto.CryptoBytes.ALGORYTHM_CODE_SIZE; -import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC_KEY; +import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC; import java.io.IOException; import java.io.InputStream; @@ -172,7 +172,7 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { public boolean supportSymmetricKey(byte[] symmetricKeyBytes) { // 验证输入字节数组长度=算法标识长度+密钥类型长度+密钥长度，字节数组的算法标识对应SM4算法且密钥密钥类型是对称密钥 return symmetricKeyBytes.length == SYMMETRICKEY_LENGTH && CryptoAlgorithm.match(SM4, symmetricKeyBytes) - && symmetricKeyBytes[ALGORYTHM_CODE_SIZE] == SYMMETRIC_KEY.CODE; + && symmetricKeyBytes[ALGORYTHM_CODE_SIZE] == SYMMETRIC.CODE; } @Override 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 4b5e549a..002b9e74 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 @@ -1,5 +1,16 @@ package test.com.jd.blockchain.crypto.service.sm; +import com.jd.blockchain.crypto.*; +import com.jd.blockchain.crypto.symmetric.SymmetricEncryptionFunction; +import com.jd.blockchain.utils.io.BytesUtils; +import org.junit.Test; + +import java.util.Random; + +import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; +import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC; +import static org.junit.Assert.*; + /** * @author zhanglin33 * @title: SM4EncryptionFunctionTest @@ -7,4 +18,256 @@ package test.com.jd.blockchain.crypto.service.sm; * @date 2019-04-03, 16:35 */ public class SM4EncryptionFunctionTest { + @Test + public void getAlgorithmTest(){ + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm4"); + assertNotNull(algorithm); + + SymmetricEncryptionFunction symmetricEncryptionFunction = + CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); + + assertEquals(symmetricEncryptionFunction.getAlgorithm().name(), algorithm.name()); + assertEquals(symmetricEncryptionFunction.getAlgorithm().code(), algorithm.code()); + + algorithm = CryptoServiceProviders.getAlgorithm("sM4"); + assertNotNull(algorithm); + + assertEquals(symmetricEncryptionFunction.getAlgorithm().name(), algorithm.name()); + assertEquals(symmetricEncryptionFunction.getAlgorithm().code(), algorithm.code()); + + algorithm = CryptoServiceProviders.getAlgorithm("smm4"); + assertNull(algorithm); + } + + @Test + public void generateSymmetricKeyTest(){ + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm4"); + assertNotNull(algorithm); + + SymmetricEncryptionFunction symmetricEncryptionFunction = + CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); + + SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); + + assertEquals(SYMMETRIC.CODE,symmetricKey.getKeyType().CODE); + assertEquals(128 / 8, symmetricKey.getRawKeyBytes().length); + + assertEquals(algorithm.name(),symmetricKey.getAlgorithm().name()); + assertEquals(algorithm.toString(),symmetricKey.getAlgorithm().toString()); + + assertEquals(2 + 1 + 128 / 8, symmetricKey.toBytes().length); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] keyTypeBytes = new byte[] {SYMMETRIC.CODE}; + byte[] rawKeyBytes = symmetricKey.getRawKeyBytes(); + assertArrayEquals(BytesUtils.concat(algoBytes,keyTypeBytes,rawKeyBytes),symmetricKey.toBytes()); + } + + + + @Test + public void encryptTest(){ + + byte[] data = new byte[1024]; + Random random = new Random(); + random.nextBytes(data); + + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm4"); + assertNotNull(algorithm); + + SymmetricEncryptionFunction symmetricEncryptionFunction = + CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); + + SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); + + Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey,data); + + 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()); + + 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("sm4"); + assertNotNull(algorithm); + + SymmetricEncryptionFunction symmetricEncryptionFunction = + CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); + + SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); + + Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey,data); + + byte[] decryptedPlaintext = symmetricEncryptionFunction.decrypt(symmetricKey,ciphertext); + + assertArrayEquals(data,decryptedPlaintext); + } + +// @Test +// public void streamEncryptTest(){ +// +// byte[] data = new byte[1024]; +// Random random = new Random(); +// random.nextBytes(data); +// +// +// InputStream inputStream = new ByteArrayInputStream(data); +// OutputStream outputStream = new ByteArrayOutputStream(); +// +// CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); +// assertNotNull(algorithm); +// +// SymmetricEncryptionFunction symmetricEncryptionFunction = +// CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); +// +// SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); +// +// symmetricEncryptionFunction.encrypt(symmetricKey,inputStream,outputStream); +// +// assertNotNull(outputStream); +// +// +// } + + + + @Test + public void supportSymmetricKeyTest(){ + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm4"); + assertNotNull(algorithm); + + SymmetricEncryptionFunction symmetricEncryptionFunction = + CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); + + SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); + byte[] symmetricKeyBytes = symmetricKey.toBytes(); + + assertTrue(symmetricEncryptionFunction.supportSymmetricKey(symmetricKeyBytes)); + + algorithm = CryptoServiceProviders.getAlgorithm("sm3"); + assertNotNull(algorithm); + byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); + byte[] pubKeyTypeBytes = new byte[] {PUBLIC.CODE}; + byte[] rawKeyBytes = symmetricKey.getRawKeyBytes(); + byte[] ripemd160KeyBytes = BytesUtils.concat(algoBytes,pubKeyTypeBytes,rawKeyBytes); + + assertFalse(symmetricEncryptionFunction.supportSymmetricKey(ripemd160KeyBytes)); + } + + @Test + public void resolveSymmetricKeyTest(){ + CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm4"); + 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("sm3"); + 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("sm4"); + 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("sm3"); + 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("sm4"); + 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("sm3"); + 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())); + } } diff --git a/source/sdk/sdk-samples/src/main/java/com/jd/blockchain/sdk/samples/SDKDemo_User.java b/source/sdk/sdk-samples/src/main/java/com/jd/blockchain/sdk/samples/SDKDemo_User.java index 59c76c68..7e92dfcd 100644 --- a/source/sdk/sdk-samples/src/main/java/com/jd/blockchain/sdk/samples/SDKDemo_User.java +++ b/source/sdk/sdk-samples/src/main/java/com/jd/blockchain/sdk/samples/SDKDemo_User.java @@ -65,7 +65,7 @@ public class SDKDemo_User { // 在本地产生要注册的账户的秘钥； //BlockchainKeyGenerator generator = BlockchainKeyGenerator.getInstance(); - //BlockchainKeyPair user = generator.generate(CryptoKeyType.PUB_KEY); + //BlockchainKeyPair user = generator.generate(CryptoKeyType.PUBLIC); SignatureFunction signatureFunction = asymmetricCryptography.getSignatureFunction(CryptoAlgorithm.ED25519); CryptoKeyPair cryptoKeyPair = signatureFunction.generateKeyPair();