@@ -8,12 +8,18 @@ import java.io.IOException; | |||||
import java.io.InputStream; | import java.io.InputStream; | ||||
import java.io.OutputStream; | import java.io.OutputStream; | ||||
import com.jd.blockchain.crypto.*; | |||||
import com.jd.blockchain.crypto.Ciphertext; | |||||
import com.jd.blockchain.crypto.CryptoAlgorithm; | |||||
import com.jd.blockchain.crypto.CryptoException; | |||||
import com.jd.blockchain.crypto.CryptoKey; | |||||
import com.jd.blockchain.crypto.SymmetricCiphertext; | |||||
import com.jd.blockchain.crypto.SymmetricEncryptionFunction; | |||||
import com.jd.blockchain.crypto.SymmetricKey; | |||||
import com.jd.blockchain.utils.security.AESUtils; | import com.jd.blockchain.utils.security.AESUtils; | ||||
public class AESEncryptionFunction implements SymmetricEncryptionFunction { | public class AESEncryptionFunction implements SymmetricEncryptionFunction { | ||||
public static final CryptoAlgorithm AES = ClassicCryptoService.AES_ALGORITHM; | |||||
public static final CryptoAlgorithm AES = ClassicAlgorithm.AES; | |||||
private static final int KEY_SIZE = 128 / 8; | private static final int KEY_SIZE = 128 / 8; | ||||
private static final int BLOCK_SIZE = 128 / 8; | private static final int BLOCK_SIZE = 128 / 8; | ||||
@@ -38,7 +44,7 @@ public class AESEncryptionFunction implements SymmetricEncryptionFunction { | |||||
} | } | ||||
// 验证密钥数据的算法标识对应AES算法 | // 验证密钥数据的算法标识对应AES算法 | ||||
if (key.getAlgorithm().code() != AES.code()) { | |||||
if (key.getAlgorithm() != AES.code()) { | |||||
throw new CryptoException("The is not AES symmetric key!"); | throw new CryptoException("The is not AES symmetric key!"); | ||||
} | } | ||||
@@ -103,7 +109,7 @@ public class AESEncryptionFunction implements SymmetricEncryptionFunction { | |||||
} | } | ||||
// 验证密钥数据的算法标识对应AES算法 | // 验证密钥数据的算法标识对应AES算法 | ||||
if (key.getAlgorithm().code() != AES.code()) { | |||||
if (key.getAlgorithm() != AES.code()) { | |||||
throw new CryptoException("The is not AES symmetric key!"); | throw new CryptoException("The is not AES symmetric key!"); | ||||
} | } | ||||
@@ -113,7 +119,7 @@ public class AESEncryptionFunction implements SymmetricEncryptionFunction { | |||||
} | } | ||||
// 验证密文数据算法标识对应AES算法 | // 验证密文数据算法标识对应AES算法 | ||||
if (ciphertext.getAlgorithm().code() != AES.code()) { | |||||
if (ciphertext.getAlgorithm() != AES.code()) { | |||||
throw new CryptoException("This is not AES ciphertext!"); | throw new CryptoException("This is not AES ciphertext!"); | ||||
} | } | ||||
@@ -0,0 +1,27 @@ | |||||
package com.jd.blockchain.crypto.service.classic; | |||||
import com.jd.blockchain.crypto.CryptoAlgorithm; | |||||
import com.jd.blockchain.crypto.CryptoAlgorithmDefinition; | |||||
public final class ClassicAlgorithm { | |||||
public static final CryptoAlgorithm ED25519 = CryptoAlgorithmDefinition.defineSignature("ED25519", false, | |||||
(byte) 21); | |||||
public static final CryptoAlgorithm ECDSA = CryptoAlgorithmDefinition.defineSignature("ECDSA", false, (byte) 22); | |||||
public static final CryptoAlgorithm RSA = CryptoAlgorithmDefinition.defineSignature("RSA", true, (byte) 23); | |||||
public static final CryptoAlgorithm SHA256 = CryptoAlgorithmDefinition.defineHash("SHA256", (byte) 24); | |||||
public static final CryptoAlgorithm RIPEMD160 = CryptoAlgorithmDefinition.defineHash("RIPEMD160", (byte) 25); | |||||
public static final CryptoAlgorithm AES = CryptoAlgorithmDefinition.defineSymmetricEncryption("AES", (byte) 26); | |||||
public static final CryptoAlgorithm JVM_SECURE_RANDOM = CryptoAlgorithmDefinition.defineRandom("JVM-SECURE-RANDOM", | |||||
(byte) 27); | |||||
private ClassicAlgorithm() { | |||||
} | |||||
} |
@@ -5,8 +5,6 @@ import java.util.Collection; | |||||
import java.util.Collections; | import java.util.Collections; | ||||
import java.util.List; | import java.util.List; | ||||
import com.jd.blockchain.crypto.CryptoAlgorithm; | |||||
import com.jd.blockchain.crypto.CryptoAlgorithmDefinition; | |||||
import com.jd.blockchain.crypto.CryptoFunction; | import com.jd.blockchain.crypto.CryptoFunction; | ||||
import com.jd.blockchain.crypto.CryptoService; | import com.jd.blockchain.crypto.CryptoService; | ||||
import com.jd.blockchain.provider.NamedProvider; | import com.jd.blockchain.provider.NamedProvider; | ||||
@@ -14,25 +12,6 @@ import com.jd.blockchain.provider.NamedProvider; | |||||
@NamedProvider("CLASSIC") | @NamedProvider("CLASSIC") | ||||
public class ClassicCryptoService implements CryptoService { | public class ClassicCryptoService implements CryptoService { | ||||
public static final CryptoAlgorithm ED25519_ALGORITHM = CryptoAlgorithmDefinition.defineSignature("ED25519", | |||||
false, (byte) 21); | |||||
public static final CryptoAlgorithm ECDSA_ALGORITHM = CryptoAlgorithmDefinition.defineSignature("ECDSA", | |||||
false, (byte) 22); | |||||
public static final CryptoAlgorithm RSA_ALGORITHM = CryptoAlgorithmDefinition.defineSignature("RSA", | |||||
true, (byte) 23); | |||||
public static final CryptoAlgorithm SHA256_ALGORITHM = CryptoAlgorithmDefinition.defineHash("SHA256", | |||||
(byte) 24); | |||||
public static final CryptoAlgorithm RIPEMD160_ALGORITHM = CryptoAlgorithmDefinition.defineHash("RIPEMD160", | |||||
(byte) 25); | |||||
public static final CryptoAlgorithm AES_ALGORITHM = CryptoAlgorithmDefinition.defineSymmetricEncryption("AES", | |||||
(byte) 26); | |||||
public static final CryptoAlgorithm JVM_SECURE_RANDOM_ALGORITHM = CryptoAlgorithmDefinition | |||||
.defineRandom("JVM-SECURE-RANDOM", (byte) 27); | |||||
public static final AESEncryptionFunction AES = new AESEncryptionFunction(); | public static final AESEncryptionFunction AES = new AESEncryptionFunction(); | ||||
@@ -59,7 +59,7 @@ public class ECDSASignatureFunction implements SignatureFunction { | |||||
@Override | @Override | ||||
public CryptoAlgorithm getAlgorithm() { | public CryptoAlgorithm getAlgorithm() { | ||||
return ClassicCryptoService.ECDSA_ALGORITHM; | |||||
return ClassicAlgorithm.ECDSA; | |||||
} | } | ||||
@Override | @Override | ||||
@@ -20,7 +20,7 @@ import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters; | |||||
public class ED25519SignatureFunction implements SignatureFunction { | public class ED25519SignatureFunction implements SignatureFunction { | ||||
private static final CryptoAlgorithm ED25519 = ClassicCryptoService.ED25519_ALGORITHM; | |||||
private static final CryptoAlgorithm ED25519 = ClassicAlgorithm.ED25519; | |||||
private static final int PUBKEY_SIZE = 32; | private static final int PUBKEY_SIZE = 32; | ||||
private static final int PRIVKEY_SIZE = 32; | private static final int PRIVKEY_SIZE = 32; | ||||
@@ -44,7 +44,7 @@ public class ED25519SignatureFunction implements SignatureFunction { | |||||
} | } | ||||
// 验证密钥数据的算法标识对应ED25519签名算法 | // 验证密钥数据的算法标识对应ED25519签名算法 | ||||
if (privKey.getAlgorithm().code() != ED25519.code()) { | |||||
if (privKey.getAlgorithm() != ED25519.code()) { | |||||
throw new CryptoException("This key is not ED25519 private key!"); | throw new CryptoException("This key is not ED25519 private key!"); | ||||
} | } | ||||
@@ -66,12 +66,12 @@ public class ED25519SignatureFunction implements SignatureFunction { | |||||
} | } | ||||
// 验证密钥数据的算法标识对应ED25519签名算法 | // 验证密钥数据的算法标识对应ED25519签名算法 | ||||
if (pubKey.getAlgorithm().code() != ED25519.code()) { | |||||
if (pubKey.getAlgorithm() != ED25519.code()) { | |||||
throw new CryptoException("This key is not ED25519 public key!"); | throw new CryptoException("This key is not ED25519 public key!"); | ||||
} | } | ||||
// 验证密文数据的算法标识对应ED25519签名算法,并且原始摘要长度为64字节 | // 验证密文数据的算法标识对应ED25519签名算法,并且原始摘要长度为64字节 | ||||
if (digest.getAlgorithm().code() != ED25519.code() || rawDigestBytes.length != SIGNATUREDIGEST_SIZE) { | |||||
if (digest.getAlgorithm() != ED25519.code() || rawDigestBytes.length != SIGNATUREDIGEST_SIZE) { | |||||
throw new CryptoException("This is not ED25519 signature digest!"); | throw new CryptoException("This is not ED25519 signature digest!"); | ||||
} | } | ||||
@@ -8,7 +8,7 @@ import com.jd.blockchain.crypto.RandomGenerator; | |||||
public class JVMSecureRandomFunction implements RandomFunction { | public class JVMSecureRandomFunction implements RandomFunction { | ||||
private static final CryptoAlgorithm JVM_SECURE_RANDOM = ClassicCryptoService.JVM_SECURE_RANDOM_ALGORITHM; | |||||
private static final CryptoAlgorithm JVM_SECURE_RANDOM = ClassicAlgorithm.JVM_SECURE_RANDOM; | |||||
JVMSecureRandomFunction() { | JVMSecureRandomFunction() { | ||||
@@ -12,7 +12,7 @@ import com.jd.blockchain.utils.security.RipeMD160Utils; | |||||
public class RIPEMD160HashFunction implements HashFunction { | public class RIPEMD160HashFunction implements HashFunction { | ||||
private static final CryptoAlgorithm RIPEMD160 = ClassicCryptoService.RIPEMD160_ALGORITHM; | |||||
private static final CryptoAlgorithm RIPEMD160 = ClassicAlgorithm.RIPEMD160; | |||||
private static final int DIGEST_BYTES = 160 / 8; | private static final int DIGEST_BYTES = 160 / 8; | ||||
@@ -12,7 +12,7 @@ import com.jd.blockchain.utils.security.ShaUtils; | |||||
public class SHA256HashFunction implements HashFunction { | public class SHA256HashFunction implements HashFunction { | ||||
private static final CryptoAlgorithm SHA256 = ClassicCryptoService.SHA256_ALGORITHM; | |||||
private static final CryptoAlgorithm SHA256 = ClassicAlgorithm.SHA256; | |||||
private static final int DIGEST_BYTES = 256 / 8; | private static final int DIGEST_BYTES = 256 / 8; | ||||
@@ -1,20 +1,28 @@ | |||||
package test.com.jd.blockchain.crypto.service.classic; | package test.com.jd.blockchain.crypto.service.classic; | ||||
import com.jd.blockchain.crypto.*; | |||||
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.CryptoAlgorithm.ENCRYPTION_ALGORITHM; | import static com.jd.blockchain.crypto.CryptoAlgorithm.ENCRYPTION_ALGORITHM; | ||||
import static com.jd.blockchain.crypto.CryptoAlgorithm.SYMMETRIC_KEY; | import static com.jd.blockchain.crypto.CryptoAlgorithm.SYMMETRIC_KEY; | ||||
import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; | import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; | ||||
import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC; | import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC; | ||||
import static org.junit.Assert.*; | |||||
import static org.junit.Assert.assertArrayEquals; | |||||
import static org.junit.Assert.assertEquals; | |||||
import static org.junit.Assert.assertFalse; | |||||
import static org.junit.Assert.assertNotNull; | |||||
import static org.junit.Assert.assertNull; | |||||
import static org.junit.Assert.assertTrue; | |||||
import java.util.Random; | |||||
import org.junit.Test; | |||||
import com.jd.blockchain.crypto.Ciphertext; | |||||
import com.jd.blockchain.crypto.CryptoAlgorithm; | |||||
import com.jd.blockchain.crypto.CryptoException; | |||||
import com.jd.blockchain.crypto.CryptoServiceProviders; | |||||
import com.jd.blockchain.crypto.SymmetricEncryptionFunction; | |||||
import com.jd.blockchain.crypto.SymmetricKey; | |||||
import com.jd.blockchain.crypto.service.classic.ClassicAlgorithm; | |||||
import com.jd.blockchain.utils.io.BytesUtils; | |||||
/** | /** | ||||
* @author zhanglin33 | * @author zhanglin33 | ||||
@@ -24,268 +32,261 @@ import static org.junit.Assert.*; | |||||
*/ | */ | ||||
public class AESEncryptionFunctionTest { | 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.code(),symmetricKey.getAlgorithm().code()); | |||||
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); | |||||
@Test | |||||
public void getAlgorithmTest() { | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = CryptoServiceProviders | |||||
.getSymmetricEncryptionFunction(algorithm); | |||||
Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey,data); | |||||
assertEquals(symmetricEncryptionFunction.getAlgorithm().name(), algorithm.name()); | |||||
assertEquals(symmetricEncryptionFunction.getAlgorithm().code(), algorithm.code()); | |||||
byte[] ciphertextBytes = ciphertext.toBytes(); | |||||
assertEquals(2 + 16 + 1024 , ciphertextBytes.length); | |||||
CryptoAlgorithm ciphertextAlgo = ciphertext.getAlgorithm(); | |||||
assertEquals("AES",ciphertextAlgo.name()); | |||||
assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 26 & 0x00FF)),ciphertextAlgo.code()); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("AES"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(ciphertextAlgo); | |||||
byte[] rawCiphertextBytes = ciphertext.getRawCiphertext(); | |||||
assertArrayEquals(BytesUtils.concat(algoBytes,rawCiphertextBytes),ciphertextBytes); | |||||
} | |||||
assertEquals(symmetricEncryptionFunction.getAlgorithm().name(), algorithm.name()); | |||||
assertEquals(symmetricEncryptionFunction.getAlgorithm().code(), algorithm.code()); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("aess"); | |||||
assertNull(algorithm); | |||||
} | |||||
@Test | |||||
public void decryptTest(){ | |||||
@Test | |||||
public void generateSymmetricKeyTest() { | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = CryptoServiceProviders | |||||
.getSymmetricEncryptionFunction(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = | |||||
CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); | |||||
assertEquals(SYMMETRIC.CODE, symmetricKey.getKeyType().CODE); | |||||
assertEquals(128 / 8, symmetricKey.getRawKeyBytes().length); | |||||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||||
assertEquals(algorithm.code(), symmetricKey.getAlgorithm()); | |||||
Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey,data); | |||||
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()); | |||||
} | |||||
byte[] decryptedPlaintext = symmetricEncryptionFunction.decrypt(symmetricKey,ciphertext); | |||||
@Test | |||||
public void encryptTest() { | |||||
assertArrayEquals(data,decryptedPlaintext); | |||||
} | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
// @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); | |||||
// | |||||
// | |||||
// } | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = CryptoServiceProviders | |||||
.getSymmetricEncryptionFunction(algorithm); | |||||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||||
@Test | |||||
public void supportSymmetricKeyTest(){ | |||||
Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey, data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
byte[] ciphertextBytes = ciphertext.toBytes(); | |||||
assertEquals(2 + 16 + 1024, ciphertextBytes.length); | |||||
assertEquals(ClassicAlgorithm.AES.code(), ciphertext.getAlgorithm()); | |||||
assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 26 & 0x00FF)), ciphertext.getAlgorithm()); | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = | |||||
CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); | |||||
byte[] algoBytes = BytesUtils.toBytes(ciphertext.getAlgorithm()); | |||||
byte[] rawCiphertextBytes = ciphertext.getRawCiphertext(); | |||||
assertArrayEquals(BytesUtils.concat(algoBytes, rawCiphertextBytes), ciphertextBytes); | |||||
} | |||||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||||
byte[] symmetricKeyBytes = symmetricKey.toBytes(); | |||||
@Test | |||||
public void decryptTest() { | |||||
assertTrue(symmetricEncryptionFunction.supportSymmetricKey(symmetricKeyBytes)); | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
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); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = CryptoServiceProviders | |||||
.getSymmetricEncryptionFunction(algorithm); | |||||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||||
assertFalse(symmetricEncryptionFunction.supportSymmetricKey(ripemd160KeyBytes)); | |||||
} | |||||
Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey, data); | |||||
byte[] decryptedPlaintext = symmetricEncryptionFunction.decrypt(symmetricKey, ciphertext); | |||||
@Test | |||||
public void resolveSymmetricKeyTest(){ | |||||
assertArrayEquals(data, decryptedPlaintext); | |||||
} | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
// @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); | |||||
// | |||||
// | |||||
// } | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = | |||||
CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); | |||||
@Test | |||||
public void supportSymmetricKeyTest() { | |||||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||||
byte[] symmetricKeyBytes = symmetricKey.toBytes(); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
SymmetricKey resolvedKey = symmetricEncryptionFunction.resolveSymmetricKey(symmetricKeyBytes); | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = CryptoServiceProviders | |||||
.getSymmetricEncryptionFunction(algorithm); | |||||
assertEquals(SYMMETRIC.CODE,resolvedKey.getKeyType().CODE); | |||||
assertEquals(128 / 8, resolvedKey.getRawKeyBytes().length); | |||||
assertEquals("AES",resolvedKey.getAlgorithm().name()); | |||||
assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 26 & 0x00FF)),resolvedKey.getAlgorithm().code()); | |||||
assertArrayEquals(symmetricKeyBytes,resolvedKey.toBytes()); | |||||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||||
byte[] symmetricKeyBytes = symmetricKey.toBytes(); | |||||
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); | |||||
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); | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
symmetricEncryptionFunction.resolveSymmetricKey(ripemd160KeyBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
assertFalse(symmetricEncryptionFunction.supportSymmetricKey(ripemd160KeyBytes)); | |||||
} | |||||
@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)); | |||||
@Test | |||||
public void resolveSymmetricKeyTest() { | |||||
algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] rawCiphertextBytes = ciphertext.toBytes(); | |||||
byte[] ripemd160CiphertextBytes = BytesUtils.concat(algoBytes,rawCiphertextBytes); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
assertFalse(symmetricEncryptionFunction.supportCiphertext(ripemd160CiphertextBytes)); | |||||
} | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = CryptoServiceProviders | |||||
.getSymmetricEncryptionFunction(algorithm); | |||||
@Test | |||||
public void resolveCiphertextTest(){ | |||||
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(ClassicAlgorithm.AES, resolvedKey.getAlgorithm()); | |||||
assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 26 & 0x00FF)), resolvedKey.getAlgorithm()); | |||||
assertArrayEquals(symmetricKeyBytes, resolvedKey.toBytes()); | |||||
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); | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = | |||||
CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = CryptoServiceProviders | |||||
.getSymmetricEncryptionFunction(algorithm); | |||||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||||
Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey,data); | |||||
Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey, data); | |||||
byte[] ciphertextBytes = ciphertext.toBytes(); | |||||
byte[] ciphertextBytes = ciphertext.toBytes(); | |||||
Ciphertext resolvedCiphertext = symmetricEncryptionFunction.resolveCiphertext(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()); | |||||
assertEquals(1024 + 16, resolvedCiphertext.getRawCiphertext().length); | |||||
assertEquals(ClassicAlgorithm.AES, resolvedCiphertext.getAlgorithm()); | |||||
assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 26 & 0x00FF)), | |||||
resolvedCiphertext.getAlgorithm()); | |||||
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()); | |||||
assertArrayEquals(ciphertext.toBytes(), resolvedCiphertext.toBytes()); | |||||
assertArrayEquals(ciphertext.getRawCiphertext(), resolvedCiphertext.getRawCiphertext()); | |||||
assertEquals(ciphertext.getAlgorithm(), resolvedCiphertext.getAlgorithm()); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] rawCiphertextBytes = ciphertext.getRawCiphertext(); | |||||
byte[] ripemd160CiphertextBytes = BytesUtils.concat(algoBytes,rawCiphertextBytes); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] rawCiphertextBytes = ciphertext.getRawCiphertext(); | |||||
byte[] ripemd160CiphertextBytes = BytesUtils.concat(algoBytes, rawCiphertextBytes); | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
symmetricEncryptionFunction.resolveCiphertext(ripemd160CiphertextBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
symmetricEncryptionFunction.resolveCiphertext(ripemd160CiphertextBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
} | } |
@@ -1,16 +1,30 @@ | |||||
package test.com.jd.blockchain.crypto.service.classic; | package test.com.jd.blockchain.crypto.service.classic; | ||||
import com.jd.blockchain.crypto.*; | |||||
import com.jd.blockchain.utils.io.BytesUtils; | |||||
import org.junit.Test; | |||||
import java.util.Random; | |||||
import static com.jd.blockchain.crypto.CryptoAlgorithm.ASYMMETRIC_KEY; | import static com.jd.blockchain.crypto.CryptoAlgorithm.ASYMMETRIC_KEY; | ||||
import static com.jd.blockchain.crypto.CryptoAlgorithm.SIGNATURE_ALGORITHM; | import static com.jd.blockchain.crypto.CryptoAlgorithm.SIGNATURE_ALGORITHM; | ||||
import static com.jd.blockchain.crypto.CryptoKeyType.PRIVATE; | import static com.jd.blockchain.crypto.CryptoKeyType.PRIVATE; | ||||
import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; | import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; | ||||
import static org.junit.Assert.*; | |||||
import static org.junit.Assert.assertArrayEquals; | |||||
import static org.junit.Assert.assertEquals; | |||||
import static org.junit.Assert.assertFalse; | |||||
import static org.junit.Assert.assertNotNull; | |||||
import static org.junit.Assert.assertNull; | |||||
import static org.junit.Assert.assertTrue; | |||||
import java.util.Random; | |||||
import org.junit.Test; | |||||
import com.jd.blockchain.crypto.CryptoAlgorithm; | |||||
import com.jd.blockchain.crypto.CryptoException; | |||||
import com.jd.blockchain.crypto.CryptoKeyPair; | |||||
import com.jd.blockchain.crypto.CryptoServiceProviders; | |||||
import com.jd.blockchain.crypto.PrivKey; | |||||
import com.jd.blockchain.crypto.PubKey; | |||||
import com.jd.blockchain.crypto.SignatureDigest; | |||||
import com.jd.blockchain.crypto.SignatureFunction; | |||||
import com.jd.blockchain.crypto.service.classic.ClassicAlgorithm; | |||||
import com.jd.blockchain.utils.io.BytesUtils; | |||||
/** | /** | ||||
* @author zhanglin33 | * @author zhanglin33 | ||||
@@ -60,10 +74,8 @@ public class ED25519SignatureFunctionTest { | |||||
assertEquals(PRIVATE.CODE,privKey.getKeyType().CODE); | assertEquals(PRIVATE.CODE,privKey.getKeyType().CODE); | ||||
assertEquals(32, privKey.getRawKeyBytes().length); | 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(algorithm.code(),pubKey.getAlgorithm()); | |||||
assertEquals(algorithm.code(),privKey.getAlgorithm()); | |||||
assertEquals(2 + 1 + 32, pubKey.toBytes().length); | assertEquals(2 + 1 + 32, pubKey.toBytes().length); | ||||
assertEquals(2 + 1 + 32, privKey.toBytes().length); | assertEquals(2 + 1 + 32, privKey.toBytes().length); | ||||
@@ -94,8 +106,7 @@ public class ED25519SignatureFunctionTest { | |||||
assertEquals(pubKey.getKeyType(),retrievedPubKey.getKeyType()); | assertEquals(pubKey.getKeyType(),retrievedPubKey.getKeyType()); | ||||
assertEquals(pubKey.getRawKeyBytes().length, retrievedPubKey.getRawKeyBytes().length); | assertEquals(pubKey.getRawKeyBytes().length, retrievedPubKey.getRawKeyBytes().length); | ||||
assertEquals(pubKey.getAlgorithm().name(),retrievedPubKey.getAlgorithm().name()); | |||||
assertEquals(pubKey.getAlgorithm().code(),retrievedPubKey.getAlgorithm().code()); | |||||
assertEquals(pubKey.getAlgorithm(),retrievedPubKey.getAlgorithm()); | |||||
assertArrayEquals(pubKey.toBytes(),retrievedPubKey.toBytes()); | assertArrayEquals(pubKey.toBytes(),retrievedPubKey.toBytes()); | ||||
} | } | ||||
@@ -119,12 +130,11 @@ public class ED25519SignatureFunctionTest { | |||||
byte[] signatureBytes = signatureDigest.toBytes(); | byte[] signatureBytes = signatureDigest.toBytes(); | ||||
assertEquals(2 + 64, signatureBytes.length); | assertEquals(2 + 64, signatureBytes.length); | ||||
CryptoAlgorithm signatureAlgo = signatureDigest.getAlgorithm(); | |||||
assertEquals("ED25519",signatureAlgo.name()); | |||||
assertEquals(ClassicAlgorithm.ED25519.code(),signatureDigest.getAlgorithm()); | |||||
assertEquals((short) (SIGNATURE_ALGORITHM | ASYMMETRIC_KEY | ((byte) 21 & 0x00FF)), | assertEquals((short) (SIGNATURE_ALGORITHM | ASYMMETRIC_KEY | ((byte) 21 & 0x00FF)), | ||||
signatureAlgo.code()); | |||||
signatureDigest.getAlgorithm()); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(signatureAlgo); | |||||
byte[] algoBytes = BytesUtils.toBytes(signatureDigest.getAlgorithm()); | |||||
byte[] rawSinatureBytes = signatureDigest.getRawDigest(); | byte[] rawSinatureBytes = signatureDigest.getRawDigest(); | ||||
assertArrayEquals(BytesUtils.concat(algoBytes,rawSinatureBytes),signatureBytes); | assertArrayEquals(BytesUtils.concat(algoBytes,rawSinatureBytes),signatureBytes); | ||||
} | } | ||||
@@ -192,9 +202,9 @@ public class ED25519SignatureFunctionTest { | |||||
assertEquals(PRIVATE.CODE,resolvedPrivKey.getKeyType().CODE); | assertEquals(PRIVATE.CODE,resolvedPrivKey.getKeyType().CODE); | ||||
assertEquals(32, resolvedPrivKey.getRawKeyBytes().length); | assertEquals(32, resolvedPrivKey.getRawKeyBytes().length); | ||||
assertEquals("ED25519",resolvedPrivKey.getAlgorithm().name()); | |||||
assertEquals(ClassicAlgorithm.ED25519.code(),resolvedPrivKey.getAlgorithm()); | |||||
assertEquals((short) (SIGNATURE_ALGORITHM | ASYMMETRIC_KEY | ((byte) 21 & 0x00FF)), | assertEquals((short) (SIGNATURE_ALGORITHM | ASYMMETRIC_KEY | ((byte) 21 & 0x00FF)), | ||||
resolvedPrivKey.getAlgorithm().code()); | |||||
resolvedPrivKey.getAlgorithm()); | |||||
assertArrayEquals(privKeyBytes,resolvedPrivKey.toBytes()); | assertArrayEquals(privKeyBytes,resolvedPrivKey.toBytes()); | ||||
algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); | algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); | ||||
@@ -257,9 +267,9 @@ public class ED25519SignatureFunctionTest { | |||||
assertEquals(PUBLIC.CODE,resolvedPubKey.getKeyType().CODE); | assertEquals(PUBLIC.CODE,resolvedPubKey.getKeyType().CODE); | ||||
assertEquals(32, resolvedPubKey.getRawKeyBytes().length); | assertEquals(32, resolvedPubKey.getRawKeyBytes().length); | ||||
assertEquals("ED25519",resolvedPubKey.getAlgorithm().name()); | |||||
assertEquals(ClassicAlgorithm.ED25519.code(),resolvedPubKey.getAlgorithm()); | |||||
assertEquals((short) (SIGNATURE_ALGORITHM | ASYMMETRIC_KEY | ((byte) 21 & 0x00FF)), | assertEquals((short) (SIGNATURE_ALGORITHM | ASYMMETRIC_KEY | ((byte) 21 & 0x00FF)), | ||||
resolvedPubKey.getAlgorithm().code()); | |||||
resolvedPubKey.getAlgorithm()); | |||||
assertArrayEquals(pubKeyBytes,resolvedPubKey.toBytes()); | assertArrayEquals(pubKeyBytes,resolvedPubKey.toBytes()); | ||||
algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); | algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); | ||||
@@ -336,9 +346,9 @@ public class ED25519SignatureFunctionTest { | |||||
SignatureDigest resolvedSignatureDigest = signatureFunction.resolveDigest(signatureDigestBytes); | SignatureDigest resolvedSignatureDigest = signatureFunction.resolveDigest(signatureDigestBytes); | ||||
assertEquals(64, resolvedSignatureDigest.getRawDigest().length); | assertEquals(64, resolvedSignatureDigest.getRawDigest().length); | ||||
assertEquals("ED25519",resolvedSignatureDigest.getAlgorithm().name()); | |||||
assertEquals(ClassicAlgorithm.ED25519,resolvedSignatureDigest.getAlgorithm()); | |||||
assertEquals((short) (SIGNATURE_ALGORITHM | ASYMMETRIC_KEY | ((byte) 21 & 0x00FF)), | assertEquals((short) (SIGNATURE_ALGORITHM | ASYMMETRIC_KEY | ((byte) 21 & 0x00FF)), | ||||
resolvedSignatureDigest.getAlgorithm().code()); | |||||
resolvedSignatureDigest.getAlgorithm()); | |||||
assertArrayEquals(signatureDigestBytes,resolvedSignatureDigest.toBytes()); | assertArrayEquals(signatureDigestBytes,resolvedSignatureDigest.toBytes()); | ||||
algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); | algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); | ||||
@@ -5,6 +5,7 @@ import com.jd.blockchain.crypto.CryptoException; | |||||
import com.jd.blockchain.crypto.CryptoServiceProviders; | import com.jd.blockchain.crypto.CryptoServiceProviders; | ||||
import com.jd.blockchain.crypto.HashDigest; | import com.jd.blockchain.crypto.HashDigest; | ||||
import com.jd.blockchain.crypto.HashFunction; | import com.jd.blockchain.crypto.HashFunction; | ||||
import com.jd.blockchain.crypto.service.classic.ClassicAlgorithm; | |||||
import com.jd.blockchain.utils.io.BytesUtils; | import com.jd.blockchain.utils.io.BytesUtils; | ||||
import org.junit.Test; | import org.junit.Test; | ||||
@@ -22,152 +23,151 @@ import static org.junit.Assert.assertEquals; | |||||
*/ | */ | ||||
public class RIPEMD160HashFunctionTest { | public class RIPEMD160HashFunctionTest { | ||||
@Test | |||||
public void getAlgorithmTest(){ | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("RIPEMD160"); | |||||
assertNotNull(algorithm); | |||||
@Test | |||||
public void getAlgorithmTest() { | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("RIPEMD160"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
assertEquals(hashFunction.getAlgorithm().name(), algorithm.name()); | |||||
assertEquals(hashFunction.getAlgorithm().code(), algorithm.code()); | |||||
assertEquals(hashFunction.getAlgorithm().name(), algorithm.name()); | |||||
assertEquals(hashFunction.getAlgorithm().code(), algorithm.code()); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("RIPEmd160"); | |||||
assertNotNull(algorithm); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("RIPEmd160"); | |||||
assertNotNull(algorithm); | |||||
assertEquals(hashFunction.getAlgorithm().name(), algorithm.name()); | |||||
assertEquals(hashFunction.getAlgorithm().code(), algorithm.code()); | |||||
assertEquals(hashFunction.getAlgorithm().name(), algorithm.name()); | |||||
assertEquals(hashFunction.getAlgorithm().code(), algorithm.code()); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("RIPEMD-160"); | |||||
assertNull(algorithm); | |||||
} | |||||
algorithm = CryptoServiceProviders.getAlgorithm("RIPEMD-160"); | |||||
assertNull(algorithm); | |||||
} | |||||
@Test | |||||
public void hashTest(){ | |||||
@Test | |||||
public void hashTest() { | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("RIPEMD160"); | |||||
assertNotNull(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("RIPEMD160"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
byte[] rawDigestBytes = digest.getRawDigest(); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
byte[] rawDigestBytes = digest.getRawDigest(); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] digestBytes = digest.toBytes(); | |||||
assertEquals(160 / 8 + 2,digestBytes.length); | |||||
assertArrayEquals(digestBytes, BytesUtils.concat(algoBytes, rawDigestBytes)); | |||||
byte[] digestBytes = digest.toBytes(); | |||||
assertEquals(160 / 8 + 2, digestBytes.length); | |||||
assertArrayEquals(digestBytes, BytesUtils.concat(algoBytes, rawDigestBytes)); | |||||
assertEquals(algorithm.code(),digest.getAlgorithm().code()); | |||||
assertEquals(algorithm.name(),digest.getAlgorithm().name()); | |||||
assertEquals(algorithm.code(), digest.getAlgorithm()); | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
data = null; | |||||
hashFunction.hash(data); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
@Test | |||||
public void verifyTest(){ | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("RIPEMD160"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
assertTrue(hashFunction.verify(digest,data)); | |||||
} | |||||
@Test | |||||
public void supportHashDigestTest(){ | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("RIPEMD160"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
byte[] digestBytes = digest.toBytes(); | |||||
assertTrue(hashFunction.supportHashDigest(digestBytes)); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
System.arraycopy(algoBytes,0,digestBytes,0,algoBytes.length); | |||||
assertFalse(hashFunction.supportHashDigest(digestBytes)); | |||||
} | |||||
@Test | |||||
public void resolveHashDigestTest(){ | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("RIPEMD160"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
byte[] digestBytes = digest.toBytes(); | |||||
HashDigest resolvedDigest = hashFunction.resolveHashDigest(digestBytes); | |||||
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); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] rawDigestBytes = digest.getRawDigest(); | |||||
byte[] aesDigestBytes = BytesUtils.concat(algoBytes,rawDigestBytes); | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
hashFunction.resolveHashDigest(aesDigestBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sha256"); | |||||
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())); | |||||
} | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
data = null; | |||||
hashFunction.hash(data); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
@Test | |||||
public void verifyTest() { | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("RIPEMD160"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
assertTrue(hashFunction.verify(digest, data)); | |||||
} | |||||
@Test | |||||
public void supportHashDigestTest() { | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("RIPEMD160"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
byte[] digestBytes = digest.toBytes(); | |||||
assertTrue(hashFunction.supportHashDigest(digestBytes)); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
System.arraycopy(algoBytes, 0, digestBytes, 0, algoBytes.length); | |||||
assertFalse(hashFunction.supportHashDigest(digestBytes)); | |||||
} | |||||
@Test | |||||
public void resolveHashDigestTest() { | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("RIPEMD160"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
byte[] digestBytes = digest.toBytes(); | |||||
HashDigest resolvedDigest = hashFunction.resolveHashDigest(digestBytes); | |||||
assertEquals(160 / 8, resolvedDigest.getRawDigest().length); | |||||
assertEquals(ClassicAlgorithm.RIPEMD160, resolvedDigest.getAlgorithm()); | |||||
assertEquals((short) (HASH_ALGORITHM | ((byte) 25 & 0x00FF)), resolvedDigest.getAlgorithm()); | |||||
assertArrayEquals(digestBytes, resolvedDigest.toBytes()); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] rawDigestBytes = digest.getRawDigest(); | |||||
byte[] aesDigestBytes = BytesUtils.concat(algoBytes, rawDigestBytes); | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
hashFunction.resolveHashDigest(aesDigestBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sha256"); | |||||
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())); | |||||
} | |||||
} | } |
@@ -5,6 +5,7 @@ import com.jd.blockchain.crypto.CryptoException; | |||||
import com.jd.blockchain.crypto.CryptoServiceProviders; | import com.jd.blockchain.crypto.CryptoServiceProviders; | ||||
import com.jd.blockchain.crypto.HashDigest; | import com.jd.blockchain.crypto.HashDigest; | ||||
import com.jd.blockchain.crypto.HashFunction; | import com.jd.blockchain.crypto.HashFunction; | ||||
import com.jd.blockchain.crypto.service.classic.ClassicAlgorithm; | |||||
import com.jd.blockchain.utils.io.BytesUtils; | import com.jd.blockchain.utils.io.BytesUtils; | ||||
import org.junit.Test; | import org.junit.Test; | ||||
@@ -22,152 +23,151 @@ import static org.junit.Assert.*; | |||||
public class SHA256HashFunctionTest { | public class SHA256HashFunctionTest { | ||||
@Test | |||||
public void getAlgorithmTest(){ | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sha256"); | |||||
assertNotNull(algorithm); | |||||
@Test | |||||
public void getAlgorithmTest() { | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sha256"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
assertEquals(hashFunction.getAlgorithm().name(), algorithm.name()); | |||||
assertEquals(hashFunction.getAlgorithm().code(), algorithm.code()); | |||||
assertEquals(hashFunction.getAlgorithm().name(), algorithm.name()); | |||||
assertEquals(hashFunction.getAlgorithm().code(), algorithm.code()); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("SHa256"); | |||||
assertNotNull(algorithm); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("SHa256"); | |||||
assertNotNull(algorithm); | |||||
assertEquals(hashFunction.getAlgorithm().name(), algorithm.name()); | |||||
assertEquals(hashFunction.getAlgorithm().code(), algorithm.code()); | |||||
assertEquals(hashFunction.getAlgorithm().name(), algorithm.name()); | |||||
assertEquals(hashFunction.getAlgorithm().code(), algorithm.code()); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sha-256"); | |||||
assertNull(algorithm); | |||||
} | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sha-256"); | |||||
assertNull(algorithm); | |||||
} | |||||
@Test | |||||
public void hashTest(){ | |||||
@Test | |||||
public void hashTest() { | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sha256"); | |||||
assertNotNull(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sha256"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
byte[] rawDigestBytes = digest.getRawDigest(); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
byte[] rawDigestBytes = digest.getRawDigest(); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] digestBytes = digest.toBytes(); | |||||
assertEquals(256 / 8 + 2,digestBytes.length); | |||||
assertArrayEquals(digestBytes, BytesUtils.concat(algoBytes, rawDigestBytes)); | |||||
byte[] digestBytes = digest.toBytes(); | |||||
assertEquals(256 / 8 + 2, digestBytes.length); | |||||
assertArrayEquals(digestBytes, BytesUtils.concat(algoBytes, rawDigestBytes)); | |||||
assertEquals(algorithm.code(),digest.getAlgorithm().code()); | |||||
assertEquals(algorithm.name(),digest.getAlgorithm().name()); | |||||
assertEquals(algorithm.code(), digest.getAlgorithm()); | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
data = null; | |||||
hashFunction.hash(data); | |||||
} catch (Exception e) { | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
data = null; | |||||
hashFunction.hash(data); | |||||
} catch (Exception e) { | |||||
actualEx = e; | actualEx = e; | ||||
} | } | ||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
@Test | |||||
public void verifyTest(){ | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sha256"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
assertTrue(hashFunction.verify(digest,data)); | |||||
} | |||||
@Test | |||||
public void supportHashDigestTest(){ | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sha256"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
byte[] digestBytes = digest.toBytes(); | |||||
assertTrue(hashFunction.supportHashDigest(digestBytes)); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
System.arraycopy(algoBytes,0,digestBytes,0,algoBytes.length); | |||||
assertFalse(hashFunction.supportHashDigest(digestBytes)); | |||||
} | |||||
@Test | |||||
public void resolveHashDigestTest(){ | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sha256"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
byte[] digestBytes = digest.toBytes(); | |||||
HashDigest resolvedDigest = hashFunction.resolveHashDigest(digestBytes); | |||||
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); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] rawDigestBytes = digest.getRawDigest(); | |||||
byte[] aesDigestBytes = BytesUtils.concat(algoBytes,rawDigestBytes); | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
hashFunction.resolveHashDigest(aesDigestBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
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())); | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
@Test | |||||
public void verifyTest() { | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sha256"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
assertTrue(hashFunction.verify(digest, data)); | |||||
} | |||||
@Test | |||||
public void supportHashDigestTest() { | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sha256"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
byte[] digestBytes = digest.toBytes(); | |||||
assertTrue(hashFunction.supportHashDigest(digestBytes)); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
System.arraycopy(algoBytes, 0, digestBytes, 0, algoBytes.length); | |||||
assertFalse(hashFunction.supportHashDigest(digestBytes)); | |||||
} | |||||
@Test | |||||
public void resolveHashDigestTest() { | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sha256"); | |||||
assertNotNull(algorithm); | |||||
HashFunction hashFunction = CryptoServiceProviders.getHashFunction(algorithm); | |||||
HashDigest digest = hashFunction.hash(data); | |||||
byte[] digestBytes = digest.toBytes(); | |||||
HashDigest resolvedDigest = hashFunction.resolveHashDigest(digestBytes); | |||||
assertEquals(256 / 8, resolvedDigest.getRawDigest().length); | |||||
assertEquals(ClassicAlgorithm.SHA256, resolvedDigest.getAlgorithm()); | |||||
assertEquals((short) (HASH_ALGORITHM | ((byte) 24 & 0x00FF)), resolvedDigest.getAlgorithm()); | |||||
assertArrayEquals(digestBytes, resolvedDigest.toBytes()); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("aes"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] rawDigestBytes = digest.getRawDigest(); | |||||
byte[] aesDigestBytes = BytesUtils.concat(algoBytes, rawDigestBytes); | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
hashFunction.resolveHashDigest(aesDigestBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
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())); | |||||
} | |||||
} | } |
@@ -55,7 +55,7 @@ public class AddressEncoding { | |||||
public static Bytes generateAddress(PubKey pubKey) { | public static Bytes generateAddress(PubKey pubKey) { | ||||
byte[] h1Bytes = ShaUtils.hash_256(pubKey.getRawKeyBytes()); | byte[] h1Bytes = ShaUtils.hash_256(pubKey.getRawKeyBytes()); | ||||
byte[] h2Bytes = RipeMD160Utils.hash(h1Bytes); | byte[] h2Bytes = RipeMD160Utils.hash(h1Bytes); | ||||
byte[] xBytes = BytesUtils.concat(new byte[] { AddressVersion.V1.CODE}, CryptoAlgorithm.toBytes(pubKey.getAlgorithm()), h2Bytes); | |||||
byte[] xBytes = BytesUtils.concat(new byte[] { AddressVersion.V1.CODE}, BytesUtils.toBytes(pubKey.getAlgorithm()), h2Bytes); | |||||
byte[] checksum = Arrays.copyOf(ShaUtils.hash_256(ShaUtils.hash_256(xBytes)), 4); | byte[] checksum = Arrays.copyOf(ShaUtils.hash_256(ShaUtils.hash_256(xBytes)), 4); | ||||
byte[] addressBytes = BytesUtils.concat(xBytes, checksum); | byte[] addressBytes = BytesUtils.concat(xBytes, checksum); | ||||
@@ -11,7 +11,7 @@ public class AsymmetricCiphertext extends BaseCryptoBytes implements Ciphertext | |||||
} | } | ||||
@Override | @Override | ||||
protected boolean support(CryptoAlgorithm algorithm) { | |||||
protected boolean support(short algorithm) { | |||||
return CryptoAlgorithm.isAsymmetricEncryptionAlgorithm(algorithm); | return CryptoAlgorithm.isAsymmetricEncryptionAlgorithm(algorithm); | ||||
} | } | ||||
@@ -8,47 +8,60 @@ import com.jd.blockchain.utils.io.BytesUtils; | |||||
public abstract class BaseCryptoBytes extends Bytes implements CryptoBytes { | public abstract class BaseCryptoBytes extends Bytes implements CryptoBytes { | ||||
private CryptoAlgorithm algorithm; | |||||
private short algorithm; | |||||
public BaseCryptoBytes() { | public BaseCryptoBytes() { | ||||
super(); | super(); | ||||
} | } | ||||
public BaseCryptoBytes(short algorithm, byte[] rawCryptoBytes) { | |||||
super(encodeBytes(algorithm, rawCryptoBytes)); | |||||
this.algorithm = algorithm; | |||||
} | |||||
public BaseCryptoBytes(CryptoAlgorithm algorithm, byte[] rawCryptoBytes) { | public BaseCryptoBytes(CryptoAlgorithm algorithm, byte[] rawCryptoBytes) { | ||||
super(encodeBytes(algorithm, rawCryptoBytes)); | super(encodeBytes(algorithm, rawCryptoBytes)); | ||||
this.algorithm = algorithm; | |||||
this.algorithm = algorithm.code(); | |||||
} | } | ||||
public BaseCryptoBytes(byte[] cryptoBytes) { | public BaseCryptoBytes(byte[] cryptoBytes) { | ||||
super(cryptoBytes); | super(cryptoBytes); | ||||
CryptoAlgorithm algorithm = decodeAlgorithm(cryptoBytes); | |||||
short algorithm = decodeAlgorithm(cryptoBytes); | |||||
if (!support(algorithm)) { | if (!support(algorithm)) { | ||||
throw new CryptoException("Not supported algorithm[" + algorithm.toString() + "]!"); | |||||
throw new CryptoException("Not supported algorithm [code:" + algorithm + "]!"); | |||||
} | } | ||||
this.algorithm = algorithm; | this.algorithm = algorithm; | ||||
} | } | ||||
static byte[] encodeBytes(short algorithm, byte[] rawCryptoBytes) { | |||||
return BytesUtils.concat(BytesUtils.toBytes(algorithm), rawCryptoBytes); | |||||
} | |||||
static byte[] encodeBytes(CryptoAlgorithm algorithm, byte[] rawCryptoBytes) { | static byte[] encodeBytes(CryptoAlgorithm algorithm, byte[] rawCryptoBytes) { | ||||
return BytesUtils.concat(CryptoAlgorithm.toBytes(algorithm), rawCryptoBytes); | return BytesUtils.concat(CryptoAlgorithm.toBytes(algorithm), rawCryptoBytes); | ||||
} | } | ||||
static CryptoAlgorithm decodeAlgorithm(byte[] cryptoBytes) { | |||||
short algorithmCode = BytesUtils.toShort(cryptoBytes, 0); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm(algorithmCode); | |||||
if (algorithm == null) { | |||||
throw new CryptoException("The algorithm with code[" + algorithmCode + "] is not supported!"); | |||||
} | |||||
return algorithm; | |||||
static short decodeAlgorithm(byte[] cryptoBytes) { | |||||
return CryptoAlgorithm.resolveCode(cryptoBytes); | |||||
} | } | ||||
protected abstract boolean support(CryptoAlgorithm algorithm); | |||||
// static CryptoAlgorithm decodeAlgorithm(byte[] cryptoBytes) { | |||||
// short algorithmCode = BytesUtils.toShort(cryptoBytes, 0); | |||||
// CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm(algorithmCode); | |||||
// if (algorithm == null) { | |||||
// throw new CryptoException("The algorithm with code[" + algorithmCode + "] is not supported!"); | |||||
// } | |||||
// return algorithm; | |||||
// } | |||||
protected abstract boolean support(short algorithm); | |||||
protected byte[] resolveRawCryptoBytes(byte[] cryptoBytes) { | protected byte[] resolveRawCryptoBytes(byte[] cryptoBytes) { | ||||
return Arrays.copyOfRange(cryptoBytes, 1, cryptoBytes.length); | return Arrays.copyOfRange(cryptoBytes, 1, cryptoBytes.length); | ||||
} | } | ||||
@Override | @Override | ||||
public CryptoAlgorithm getAlgorithm() { | |||||
public short getAlgorithm() { | |||||
return algorithm; | return algorithm; | ||||
} | } | ||||
@@ -13,6 +13,10 @@ public abstract class BaseCryptoKey extends BaseCryptoBytes implements CryptoKey | |||||
// public BaseCryptoKey() { | // public BaseCryptoKey() { | ||||
// super(); | // super(); | ||||
// } | // } | ||||
protected BaseCryptoKey(short algorithm, byte[] rawKeyBytes, CryptoKeyType keyType) { | |||||
super(algorithm, encodeKeyBytes(rawKeyBytes, keyType)); | |||||
} | |||||
protected BaseCryptoKey(CryptoAlgorithm algorithm, byte[] rawKeyBytes, CryptoKeyType keyType) { | protected BaseCryptoKey(CryptoAlgorithm algorithm, byte[] rawKeyBytes, CryptoKeyType keyType) { | ||||
super(algorithm, encodeKeyBytes(rawKeyBytes, keyType)); | super(algorithm, encodeKeyBytes(rawKeyBytes, keyType)); | ||||
@@ -35,7 +39,7 @@ public abstract class BaseCryptoKey extends BaseCryptoBytes implements CryptoKey | |||||
} | } | ||||
@Override | @Override | ||||
protected boolean support(CryptoAlgorithm algorithm) { | |||||
protected boolean support(short algorithm) { | |||||
return CryptoAlgorithm.hasAsymmetricKey(algorithm) || CryptoAlgorithm.hasSymmetricKey(algorithm); | return CryptoAlgorithm.hasAsymmetricKey(algorithm) || CryptoAlgorithm.hasSymmetricKey(algorithm); | ||||
} | } | ||||
@@ -1,5 +1,8 @@ | |||||
package com.jd.blockchain.crypto; | package com.jd.blockchain.crypto; | ||||
import java.io.InputStream; | |||||
import java.io.OutputStream; | |||||
import com.jd.blockchain.binaryproto.DataContract; | import com.jd.blockchain.binaryproto.DataContract; | ||||
import com.jd.blockchain.binaryproto.DataField; | import com.jd.blockchain.binaryproto.DataField; | ||||
import com.jd.blockchain.consts.TypeCodes; | import com.jd.blockchain.consts.TypeCodes; | ||||
@@ -90,6 +93,14 @@ public interface CryptoAlgorithm { | |||||
return BytesUtils.toShort(algorithmBytes, offset); | return BytesUtils.toShort(algorithmBytes, offset); | ||||
} | } | ||||
static short resolveCode(InputStream in) { | |||||
return BytesUtils.readShort(in); | |||||
} | |||||
static int writeCode(short code, OutputStream out) { | |||||
return BytesUtils.writeShort(code, out); | |||||
} | |||||
static boolean match(CryptoAlgorithm algorithm, byte[] algorithmBytes) { | static boolean match(CryptoAlgorithm algorithm, byte[] algorithmBytes) { | ||||
return algorithm.code() == BytesUtils.toShort(algorithmBytes, 0); | return algorithm.code() == BytesUtils.toShort(algorithmBytes, 0); | ||||
} | } | ||||
@@ -116,6 +127,24 @@ public interface CryptoAlgorithm { | |||||
return HASH_ALGORITHM == (algorithm.code() & HASH_ALGORITHM); | return HASH_ALGORITHM == (algorithm.code() & HASH_ALGORITHM); | ||||
} | } | ||||
/** | |||||
* 是否属于摘要算法; | |||||
* | |||||
* @return | |||||
*/ | |||||
static boolean isHashAlgorithm(short algorithm) { | |||||
return HASH_ALGORITHM == (algorithm & HASH_ALGORITHM); | |||||
} | |||||
/** | |||||
* 是否属于签名算法; | |||||
* | |||||
* @return | |||||
*/ | |||||
static boolean isSignatureAlgorithm(short algorithm) { | |||||
return SIGNATURE_ALGORITHM == (algorithm & SIGNATURE_ALGORITHM); | |||||
} | |||||
/** | /** | ||||
* 是否属于签名算法; | * 是否属于签名算法; | ||||
* | * | ||||
@@ -125,6 +154,15 @@ public interface CryptoAlgorithm { | |||||
return SIGNATURE_ALGORITHM == (algorithm.code() & SIGNATURE_ALGORITHM); | return SIGNATURE_ALGORITHM == (algorithm.code() & SIGNATURE_ALGORITHM); | ||||
} | } | ||||
/** | |||||
* 是否属于加密算法; | |||||
* | |||||
* @return | |||||
*/ | |||||
static boolean isEncryptionAlgorithm(short algorithm) { | |||||
return ENCRYPTION_ALGORITHM == (algorithm & ENCRYPTION_ALGORITHM); | |||||
} | |||||
/** | /** | ||||
* 是否属于加密算法; | * 是否属于加密算法; | ||||
* | * | ||||
@@ -143,6 +181,15 @@ public interface CryptoAlgorithm { | |||||
return EXT_ALGORITHM == (algorithm.code() & 0xF000); | return EXT_ALGORITHM == (algorithm.code() & 0xF000); | ||||
} | } | ||||
/** | |||||
* 算法是否包含非对称密钥; | |||||
* | |||||
* @return | |||||
*/ | |||||
static boolean hasAsymmetricKey(short algorithm) { | |||||
return ASYMMETRIC_KEY == (algorithm & ASYMMETRIC_KEY); | |||||
} | |||||
/** | /** | ||||
* 算法是否包含非对称密钥; | * 算法是否包含非对称密钥; | ||||
* | * | ||||
@@ -152,6 +199,15 @@ public interface CryptoAlgorithm { | |||||
return ASYMMETRIC_KEY == (algorithm.code() & ASYMMETRIC_KEY); | return ASYMMETRIC_KEY == (algorithm.code() & ASYMMETRIC_KEY); | ||||
} | } | ||||
/** | |||||
* 算法是否包含对称密钥; | |||||
* | |||||
* @return | |||||
*/ | |||||
static boolean hasSymmetricKey(short algorithm) { | |||||
return SYMMETRIC_KEY == (algorithm & SYMMETRIC_KEY); | |||||
} | |||||
/** | /** | ||||
* 算法是否包含对称密钥; | * 算法是否包含对称密钥; | ||||
* | * | ||||
@@ -171,6 +227,16 @@ public interface CryptoAlgorithm { | |||||
return isEncryptionAlgorithm(algorithm) && hasSymmetricKey(algorithm); | return isEncryptionAlgorithm(algorithm) && hasSymmetricKey(algorithm); | ||||
} | } | ||||
/** | |||||
* 是否属于非对称加密算法; | |||||
* | |||||
* @param algorithm | |||||
* @return | |||||
*/ | |||||
static boolean isAsymmetricEncryptionAlgorithm(short algorithm) { | |||||
return isEncryptionAlgorithm(algorithm) && hasAsymmetricKey(algorithm); | |||||
} | |||||
/** | /** | ||||
* 是否属于非对称加密算法; | * 是否属于非对称加密算法; | ||||
* | * | ||||
@@ -20,7 +20,7 @@ public interface CryptoBytes extends BytesSerializable { | |||||
* | * | ||||
* @return | * @return | ||||
*/ | */ | ||||
CryptoAlgorithm getAlgorithm(); | |||||
short getAlgorithm(); | |||||
/** | /** | ||||
* 返回编码后的摘要信息;<br> | * 返回编码后的摘要信息;<br> | ||||
@@ -6,7 +6,7 @@ public class CryptoKeyPair { | |||||
private PrivKey privKey; | private PrivKey privKey; | ||||
public CryptoAlgorithm getAlgorithm() { | |||||
public short getAlgorithm() { | |||||
return pubKey.getAlgorithm(); | return pubKey.getAlgorithm(); | ||||
} | } | ||||
@@ -19,7 +19,7 @@ public class CryptoKeyPair { | |||||
} | } | ||||
public CryptoKeyPair(PubKey pubKey, PrivKey privKey) { | public CryptoKeyPair(PubKey pubKey, PrivKey privKey) { | ||||
if (!CryptoAlgorithm.equals(pubKey.getAlgorithm(), privKey.getAlgorithm())) { | |||||
if (pubKey.getAlgorithm() != privKey.getAlgorithm()) { | |||||
throw new IllegalArgumentException("The algorithms of PubKey and PrivKey don't match!"); | throw new IllegalArgumentException("The algorithms of PubKey and PrivKey don't match!"); | ||||
} | } | ||||
this.pubKey = pubKey; | this.pubKey = pubKey; | ||||
@@ -19,7 +19,7 @@ public class HashDigest extends BaseCryptoBytes implements CryptoDigest,Serializ | |||||
} | } | ||||
@Override | @Override | ||||
protected boolean support(CryptoAlgorithm algorithm) { | |||||
protected boolean support(short algorithm) { | |||||
return CryptoAlgorithm.isHashAlgorithm(algorithm); | return CryptoAlgorithm.isHashAlgorithm(algorithm); | ||||
} | } | ||||
@@ -8,6 +8,10 @@ package com.jd.blockchain.crypto; | |||||
*/ | */ | ||||
public class PrivKey extends BaseCryptoKey { | public class PrivKey extends BaseCryptoKey { | ||||
private static final long serialVersionUID = 6265440395252295646L; | private static final long serialVersionUID = 6265440395252295646L; | ||||
public PrivKey(short algorithm, byte[] rawCryptoBytes) { | |||||
super(algorithm, rawCryptoBytes, CryptoKeyType.PRIVATE); | |||||
} | |||||
public PrivKey(CryptoAlgorithm algorithm, byte[] rawCryptoBytes) { | public PrivKey(CryptoAlgorithm algorithm, byte[] rawCryptoBytes) { | ||||
super(algorithm, rawCryptoBytes, CryptoKeyType.PRIVATE); | super(algorithm, rawCryptoBytes, CryptoKeyType.PRIVATE); | ||||
@@ -9,6 +9,10 @@ package com.jd.blockchain.crypto; | |||||
public class PubKey extends BaseCryptoKey { | public class PubKey extends BaseCryptoKey { | ||||
private static final long serialVersionUID = -2055071197736385328L; | private static final long serialVersionUID = -2055071197736385328L; | ||||
public PubKey(short algorithm, byte[] rawCryptoBytes) { | |||||
super(algorithm, rawCryptoBytes, CryptoKeyType.PUBLIC); | |||||
} | |||||
public PubKey(CryptoAlgorithm algorithm, byte[] rawCryptoBytes) { | public PubKey(CryptoAlgorithm algorithm, byte[] rawCryptoBytes) { | ||||
super(algorithm, rawCryptoBytes, CryptoKeyType.PUBLIC); | super(algorithm, rawCryptoBytes, CryptoKeyType.PUBLIC); | ||||
@@ -14,7 +14,7 @@ public class SignatureDigest extends BaseCryptoBytes implements CryptoDigest { | |||||
} | } | ||||
@Override | @Override | ||||
protected boolean support(CryptoAlgorithm algorithm) { | |||||
protected boolean support(short algorithm) { | |||||
return CryptoAlgorithm.isSignatureAlgorithm(algorithm); | return CryptoAlgorithm.isSignatureAlgorithm(algorithm); | ||||
} | } | ||||
@@ -11,7 +11,7 @@ public class SymmetricCiphertext extends BaseCryptoBytes implements Ciphertext { | |||||
} | } | ||||
@Override | @Override | ||||
protected boolean support(CryptoAlgorithm algorithm) { | |||||
protected boolean support(short algorithm) { | |||||
return CryptoAlgorithm.isEncryptionAlgorithm(algorithm) && CryptoAlgorithm.hasSymmetricKey(algorithm); | return CryptoAlgorithm.isEncryptionAlgorithm(algorithm) && CryptoAlgorithm.hasSymmetricKey(algorithm); | ||||
} | } | ||||
@@ -1,5 +1,7 @@ | |||||
package com.jd.blockchain.crypto.serialize; | package com.jd.blockchain.crypto.serialize; | ||||
import java.lang.reflect.Type; | |||||
import com.alibaba.fastjson.serializer.JSONSerializer; | import com.alibaba.fastjson.serializer.JSONSerializer; | ||||
import com.alibaba.fastjson.serializer.ObjectSerializer; | import com.alibaba.fastjson.serializer.ObjectSerializer; | ||||
import com.jd.blockchain.crypto.HashDigest; | import com.jd.blockchain.crypto.HashDigest; | ||||
@@ -8,9 +10,6 @@ import com.jd.blockchain.crypto.SignatureDigest; | |||||
import com.jd.blockchain.utils.Bytes; | import com.jd.blockchain.utils.Bytes; | ||||
import com.jd.blockchain.utils.io.BytesSlice; | import com.jd.blockchain.utils.io.BytesSlice; | ||||
import java.io.IOException; | |||||
import java.lang.reflect.Type; | |||||
public class ByteArrayObjectSerializer implements ObjectSerializer { | public class ByteArrayObjectSerializer implements ObjectSerializer { | ||||
private Class<?> clazz; | private Class<?> clazz; | ||||
@@ -51,11 +50,13 @@ public class ByteArrayObjectSerializer implements ObjectSerializer { | |||||
this.value = value; | this.value = value; | ||||
} | } | ||||
public String getValue() { | |||||
@SuppressWarnings("unused") | |||||
public String getValue() { | |||||
return value; | return value; | ||||
} | } | ||||
public void setValue(String value) { | |||||
@SuppressWarnings("unused") | |||||
public void setValue(String value) { | |||||
this.value = value; | this.value = value; | ||||
} | } | ||||
} | } | ||||
@@ -5,16 +5,25 @@ import static com.jd.blockchain.crypto.CryptoBytes.ALGORYTHM_CODE_SIZE; | |||||
import static com.jd.blockchain.crypto.CryptoKeyType.PRIVATE; | import static com.jd.blockchain.crypto.CryptoKeyType.PRIVATE; | ||||
import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; | import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; | ||||
import com.jd.blockchain.crypto.*; | |||||
import org.bouncycastle.crypto.AsymmetricCipherKeyPair; | import org.bouncycastle.crypto.AsymmetricCipherKeyPair; | ||||
import org.bouncycastle.crypto.params.ECPrivateKeyParameters; | import org.bouncycastle.crypto.params.ECPrivateKeyParameters; | ||||
import org.bouncycastle.crypto.params.ECPublicKeyParameters; | import org.bouncycastle.crypto.params.ECPublicKeyParameters; | ||||
import com.jd.blockchain.crypto.AsymmetricCiphertext; | |||||
import com.jd.blockchain.crypto.AsymmetricEncryptionFunction; | |||||
import com.jd.blockchain.crypto.Ciphertext; | |||||
import com.jd.blockchain.crypto.CryptoAlgorithm; | |||||
import com.jd.blockchain.crypto.CryptoException; | |||||
import com.jd.blockchain.crypto.CryptoKeyPair; | |||||
import com.jd.blockchain.crypto.PrivKey; | |||||
import com.jd.blockchain.crypto.PubKey; | |||||
import com.jd.blockchain.crypto.SignatureDigest; | |||||
import com.jd.blockchain.crypto.SignatureFunction; | |||||
import com.jd.blockchain.crypto.utils.sm.SM2Utils; | import com.jd.blockchain.crypto.utils.sm.SM2Utils; | ||||
public class SM2CryptoFunction implements AsymmetricEncryptionFunction, SignatureFunction { | public class SM2CryptoFunction implements AsymmetricEncryptionFunction, SignatureFunction { | ||||
private static final CryptoAlgorithm SM2 = SMCryptoService.SM2_ALGORITHM; | |||||
private static final CryptoAlgorithm SM2 = SMAlgorithm.SM2; | |||||
private static final int ECPOINT_SIZE = 65; | private static final int ECPOINT_SIZE = 65; | ||||
private static final int PRIVKEY_SIZE = 32; | private static final int PRIVKEY_SIZE = 32; | ||||
@@ -39,7 +48,7 @@ public class SM2CryptoFunction implements AsymmetricEncryptionFunction, Signatur | |||||
} | } | ||||
// 验证密钥数据的算法标识对应SM2算法 | // 验证密钥数据的算法标识对应SM2算法 | ||||
if (pubKey.getAlgorithm().code() != SM2.code()) { | |||||
if (pubKey.getAlgorithm() != SM2.code()) { | |||||
throw new CryptoException("The is not sm2 public key!"); | throw new CryptoException("The is not sm2 public key!"); | ||||
} | } | ||||
@@ -59,12 +68,12 @@ public class SM2CryptoFunction implements AsymmetricEncryptionFunction, Signatur | |||||
} | } | ||||
// 验证密钥数据的算法标识对应SM2算法 | // 验证密钥数据的算法标识对应SM2算法 | ||||
if (privKey.getAlgorithm().code() != SM2.code()) { | |||||
if (privKey.getAlgorithm() != SM2.code()) { | |||||
throw new CryptoException("This key is not SM2 private key!"); | throw new CryptoException("This key is not SM2 private key!"); | ||||
} | } | ||||
// 验证密文数据的算法标识对应SM2签名算法,并且原始摘要长度为64字节 | // 验证密文数据的算法标识对应SM2签名算法,并且原始摘要长度为64字节 | ||||
if (ciphertext.getAlgorithm().code() != SM2.code() | |||||
if (ciphertext.getAlgorithm() != SM2.code() | |||||
|| rawCiphertextBytes.length < ECPOINT_SIZE + HASHDIGEST_SIZE) { | || rawCiphertextBytes.length < ECPOINT_SIZE + HASHDIGEST_SIZE) { | ||||
throw new CryptoException("This is not SM2 ciphertext!"); | throw new CryptoException("This is not SM2 ciphertext!"); | ||||
} | } | ||||
@@ -147,7 +156,7 @@ public class SM2CryptoFunction implements AsymmetricEncryptionFunction, Signatur | |||||
} | } | ||||
// 验证密钥数据的算法标识对应SM2签名算法 | // 验证密钥数据的算法标识对应SM2签名算法 | ||||
if (privKey.getAlgorithm().code() != SM2.code()) { | |||||
if (privKey.getAlgorithm() != SM2.code()) { | |||||
throw new CryptoException("This key is not SM2 private key!"); | throw new CryptoException("This key is not SM2 private key!"); | ||||
} | } | ||||
@@ -167,12 +176,12 @@ public class SM2CryptoFunction implements AsymmetricEncryptionFunction, Signatur | |||||
} | } | ||||
// 验证密钥数据的算法标识对应SM2签名算法 | // 验证密钥数据的算法标识对应SM2签名算法 | ||||
if (pubKey.getAlgorithm().code() != SM2.code()) { | |||||
if (pubKey.getAlgorithm() != SM2.code()) { | |||||
throw new CryptoException("This key is not SM2 public key!"); | throw new CryptoException("This key is not SM2 public key!"); | ||||
} | } | ||||
// 验证签名数据的算法标识对应SM2签名算法,并且原始签名长度为64字节 | // 验证签名数据的算法标识对应SM2签名算法,并且原始签名长度为64字节 | ||||
if (digest.getAlgorithm().code() != SM2.code() || rawDigestBytes.length != SIGNATUREDIGEST_SIZE) { | |||||
if (digest.getAlgorithm() != SM2.code() || rawDigestBytes.length != SIGNATUREDIGEST_SIZE) { | |||||
throw new CryptoException("This is not SM2 signature digest!"); | throw new CryptoException("This is not SM2 signature digest!"); | ||||
} | } | ||||
@@ -11,7 +11,7 @@ import com.jd.blockchain.crypto.utils.sm.SM3Utils; | |||||
public class SM3HashFunction implements HashFunction { | public class SM3HashFunction implements HashFunction { | ||||
private static final CryptoAlgorithm SM3 = SMCryptoService.SM3_ALGORITHM; | |||||
private static final CryptoAlgorithm SM3 = SMAlgorithm.SM3; | |||||
private static final int DIGEST_BYTES = 256 / 8; | private static final int DIGEST_BYTES = 256 / 8; | ||||
@@ -13,7 +13,7 @@ import com.jd.blockchain.crypto.utils.sm.SM4Utils; | |||||
public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | ||||
private static final CryptoAlgorithm SM4 = SMCryptoService.SM4_ALGORITHM; | |||||
private static final CryptoAlgorithm SM4 = SMAlgorithm.SM4; | |||||
private static final int KEY_SIZE = 128 / 8; | private static final int KEY_SIZE = 128 / 8; | ||||
private static final int BLOCK_SIZE = 128 / 8; | private static final int BLOCK_SIZE = 128 / 8; | ||||
@@ -38,7 +38,7 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | |||||
} | } | ||||
// 验证密钥数据的算法标识对应SM4算法 | // 验证密钥数据的算法标识对应SM4算法 | ||||
if (key.getAlgorithm().code() != SM4.code()) { | |||||
if (key.getAlgorithm() != SM4.code()) { | |||||
throw new CryptoException("The is not SM4 symmetric key!"); | throw new CryptoException("The is not SM4 symmetric key!"); | ||||
} | } | ||||
@@ -53,7 +53,8 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | |||||
try { | try { | ||||
byte[] buffBytes = new byte[PLAINTEXT_BUFFER_LENGTH]; | byte[] buffBytes = new byte[PLAINTEXT_BUFFER_LENGTH]; | ||||
// The final byte of plaintextWithPadding represents the length of padding in the first 256 bytes, | |||||
// The final byte of plaintextWithPadding represents the length of padding in | |||||
// the first 256 bytes, | |||||
// and the padded value in hexadecimal | // and the padded value in hexadecimal | ||||
byte[] plaintextWithPadding = new byte[buffBytes.length + 1]; | byte[] plaintextWithPadding = new byte[buffBytes.length + 1]; | ||||
@@ -62,21 +63,21 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | |||||
int len; | int len; | ||||
int i; | int i; | ||||
while((len=in.read(buffBytes)) > 0) { | |||||
while ((len = in.read(buffBytes)) > 0) { | |||||
padding = (byte) (PLAINTEXT_BUFFER_LENGTH - len); | padding = (byte) (PLAINTEXT_BUFFER_LENGTH - len); | ||||
i = len; | i = len; | ||||
while (i < plaintextWithPadding.length) { | while (i < plaintextWithPadding.length) { | ||||
plaintextWithPadding[i] = padding; | plaintextWithPadding[i] = padding; | ||||
i++; | i++; | ||||
} | } | ||||
out.write(encrypt(key,plaintextWithPadding).toBytes()); | |||||
out.write(encrypt(key, plaintextWithPadding).toBytes()); | |||||
} | } | ||||
// byte[] sm4Data = new byte[in.available()]; | |||||
// in.read(sm4Data); | |||||
// in.close(); | |||||
// | |||||
// out.write(encrypt(key, sm4Data).toBytes()); | |||||
// out.close(); | |||||
// byte[] sm4Data = new byte[in.available()]; | |||||
// in.read(sm4Data); | |||||
// in.close(); | |||||
// | |||||
// out.write(encrypt(key, sm4Data).toBytes()); | |||||
// out.close(); | |||||
} catch (IOException e) { | } catch (IOException e) { | ||||
throw new CryptoException(e.getMessage(), e); | throw new CryptoException(e.getMessage(), e); | ||||
} | } | ||||
@@ -94,7 +95,7 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | |||||
} | } | ||||
// 验证密钥数据的算法标识对应SM4算法 | // 验证密钥数据的算法标识对应SM4算法 | ||||
if (key.getAlgorithm().code() != SM4.code()) { | |||||
if (key.getAlgorithm() != SM4.code()) { | |||||
throw new CryptoException("The is not SM4 symmetric key!"); | throw new CryptoException("The is not SM4 symmetric key!"); | ||||
} | } | ||||
@@ -104,7 +105,7 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | |||||
} | } | ||||
// 验证密文数据算法标识对应SM4算法 | // 验证密文数据算法标识对应SM4算法 | ||||
if (ciphertext.getAlgorithm().code() != SM4.code()) { | |||||
if (ciphertext.getAlgorithm() != SM4.code()) { | |||||
throw new CryptoException("This is not SM4 ciphertext!"); | throw new CryptoException("This is not SM4 ciphertext!"); | ||||
} | } | ||||
@@ -122,7 +123,7 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | |||||
byte padding; | byte padding; | ||||
byte[] plaintext; | byte[] plaintext; | ||||
int len,i; | |||||
int len, i; | |||||
while ((len = in.read(buffBytes)) > 0) { | while ((len = in.read(buffBytes)) > 0) { | ||||
if (len != CIPHERTEXT_BUFFER_LENGTH) { | if (len != CIPHERTEXT_BUFFER_LENGTH) { | ||||
throw new CryptoException("inputStream's length is wrong!"); | throw new CryptoException("inputStream's length is wrong!"); | ||||
@@ -131,7 +132,7 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | |||||
throw new CryptoException("InputStream is not valid SM4 ciphertext!"); | throw new CryptoException("InputStream is not valid SM4 ciphertext!"); | ||||
} | } | ||||
plaintextWithPadding = decrypt(key,resolveCiphertext(buffBytes)); | |||||
plaintextWithPadding = decrypt(key, resolveCiphertext(buffBytes)); | |||||
if (plaintextWithPadding.length != (PLAINTEXT_BUFFER_LENGTH + 1)) { | if (plaintextWithPadding.length != (PLAINTEXT_BUFFER_LENGTH + 1)) { | ||||
throw new CryptoException("The decrypted plaintext is invalid"); | throw new CryptoException("The decrypted plaintext is invalid"); | ||||
@@ -148,19 +149,19 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | |||||
i--; | i--; | ||||
} | } | ||||
plaintext = new byte[PLAINTEXT_BUFFER_LENGTH - padding]; | plaintext = new byte[PLAINTEXT_BUFFER_LENGTH - padding]; | ||||
System.arraycopy(plaintextWithPadding,0,plaintext,0,plaintext.length); | |||||
System.arraycopy(plaintextWithPadding, 0, plaintext, 0, plaintext.length); | |||||
out.write(plaintext); | out.write(plaintext); | ||||
} | } | ||||
// byte[] sm4Data = new byte[in.available()]; | |||||
// in.read(sm4Data); | |||||
// in.close(); | |||||
// | |||||
// if (!supportCiphertext(sm4Data)) { | |||||
// throw new CryptoException("InputStream is not valid SM4 ciphertext!"); | |||||
// } | |||||
// | |||||
// out.write(decrypt(key, resolveCiphertext(sm4Data))); | |||||
// out.close(); | |||||
// byte[] sm4Data = new byte[in.available()]; | |||||
// in.read(sm4Data); | |||||
// in.close(); | |||||
// | |||||
// if (!supportCiphertext(sm4Data)) { | |||||
// throw new CryptoException("InputStream is not valid SM4 ciphertext!"); | |||||
// } | |||||
// | |||||
// out.write(decrypt(key, resolveCiphertext(sm4Data))); | |||||
// out.close(); | |||||
} catch (IOException e) { | } catch (IOException e) { | ||||
throw new CryptoException(e.getMessage(), e); | throw new CryptoException(e.getMessage(), e); | ||||
} | } | ||||
@@ -0,0 +1,17 @@ | |||||
package com.jd.blockchain.crypto.service.sm; | |||||
import com.jd.blockchain.crypto.CryptoAlgorithm; | |||||
import com.jd.blockchain.crypto.CryptoAlgorithmDefinition; | |||||
public final class SMAlgorithm { | |||||
public static final CryptoAlgorithm SM2 = CryptoAlgorithmDefinition.defineSignature("SM2", true, (byte) 2); | |||||
public static final CryptoAlgorithm SM3 = CryptoAlgorithmDefinition.defineHash("SM3", (byte) 3); | |||||
public static final CryptoAlgorithm SM4 = CryptoAlgorithmDefinition.defineSymmetricEncryption("SM4", (byte) 4); | |||||
private SMAlgorithm() { | |||||
} | |||||
} |
@@ -5,8 +5,6 @@ import java.util.Collection; | |||||
import java.util.Collections; | import java.util.Collections; | ||||
import java.util.List; | import java.util.List; | ||||
import com.jd.blockchain.crypto.CryptoAlgorithm; | |||||
import com.jd.blockchain.crypto.CryptoAlgorithmDefinition; | |||||
import com.jd.blockchain.crypto.CryptoFunction; | import com.jd.blockchain.crypto.CryptoFunction; | ||||
import com.jd.blockchain.crypto.CryptoService; | import com.jd.blockchain.crypto.CryptoService; | ||||
import com.jd.blockchain.provider.NamedProvider; | import com.jd.blockchain.provider.NamedProvider; | ||||
@@ -20,14 +18,6 @@ import com.jd.blockchain.provider.NamedProvider; | |||||
@NamedProvider("SM-SOFTWARE") | @NamedProvider("SM-SOFTWARE") | ||||
public class SMCryptoService implements CryptoService { | public class SMCryptoService implements CryptoService { | ||||
public static final CryptoAlgorithm SM2_ALGORITHM = CryptoAlgorithmDefinition.defineSignature("SM2", | |||||
true, (byte) 2); | |||||
public static final CryptoAlgorithm SM3_ALGORITHM = CryptoAlgorithmDefinition.defineHash("SM3", (byte) 3); | |||||
public static final CryptoAlgorithm SM4_ALGORITHM = CryptoAlgorithmDefinition.defineSymmetricEncryption("SM4", | |||||
(byte) 4); | |||||
public static final SM2CryptoFunction SM2 = new SM2CryptoFunction(); | public static final SM2CryptoFunction SM2 = new SM2CryptoFunction(); | ||||
public static final SM3HashFunction SM3 = new SM3HashFunction(); | public static final SM3HashFunction SM3 = new SM3HashFunction(); | ||||
public static final SM4EncryptionFunction SM4 = new SM4EncryptionFunction(); | public static final SM4EncryptionFunction SM4 = new SM4EncryptionFunction(); | ||||
@@ -1,6 +1,7 @@ | |||||
package test.com.jd.blockchain.crypto.service.sm; | package test.com.jd.blockchain.crypto.service.sm; | ||||
import com.jd.blockchain.crypto.*; | import com.jd.blockchain.crypto.*; | ||||
import com.jd.blockchain.crypto.service.sm.SMAlgorithm; | |||||
import com.jd.blockchain.utils.io.BytesUtils; | import com.jd.blockchain.utils.io.BytesUtils; | ||||
import org.junit.Test; | import org.junit.Test; | ||||
@@ -19,479 +20,469 @@ import static org.junit.Assert.*; | |||||
*/ | */ | ||||
public class SM2CyptoFunctionTest { | public class SM2CyptoFunctionTest { | ||||
@Test | |||||
public void getAlgorithmTest(){ | |||||
@Test | |||||
public void getAlgorithmTest() { | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
assertEquals(signatureFunction.getAlgorithm().name(), algorithm.name()); | |||||
assertEquals(signatureFunction.getAlgorithm().code(), algorithm.code()); | |||||
assertEquals(signatureFunction.getAlgorithm().name(), algorithm.name()); | |||||
assertEquals(signatureFunction.getAlgorithm().code(), algorithm.code()); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sM2"); | |||||
assertNotNull(algorithm); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sM2"); | |||||
assertNotNull(algorithm); | |||||
assertEquals(signatureFunction.getAlgorithm().name(), algorithm.name()); | |||||
assertEquals(signatureFunction.getAlgorithm().code(), algorithm.code()); | |||||
assertEquals(signatureFunction.getAlgorithm().name(), algorithm.name()); | |||||
assertEquals(signatureFunction.getAlgorithm().code(), algorithm.code()); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sm22"); | |||||
assertNull(algorithm); | |||||
} | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sm22"); | |||||
assertNull(algorithm); | |||||
} | |||||
@Test | |||||
public void generateKeyPairTest() { | |||||
@Test | |||||
public void generateKeyPairTest(){ | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
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(PUBLIC.CODE,pubKey.getKeyType().CODE); | |||||
assertEquals(65, pubKey.getRawKeyBytes().length); | |||||
assertEquals(PRIVATE.CODE,privKey.getKeyType().CODE); | |||||
assertEquals(32, privKey.getRawKeyBytes().length); | |||||
assertEquals(algorithm.code(), pubKey.getAlgorithm()); | |||||
assertEquals(algorithm.code(), privKey.getAlgorithm()); | |||||
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); | |||||
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()); | |||||
} | |||||
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() { | |||||
@Test | |||||
public void retrievePubKeyTest(){ | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
PubKey retrievedPubKey = signatureFunction.retrievePubKey(privKey); | |||||
PubKey retrievedPubKey = signatureFunction.retrievePubKey(privKey); | |||||
assertEquals(pubKey.getKeyType(), retrievedPubKey.getKeyType()); | |||||
assertEquals(pubKey.getRawKeyBytes().length, retrievedPubKey.getRawKeyBytes().length); | |||||
assertEquals(pubKey.getAlgorithm(), retrievedPubKey.getAlgorithm()); | |||||
assertArrayEquals(pubKey.toBytes(), retrievedPubKey.toBytes()); | |||||
} | |||||
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() { | |||||
@Test | |||||
public void signTest(){ | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
SignatureDigest signatureDigest = signatureFunction.sign(privKey, data); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
SignatureDigest signatureDigest = signatureFunction.sign(privKey,data); | |||||
byte[] signatureBytes = signatureDigest.toBytes(); | |||||
byte[] signatureBytes = signatureDigest.toBytes(); | |||||
assertEquals(2 + 64, signatureBytes.length); | |||||
assertEquals(algorithm.code(), signatureDigest.getAlgorithm()); | |||||
assertEquals(2 + 64, signatureBytes.length); | |||||
CryptoAlgorithm signatureAlgo = signatureDigest.getAlgorithm(); | |||||
assertEquals(algorithm.name(),signatureDigest.getAlgorithm().name()); | |||||
assertEquals(algorithm.code(),signatureDigest.getAlgorithm().code()); | |||||
assertEquals(SMAlgorithm.SM2, signatureDigest.getAlgorithm()); | |||||
assertEquals((short) (SIGNATURE_ALGORITHM | ENCRYPTION_ALGORITHM | ASYMMETRIC_KEY | ((byte) 2 & 0x00FF)), | |||||
signatureDigest.getAlgorithm()); | |||||
assertEquals("SM2",signatureAlgo.name()); | |||||
assertEquals((short) (SIGNATURE_ALGORITHM | ENCRYPTION_ALGORITHM | ASYMMETRIC_KEY | ((byte) 2 & 0x00FF)), | |||||
signatureAlgo.code()); | |||||
byte[] algoBytes = BytesUtils.toBytes(signatureDigest.getAlgorithm()); | |||||
byte[] rawSinatureBytes = signatureDigest.getRawDigest(); | |||||
assertArrayEquals(BytesUtils.concat(algoBytes, rawSinatureBytes), signatureBytes); | |||||
} | |||||
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); | |||||
@Test | |||||
public void verifyTest(){ | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
SignatureDigest signatureDigest = signatureFunction.sign(privKey, data); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
SignatureDigest signatureDigest = signatureFunction.sign(privKey,data); | |||||
assertTrue(signatureFunction.verify(signatureDigest, pubKey, data)); | |||||
} | |||||
assertTrue(signatureFunction.verify(signatureDigest,pubKey,data)); | |||||
} | |||||
@Test | |||||
public void encryptTest() { | |||||
@Test | |||||
public void encryptTest(){ | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
AsymmetricEncryptionFunction asymmetricEncryptionFunction = CryptoServiceProviders | |||||
.getAsymmetricEncryptionFunction(algorithm); | |||||
AsymmetricEncryptionFunction asymmetricEncryptionFunction = | |||||
CryptoServiceProviders.getAsymmetricEncryptionFunction(algorithm); | |||||
CryptoKeyPair keyPair = asymmetricEncryptionFunction.generateKeyPair(); | |||||
CryptoKeyPair keyPair = asymmetricEncryptionFunction.generateKeyPair(); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
Ciphertext ciphertext = asymmetricEncryptionFunction.encrypt(pubKey, data); | |||||
Ciphertext ciphertext =asymmetricEncryptionFunction.encrypt(pubKey,data); | |||||
byte[] ciphertextBytes = ciphertext.toBytes(); | |||||
assertEquals(2 + 65 + 256 / 8 + 1024, ciphertextBytes.length); | |||||
assertEquals(SMAlgorithm.SM2, ciphertext.getAlgorithm()); | |||||
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()); | |||||
assertEquals((short) (SIGNATURE_ALGORITHM | ENCRYPTION_ALGORITHM | ASYMMETRIC_KEY | ((byte) 2 & 0x00FF)), | |||||
ciphertext.getAlgorithm()); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(ciphertextAlgo); | |||||
byte[] rawCiphertextBytes = ciphertext.getRawCiphertext(); | |||||
assertArrayEquals(BytesUtils.concat(algoBytes,rawCiphertextBytes),ciphertextBytes); | |||||
} | |||||
byte[] algoBytes = BytesUtils.toBytes(ciphertext.getAlgorithm()); | |||||
byte[] rawCiphertextBytes = ciphertext.getRawCiphertext(); | |||||
assertArrayEquals(BytesUtils.concat(algoBytes, rawCiphertextBytes), ciphertextBytes); | |||||
} | |||||
@Test | |||||
public void decryptTest() { | |||||
@Test | |||||
public void decryptTest(){ | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
AsymmetricEncryptionFunction asymmetricEncryptionFunction = CryptoServiceProviders | |||||
.getAsymmetricEncryptionFunction(algorithm); | |||||
AsymmetricEncryptionFunction asymmetricEncryptionFunction = | |||||
CryptoServiceProviders.getAsymmetricEncryptionFunction(algorithm); | |||||
CryptoKeyPair keyPair = asymmetricEncryptionFunction.generateKeyPair(); | |||||
CryptoKeyPair keyPair = asymmetricEncryptionFunction.generateKeyPair(); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
Ciphertext ciphertext = asymmetricEncryptionFunction.encrypt(pubKey, data); | |||||
Ciphertext ciphertext =asymmetricEncryptionFunction.encrypt(pubKey,data); | |||||
byte[] decryptedPlaintext = asymmetricEncryptionFunction.decrypt(privKey, ciphertext); | |||||
byte[] decryptedPlaintext = asymmetricEncryptionFunction.decrypt(privKey,ciphertext); | |||||
assertArrayEquals(data, decryptedPlaintext); | |||||
} | |||||
assertArrayEquals(data,decryptedPlaintext); | |||||
} | |||||
@Test | |||||
public void supportPrivKeyTest() { | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
@Test | |||||
public void supportPrivKeyTest(){ | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
byte[] privKeyBytes = privKey.toBytes(); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
assertTrue(signatureFunction.supportPrivKey(privKeyBytes)); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
byte[] privKeyBytes = privKey.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); | |||||
assertTrue(signatureFunction.supportPrivKey(privKeyBytes)); | |||||
assertFalse(signatureFunction.supportPrivKey(sm3PubKeyBytes)); | |||||
} | |||||
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); | |||||
@Test | |||||
public void resolvePrivKeyTest() { | |||||
assertFalse(signatureFunction.supportPrivKey(sm3PubKeyBytes)); | |||||
} | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
@Test | |||||
public void resolvePrivKeyTest(){ | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
byte[] privKeyBytes = privKey.toBytes(); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
PrivKey resolvedPrivKey = signatureFunction.resolvePrivKey(privKeyBytes); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
byte[] privKeyBytes = privKey.toBytes(); | |||||
assertEquals(PRIVATE.CODE, resolvedPrivKey.getKeyType().CODE); | |||||
assertEquals(32, resolvedPrivKey.getRawKeyBytes().length); | |||||
assertEquals(SMAlgorithm.SM2, resolvedPrivKey.getAlgorithm()); | |||||
assertEquals((short) (SIGNATURE_ALGORITHM | ENCRYPTION_ALGORITHM | ASYMMETRIC_KEY | ((byte) 2 & 0x00FF)), | |||||
resolvedPrivKey.getAlgorithm()); | |||||
assertArrayEquals(privKeyBytes, resolvedPrivKey.toBytes()); | |||||
PrivKey resolvedPrivKey = signatureFunction.resolvePrivKey(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); | |||||
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()); | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
signatureFunction.resolvePrivKey(sm3PubKeyBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
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); | |||||
@Test | |||||
public void supportPubKeyTest() { | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
signatureFunction.resolvePrivKey(sm3PubKeyBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
@Test | |||||
public void supportPubKeyTest(){ | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
byte[] pubKeyBytes = pubKey.toBytes(); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
assertTrue(signatureFunction.supportPubKey(pubKeyBytes)); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
byte[] pubKeyBytes = pubKey.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); | |||||
assertTrue(signatureFunction.supportPubKey(pubKeyBytes)); | |||||
assertFalse(signatureFunction.supportPubKey(sm3PrivKeyBytes)); | |||||
} | |||||
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); | |||||
@Test | |||||
public void resolvePubKeyTest() { | |||||
assertFalse(signatureFunction.supportPubKey(sm3PrivKeyBytes)); | |||||
} | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
@Test | |||||
public void resolvePubKeyTest(){ | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
byte[] pubKeyBytes = pubKey.toBytes(); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
PubKey resolvedPubKey = signatureFunction.resolvePubKey(pubKeyBytes); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
byte[] pubKeyBytes = pubKey.toBytes(); | |||||
assertEquals(PUBLIC.CODE, resolvedPubKey.getKeyType().CODE); | |||||
assertEquals(65, resolvedPubKey.getRawKeyBytes().length); | |||||
assertEquals(SMAlgorithm.SM2, resolvedPubKey.getAlgorithm()); | |||||
assertEquals((short) (SIGNATURE_ALGORITHM | ENCRYPTION_ALGORITHM | ASYMMETRIC_KEY | ((byte) 2 & 0x00FF)), | |||||
resolvedPubKey.getAlgorithm()); | |||||
assertArrayEquals(pubKeyBytes, resolvedPubKey.toBytes()); | |||||
PubKey resolvedPubKey = signatureFunction.resolvePubKey(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); | |||||
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()); | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
signatureFunction.resolvePrivKey(sm3PrivKeyBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
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); | |||||
@Test | |||||
public void supportDigestTest() { | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
signatureFunction.resolvePrivKey(sm3PrivKeyBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
@Test | |||||
public void supportDigestTest(){ | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
SignatureFunction signatureFunction = | |||||
CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
SignatureDigest signatureDigest = signatureFunction.sign(privKey, data); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
byte[] signatureDigestBytes = signatureDigest.toBytes(); | |||||
assertTrue(signatureFunction.supportDigest(signatureDigestBytes)); | |||||
SignatureDigest signatureDigest = signatureFunction.sign(privKey,data); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sm3"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] rawDigestBytes = signatureDigest.toBytes(); | |||||
byte[] sm3SignatureBytes = BytesUtils.concat(algoBytes, rawDigestBytes); | |||||
byte[] signatureDigestBytes = signatureDigest.toBytes(); | |||||
assertTrue(signatureFunction.supportDigest(signatureDigestBytes)); | |||||
assertFalse(signatureFunction.supportDigest(sm3SignatureBytes)); | |||||
} | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sm3"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] rawDigestBytes = signatureDigest.toBytes(); | |||||
byte[] sm3SignatureBytes = BytesUtils.concat(algoBytes,rawDigestBytes); | |||||
@Test | |||||
public void resolveDigestTest() { | |||||
assertFalse(signatureFunction.supportDigest(sm3SignatureBytes)); | |||||
} | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
@Test | |||||
public void resolveDigestTest(){ | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
SignatureFunction signatureFunction = | |||||
CryptoServiceProviders.getSignatureFunction(algorithm); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
CryptoKeyPair keyPair = signatureFunction.generateKeyPair(); | |||||
SignatureDigest signatureDigest = signatureFunction.sign(privKey, data); | |||||
PrivKey privKey = keyPair.getPrivKey(); | |||||
byte[] signatureDigestBytes = signatureDigest.toBytes(); | |||||
SignatureDigest signatureDigest = signatureFunction.sign(privKey,data); | |||||
SignatureDigest resolvedSignatureDigest = signatureFunction.resolveDigest(signatureDigestBytes); | |||||
byte[] signatureDigestBytes = signatureDigest.toBytes(); | |||||
assertEquals(64, resolvedSignatureDigest.getRawDigest().length); | |||||
assertEquals(SMAlgorithm.SM2, resolvedSignatureDigest.getAlgorithm()); | |||||
assertEquals((short) (SIGNATURE_ALGORITHM | ENCRYPTION_ALGORITHM | ASYMMETRIC_KEY | ((byte) 2 & 0x00FF)), | |||||
resolvedSignatureDigest.getAlgorithm()); | |||||
assertArrayEquals(signatureDigestBytes, resolvedSignatureDigest.toBytes()); | |||||
SignatureDigest resolvedSignatureDigest = signatureFunction.resolveDigest(signatureDigestBytes); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sm3"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] rawDigestBytes = signatureDigest.getRawDigest(); | |||||
byte[] sm3SignatureDigestBytes = BytesUtils.concat(algoBytes, rawDigestBytes); | |||||
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()); | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
signatureFunction.resolveDigest(sm3SignatureDigestBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sm3"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] rawDigestBytes = signatureDigest.getRawDigest(); | |||||
byte[] sm3SignatureDigestBytes = BytesUtils.concat(algoBytes,rawDigestBytes); | |||||
@Test | |||||
public void supportCiphertextTest() { | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
signatureFunction.resolveDigest(sm3SignatureDigestBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
@Test | |||||
public void supportCiphertextTest(){ | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
AsymmetricEncryptionFunction asymmetricEncryptionFunction = CryptoServiceProviders | |||||
.getAsymmetricEncryptionFunction(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
CryptoKeyPair keyPair = asymmetricEncryptionFunction.generateKeyPair(); | |||||
AsymmetricEncryptionFunction asymmetricEncryptionFunction = | |||||
CryptoServiceProviders.getAsymmetricEncryptionFunction(algorithm); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
CryptoKeyPair keyPair = asymmetricEncryptionFunction.generateKeyPair(); | |||||
Ciphertext ciphertext = asymmetricEncryptionFunction.encrypt(pubKey, data); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
byte[] ciphertextBytes = ciphertext.toBytes(); | |||||
Ciphertext ciphertext =asymmetricEncryptionFunction.encrypt(pubKey,data); | |||||
assertTrue(asymmetricEncryptionFunction.supportCiphertext(ciphertextBytes)); | |||||
byte[] ciphertextBytes = ciphertext.toBytes(); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sm3"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] rawCiphertextBytes = ciphertext.toBytes(); | |||||
byte[] sm3CiphertextBytes = BytesUtils.concat(algoBytes, rawCiphertextBytes); | |||||
assertTrue(asymmetricEncryptionFunction.supportCiphertext(ciphertextBytes)); | |||||
assertFalse(asymmetricEncryptionFunction.supportCiphertext(sm3CiphertextBytes)); | |||||
} | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sm3"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] rawCiphertextBytes = ciphertext.toBytes(); | |||||
byte[] sm3CiphertextBytes = BytesUtils.concat(algoBytes,rawCiphertextBytes); | |||||
@Test | |||||
public void resolveCiphertextTest() { | |||||
assertFalse(asymmetricEncryptionFunction.supportCiphertext(sm3CiphertextBytes)); | |||||
} | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
@Test | |||||
public void resolveCiphertextTest(){ | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
AsymmetricEncryptionFunction asymmetricEncryptionFunction = CryptoServiceProviders | |||||
.getAsymmetricEncryptionFunction(algorithm); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm2"); | |||||
assertNotNull(algorithm); | |||||
CryptoKeyPair keyPair = asymmetricEncryptionFunction.generateKeyPair(); | |||||
AsymmetricEncryptionFunction asymmetricEncryptionFunction = | |||||
CryptoServiceProviders.getAsymmetricEncryptionFunction(algorithm); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
CryptoKeyPair keyPair = asymmetricEncryptionFunction.generateKeyPair(); | |||||
Ciphertext ciphertext = asymmetricEncryptionFunction.encrypt(pubKey, data); | |||||
PubKey pubKey = keyPair.getPubKey(); | |||||
byte[] ciphertextBytes = ciphertext.toBytes(); | |||||
Ciphertext ciphertext =asymmetricEncryptionFunction.encrypt(pubKey,data); | |||||
Ciphertext resolvedCiphertext = asymmetricEncryptionFunction.resolveCiphertext(ciphertextBytes); | |||||
byte[] ciphertextBytes = ciphertext.toBytes(); | |||||
assertEquals(65 + 256 / 8 + 1024, resolvedCiphertext.getRawCiphertext().length); | |||||
assertEquals(SMAlgorithm.SM2, resolvedCiphertext.getAlgorithm()); | |||||
assertEquals((short) (SIGNATURE_ALGORITHM | ENCRYPTION_ALGORITHM | ASYMMETRIC_KEY | ((byte) 2 & 0x00FF)), | |||||
resolvedCiphertext.getAlgorithm()); | |||||
assertArrayEquals(ciphertextBytes, resolvedCiphertext.toBytes()); | |||||
Ciphertext resolvedCiphertext = asymmetricEncryptionFunction.resolveCiphertext(ciphertextBytes); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sm3"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] rawCiphertextBytes = ciphertext.getRawCiphertext(); | |||||
byte[] sm3CiphertextBytes = BytesUtils.concat(algoBytes, rawCiphertextBytes); | |||||
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())); | |||||
} | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
asymmetricEncryptionFunction.resolveCiphertext(sm3CiphertextBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
} | } |
@@ -5,6 +5,7 @@ import com.jd.blockchain.crypto.CryptoException; | |||||
import com.jd.blockchain.crypto.CryptoServiceProviders; | import com.jd.blockchain.crypto.CryptoServiceProviders; | ||||
import com.jd.blockchain.crypto.HashDigest; | import com.jd.blockchain.crypto.HashDigest; | ||||
import com.jd.blockchain.crypto.HashFunction; | import com.jd.blockchain.crypto.HashFunction; | ||||
import com.jd.blockchain.crypto.service.sm.SMAlgorithm; | |||||
import com.jd.blockchain.utils.io.BytesUtils; | import com.jd.blockchain.utils.io.BytesUtils; | ||||
import org.junit.Test; | import org.junit.Test; | ||||
@@ -60,8 +61,7 @@ public class SM3HashFunctionTest { | |||||
assertEquals(256 / 8 + 2,digestBytes.length); | assertEquals(256 / 8 + 2,digestBytes.length); | ||||
assertArrayEquals(digestBytes, BytesUtils.concat(algoBytes, rawDigestBytes)); | assertArrayEquals(digestBytes, BytesUtils.concat(algoBytes, rawDigestBytes)); | ||||
assertEquals(algorithm.code(),digest.getAlgorithm().code()); | |||||
assertEquals(algorithm.name(),digest.getAlgorithm().name()); | |||||
assertEquals(algorithm.code(),digest.getAlgorithm()); | |||||
Class<?> expectedException = CryptoException.class; | Class<?> expectedException = CryptoException.class; | ||||
Exception actualEx = null; | Exception actualEx = null; | ||||
@@ -132,8 +132,8 @@ public class SM3HashFunctionTest { | |||||
HashDigest resolvedDigest = hashFunction.resolveHashDigest(digestBytes); | HashDigest resolvedDigest = hashFunction.resolveHashDigest(digestBytes); | ||||
assertEquals(256 / 8,resolvedDigest.getRawDigest().length); | assertEquals(256 / 8,resolvedDigest.getRawDigest().length); | ||||
assertEquals("SM3",resolvedDigest.getAlgorithm().name()); | |||||
assertEquals((short) (HASH_ALGORITHM | ((byte) 3 & 0x00FF)),resolvedDigest.getAlgorithm().code()); | |||||
assertEquals(SMAlgorithm.SM3,resolvedDigest.getAlgorithm()); | |||||
assertEquals((short) (HASH_ALGORITHM | ((byte) 3 & 0x00FF)),resolvedDigest.getAlgorithm()); | |||||
assertArrayEquals(digestBytes,resolvedDigest.toBytes()); | assertArrayEquals(digestBytes,resolvedDigest.toBytes()); | ||||
algorithm = CryptoServiceProviders.getAlgorithm("sm4"); | algorithm = CryptoServiceProviders.getAlgorithm("sm4"); | ||||
@@ -1,16 +1,28 @@ | |||||
package test.com.jd.blockchain.crypto.service.sm; | package test.com.jd.blockchain.crypto.service.sm; | ||||
import com.jd.blockchain.crypto.*; | |||||
import com.jd.blockchain.utils.io.BytesUtils; | |||||
import org.junit.Test; | |||||
import java.util.Random; | |||||
import static com.jd.blockchain.crypto.CryptoAlgorithm.ENCRYPTION_ALGORITHM; | import static com.jd.blockchain.crypto.CryptoAlgorithm.ENCRYPTION_ALGORITHM; | ||||
import static com.jd.blockchain.crypto.CryptoAlgorithm.SYMMETRIC_KEY; | import static com.jd.blockchain.crypto.CryptoAlgorithm.SYMMETRIC_KEY; | ||||
import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; | import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; | ||||
import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC; | import static com.jd.blockchain.crypto.CryptoKeyType.SYMMETRIC; | ||||
import static org.junit.Assert.*; | |||||
import static org.junit.Assert.assertArrayEquals; | |||||
import static org.junit.Assert.assertEquals; | |||||
import static org.junit.Assert.assertFalse; | |||||
import static org.junit.Assert.assertNotNull; | |||||
import static org.junit.Assert.assertNull; | |||||
import static org.junit.Assert.assertTrue; | |||||
import java.util.Random; | |||||
import org.junit.Test; | |||||
import com.jd.blockchain.crypto.Ciphertext; | |||||
import com.jd.blockchain.crypto.CryptoAlgorithm; | |||||
import com.jd.blockchain.crypto.CryptoException; | |||||
import com.jd.blockchain.crypto.CryptoServiceProviders; | |||||
import com.jd.blockchain.crypto.SymmetricEncryptionFunction; | |||||
import com.jd.blockchain.crypto.SymmetricKey; | |||||
import com.jd.blockchain.crypto.service.sm.SMAlgorithm; | |||||
import com.jd.blockchain.utils.io.BytesUtils; | |||||
/** | /** | ||||
* @author zhanglin33 | * @author zhanglin33 | ||||
@@ -19,262 +31,256 @@ import static org.junit.Assert.*; | |||||
* @date 2019-04-03, 16:35 | * @date 2019-04-03, 16:35 | ||||
*/ | */ | ||||
public class SM4EncryptionFunctionTest { | 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.code(),symmetricKey.getAlgorithm().code()); | |||||
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("SM4",ciphertextAlgo.name()); | |||||
assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 4 & 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("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); | |||||
@Test | |||||
public void getAlgorithmTest() { | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm4"); | |||||
assertNotNull(algorithm); | |||||
assertFalse(symmetricEncryptionFunction.supportSymmetricKey(ripemd160KeyBytes)); | |||||
} | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = CryptoServiceProviders | |||||
.getSymmetricEncryptionFunction(algorithm); | |||||
@Test | |||||
public void resolveSymmetricKeyTest(){ | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm4"); | |||||
assertNotNull(algorithm); | |||||
assertEquals(symmetricEncryptionFunction.getAlgorithm().name(), algorithm.name()); | |||||
assertEquals(symmetricEncryptionFunction.getAlgorithm().code(), algorithm.code()); | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = | |||||
CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sM4"); | |||||
assertNotNull(algorithm); | |||||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||||
byte[] symmetricKeyBytes = symmetricKey.toBytes(); | |||||
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(); | |||||
SymmetricKey resolvedKey = symmetricEncryptionFunction.resolveSymmetricKey(symmetricKeyBytes); | |||||
assertEquals(SYMMETRIC.CODE, symmetricKey.getKeyType().CODE); | |||||
assertEquals(128 / 8, symmetricKey.getRawKeyBytes().length); | |||||
assertEquals(SYMMETRIC.CODE,resolvedKey.getKeyType().CODE); | |||||
assertEquals(128 / 8, resolvedKey.getRawKeyBytes().length); | |||||
assertEquals("SM4",resolvedKey.getAlgorithm().name()); | |||||
assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 4 & 0x00FF)),resolvedKey.getAlgorithm().code()); | |||||
assertArrayEquals(symmetricKeyBytes,resolvedKey.toBytes()); | |||||
assertEquals(algorithm.code(), symmetricKey.getAlgorithm()); | |||||
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); | |||||
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); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm4"); | |||||
assertNotNull(algorithm); | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = CryptoServiceProviders | |||||
.getSymmetricEncryptionFunction(algorithm); | |||||
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[] sm3CiphertextBytes = BytesUtils.concat(algoBytes,rawCiphertextBytes); | |||||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||||
assertFalse(symmetricEncryptionFunction.supportCiphertext(sm3CiphertextBytes)); | |||||
} | |||||
Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey, data); | |||||
byte[] ciphertextBytes = ciphertext.toBytes(); | |||||
assertEquals(2 + 16 + 16 + 1024, ciphertextBytes.length); | |||||
assertEquals(SMAlgorithm.SM4.code(), ciphertext.getAlgorithm()); | |||||
assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 4 & 0x00FF)), ciphertext.getAlgorithm()); | |||||
byte[] algoBytes = BytesUtils.toBytes(ciphertext.getAlgorithm()); | |||||
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); | |||||
@Test | |||||
public void resolveCiphertextTest(){ | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = CryptoServiceProviders | |||||
.getSymmetricEncryptionFunction(algorithm); | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||||
byte[] symmetricKeyBytes = symmetricKey.toBytes(); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm4"); | |||||
assertNotNull(algorithm); | |||||
assertTrue(symmetricEncryptionFunction.supportSymmetricKey(symmetricKeyBytes)); | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = | |||||
CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); | |||||
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)); | |||||
} | |||||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||||
@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(SMAlgorithm.SM4, resolvedKey.getAlgorithm()); | |||||
assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 4 & 0x00FF)), | |||||
resolvedKey.getAlgorithm()); | |||||
assertArrayEquals(symmetricKeyBytes, resolvedKey.toBytes()); | |||||
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[] sm3CiphertextBytes = BytesUtils.concat(algoBytes, rawCiphertextBytes); | |||||
assertFalse(symmetricEncryptionFunction.supportCiphertext(sm3CiphertextBytes)); | |||||
} | |||||
@Test | |||||
public void resolveCiphertextTest() { | |||||
byte[] data = new byte[1024]; | |||||
Random random = new Random(); | |||||
random.nextBytes(data); | |||||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm4"); | |||||
assertNotNull(algorithm); | |||||
Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey,data); | |||||
SymmetricEncryptionFunction symmetricEncryptionFunction = CryptoServiceProviders | |||||
.getSymmetricEncryptionFunction(algorithm); | |||||
byte[] ciphertextBytes = ciphertext.toBytes(); | |||||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||||
Ciphertext resolvedCiphertext = symmetricEncryptionFunction.resolveCiphertext(ciphertextBytes); | |||||
Ciphertext ciphertext = symmetricEncryptionFunction.encrypt(symmetricKey, data); | |||||
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()); | |||||
byte[] ciphertextBytes = ciphertext.toBytes(); | |||||
Ciphertext resolvedCiphertext = symmetricEncryptionFunction.resolveCiphertext(ciphertextBytes); | |||||
algorithm = CryptoServiceProviders.getAlgorithm("sm3"); | |||||
assertNotNull(algorithm); | |||||
byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); | |||||
byte[] rawCiphertextBytes = ciphertext.getRawCiphertext(); | |||||
byte[] sm3CiphertextBytes = BytesUtils.concat(algoBytes,rawCiphertextBytes); | |||||
assertEquals(1024 + 16 + 16, resolvedCiphertext.getRawCiphertext().length); | |||||
assertEquals(SMAlgorithm.SM4, resolvedCiphertext.getAlgorithm()); | |||||
assertEquals((short) (ENCRYPTION_ALGORITHM | SYMMETRIC_KEY | ((byte) 4 & 0x00FF)), | |||||
resolvedCiphertext.getAlgorithm()); | |||||
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 { | |||||
symmetricEncryptionFunction.resolveCiphertext(sm3CiphertextBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
Class<?> expectedException = CryptoException.class; | |||||
Exception actualEx = null; | |||||
try { | |||||
symmetricEncryptionFunction.resolveCiphertext(sm3CiphertextBytes); | |||||
} catch (Exception e) { | |||||
actualEx = e; | |||||
} | |||||
assertNotNull(actualEx); | |||||
assertTrue(expectedException.isAssignableFrom(actualEx.getClass())); | |||||
} | |||||
} | } |
@@ -12,6 +12,7 @@ import com.jd.blockchain.crypto.PubKey; | |||||
import com.jd.blockchain.ledger.MagicNumber; | import com.jd.blockchain.ledger.MagicNumber; | ||||
import com.jd.blockchain.utils.io.ByteArray; | import com.jd.blockchain.utils.io.ByteArray; | ||||
import com.jd.blockchain.utils.io.BytesEncoding; | import com.jd.blockchain.utils.io.BytesEncoding; | ||||
import com.jd.blockchain.utils.io.BytesUtils; | |||||
import com.jd.blockchain.utils.io.NumberMask; | import com.jd.blockchain.utils.io.NumberMask; | ||||
import com.jd.blockchain.utils.io.RuntimeIOException; | import com.jd.blockchain.utils.io.RuntimeIOException; | ||||
@@ -34,9 +35,9 @@ public class CryptoKeyEncoding { | |||||
} | } | ||||
out.write(magicNum); | out.write(magicNum); | ||||
out.write(key.getAlgorithm().code()); | |||||
BytesUtils.writeShort(key.getAlgorithm(), out); | |||||
int size = 2;// 已经写入 2 字节; | |||||
int size = 3;// 已经写入 3 字节; | |||||
size += BytesEncoding.write(key.getRawKeyBytes(), NumberMask.SHORT, out); | size += BytesEncoding.write(key.getRawKeyBytes(), NumberMask.SHORT, out); | ||||
return size; | return size; | ||||
} catch (IOException e) { | } catch (IOException e) { | ||||
@@ -55,8 +56,7 @@ public class CryptoKeyEncoding { | |||||
if (magicNum != MagicNumber.PUB_KEY && magicNum != MagicNumber.PRIV_KEY) { | if (magicNum != MagicNumber.PUB_KEY && magicNum != MagicNumber.PRIV_KEY) { | ||||
throw new IllegalArgumentException("The CryptoKey MagicNumber read from the InputStream is Illegal!"); | throw new IllegalArgumentException("The CryptoKey MagicNumber read from the InputStream is Illegal!"); | ||||
} | } | ||||
byte code = (byte) in.read(); | |||||
CryptoAlgorithm algorithm = CryptoAlgorithm.valueOf(code); | |||||
short algorithm = CryptoAlgorithm.resolveCode(in); | |||||
ByteArray value = BytesEncoding.readAsByteArray(NumberMask.SHORT, in); | ByteArray value = BytesEncoding.readAsByteArray(NumberMask.SHORT, in); | ||||
if (magicNum == MagicNumber.PUB_KEY) { | if (magicNum == MagicNumber.PUB_KEY) { | ||||
@@ -80,8 +80,7 @@ public class CryptoKeyEncoding { | |||||
if (magicNum != MagicNumber.PUB_KEY) { | if (magicNum != MagicNumber.PUB_KEY) { | ||||
throw new IllegalArgumentException("The PubKey MagicNumber read from the InputStream is Illegal!"); | throw new IllegalArgumentException("The PubKey MagicNumber read from the InputStream is Illegal!"); | ||||
} | } | ||||
byte code = (byte) in.read(); | |||||
CryptoAlgorithm algorithm = CryptoAlgorithm.valueOf(code); | |||||
short algorithm = CryptoAlgorithm.resolveCode(in); | |||||
ByteArray value = BytesEncoding.readAsByteArray(NumberMask.SHORT, in); | ByteArray value = BytesEncoding.readAsByteArray(NumberMask.SHORT, in); | ||||
return new PubKey(algorithm, value.bytes()); | return new PubKey(algorithm, value.bytes()); | ||||
} catch (IOException e) { | } catch (IOException e) { | ||||
@@ -100,8 +99,7 @@ public class CryptoKeyEncoding { | |||||
if (magicNum != MagicNumber.PRIV_KEY) { | if (magicNum != MagicNumber.PRIV_KEY) { | ||||
throw new IllegalArgumentException("The PrivKey MagicNumber read from the InputStream is Illegal!"); | throw new IllegalArgumentException("The PrivKey MagicNumber read from the InputStream is Illegal!"); | ||||
} | } | ||||
byte code = (byte) in.read(); | |||||
CryptoAlgorithm algorithm = CryptoAlgorithm.valueOf(code); | |||||
short algorithm = CryptoAlgorithm.resolveCode(in); | |||||
ByteArray value = BytesEncoding.readAsByteArray(NumberMask.SHORT, in); | ByteArray value = BytesEncoding.readAsByteArray(NumberMask.SHORT, in); | ||||
return new PrivKey(algorithm, value.bytes()); | return new PrivKey(algorithm, value.bytes()); | ||||
} catch (IOException e) { | } catch (IOException e) { | ||||
@@ -66,14 +66,14 @@ public class NodeSigningAppender implements TransactionService { | |||||
// 生成网关签名; | // 生成网关签名; | ||||
byte[] endpointRequestBytes = BinaryEncodingUtils.encode(txMessage, TransactionRequest.class); | byte[] endpointRequestBytes = BinaryEncodingUtils.encode(txMessage, TransactionRequest.class); | ||||
CryptoAlgorithm signAlgorithm = nodeKeyPair.getAlgorithm(); | |||||
SignatureFunction signFunc = CryptoServiceProviders.getSignatureFunction(nodeKeyPair.getAlgorithm()); | |||||
short signAlgorithm = nodeKeyPair.getAlgorithm(); | |||||
SignatureFunction signFunc = CryptoServiceProviders.getSignatureFunction(signAlgorithm); | |||||
SignatureDigest signDigest = signFunc.sign(nodeKeyPair.getPrivKey(), endpointRequestBytes); | SignatureDigest signDigest = signFunc.sign(nodeKeyPair.getPrivKey(), endpointRequestBytes); | ||||
txMessage.addNodeSignatures(new DigitalSignatureBlob(nodeKeyPair.getPubKey(), signDigest)); | txMessage.addNodeSignatures(new DigitalSignatureBlob(nodeKeyPair.getPubKey(), signDigest)); | ||||
// 计算交易哈希; | // 计算交易哈希; | ||||
byte[] nodeRequestBytes = BinaryEncodingUtils.encode(txMessage, TransactionRequest.class); | byte[] nodeRequestBytes = BinaryEncodingUtils.encode(txMessage, TransactionRequest.class); | ||||
HashFunction hashFunc = CryptoServiceProviders.getHashFunction(nodeKeyPair.getAlgorithm()); | |||||
HashFunction hashFunc = CryptoServiceProviders.getHashFunction(signAlgorithm); | |||||
HashDigest txHash = hashFunc.hash(nodeRequestBytes); | HashDigest txHash = hashFunc.hash(nodeRequestBytes); | ||||
txMessage.setHash(txHash); | txMessage.setHash(txHash); | ||||
@@ -3,7 +3,6 @@ package com.jd.blockchain.sdk.client; | |||||
import java.io.Closeable; | import java.io.Closeable; | ||||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | ||||
import com.jd.blockchain.crypto.CryptoAlgorithm; | |||||
import com.jd.blockchain.crypto.CryptoServiceProviders; | import com.jd.blockchain.crypto.CryptoServiceProviders; | ||||
import com.jd.blockchain.crypto.PrivKey; | import com.jd.blockchain.crypto.PrivKey; | ||||
import com.jd.blockchain.crypto.SignatureDigest; | import com.jd.blockchain.crypto.SignatureDigest; | ||||
@@ -139,8 +138,7 @@ public class GatewayServiceFactory implements BlockchainServiceFactory, Closeabl | |||||
byte[] txContentBytes = BinaryEncodingUtils.encode(txRequest.getTransactionContent(), | byte[] txContentBytes = BinaryEncodingUtils.encode(txRequest.getTransactionContent(), | ||||
TransactionContent.class); | TransactionContent.class); | ||||
PrivKey userPrivKey = userKey.getPrivKey(); | PrivKey userPrivKey = userKey.getPrivKey(); | ||||
CryptoAlgorithm userAlgorithm = userKey.getAlgorithm(); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(userAlgorithm); | |||||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(userKey.getAlgorithm()); | |||||
if (signatureFunction != null) { | if (signatureFunction != null) { | ||||
SignatureDigest signatureDigest = signatureFunction.sign(userPrivKey, txContentBytes); | SignatureDigest signatureDigest = signatureFunction.sign(userPrivKey, txContentBytes); | ||||
DigitalSignature signature = new DigitalSignatureBlob(userKey.getPubKey(), signatureDigest); | DigitalSignature signature = new DigitalSignatureBlob(userKey.getPubKey(), signatureDigest); | ||||
@@ -673,7 +673,7 @@ public class LedgerInitializeWebController implements LedgerInitProcess, LedgerI | |||||
return false; | return false; | ||||
} | } | ||||
return validateAndRecordDecision(targetDecision, resultHandle, privKey.getAlgorithm()); | |||||
return validateAndRecordDecision(targetDecision, resultHandle); | |||||
} catch (Exception e) { | } catch (Exception e) { | ||||
prompter.error(e, "Error occurred on synchronizing decision from participant[%s] to participant[%s] ! --%s", | prompter.error(e, "Error occurred on synchronizing decision from participant[%s] to participant[%s] ! --%s", | ||||
currentId, targetId, e.getMessage()); | currentId, targetId, e.getMessage()); | ||||
@@ -693,7 +693,7 @@ public class LedgerInitializeWebController implements LedgerInitProcess, LedgerI | |||||
* @return | * @return | ||||
*/ | */ | ||||
private synchronized boolean validateAndRecordDecision(LedgerInitDecision targetDecision, | private synchronized boolean validateAndRecordDecision(LedgerInitDecision targetDecision, | ||||
DecisionResultHandle resultHandle, CryptoAlgorithm hashAlgorithm) { | |||||
DecisionResultHandle resultHandle) { | |||||
if ((!localDecision.getLedgerHash().equals(targetDecision.getLedgerHash())) | if ((!localDecision.getLedgerHash().equals(targetDecision.getLedgerHash())) | ||||
&& resultHandle.getResult() == null) { | && resultHandle.getResult() == null) { | ||||
// 如果结果已经被 | // 如果结果已经被 | ||||
@@ -730,9 +730,8 @@ public class LedgerInitializeWebController implements LedgerInitProcess, LedgerI | |||||
// 当前参与者尚未准备就绪,返回 null; | // 当前参与者尚未准备就绪,返回 null; | ||||
return null; | return null; | ||||
} | } | ||||
PubKey pubKey = ledgerInitSetting.getConsensusParticipants()[remoteId].getPubKey(); | |||||
DecisionResultHandle resultHandle = this.decisions[remoteId]; | DecisionResultHandle resultHandle = this.decisions[remoteId]; | ||||
if (!validateAndRecordDecision(initDecision, resultHandle, pubKey.getAlgorithm())) { | |||||
if (!validateAndRecordDecision(initDecision, resultHandle)) { | |||||
// 签名无效; | // 签名无效; | ||||
throw new LedgerInitException( | throw new LedgerInitException( | ||||
String.format("Reject decision because of invalid signature! --[Id=%s]", remoteId)); | String.format("Reject decision because of invalid signature! --[Id=%s]", remoteId)); | ||||
@@ -28,8 +28,10 @@ public class BytesUtils { | |||||
* | * | ||||
* 此方法不处理两者其中之一为 null 的情形,因为无法定义相等性,所以将引发 {@link NullPointerException} 异常; | * 此方法不处理两者其中之一为 null 的情形,因为无法定义相等性,所以将引发 {@link NullPointerException} 异常; | ||||
* | * | ||||
* @param bytes1 bytes1 | |||||
* @param bytes2 bytes2 | |||||
* @param bytes1 | |||||
* bytes1 | |||||
* @param bytes2 | |||||
* bytes2 | |||||
* @return boolean | * @return boolean | ||||
*/ | */ | ||||
public static boolean equals(byte[] bytes1, byte[] bytes2) { | public static boolean equals(byte[] bytes1, byte[] bytes2) { | ||||
@@ -59,9 +61,11 @@ public class BytesUtils { | |||||
} | } | ||||
/** | /** | ||||
* 将输入流的所有内容都读入到字节数组返回; | |||||
* 如果输入流的长度超出 MAX_BUFFER_SIZE 定义的值,则抛出 IllegalArgumentException ; | |||||
* @param in in | |||||
* 将输入流的所有内容都读入到字节数组返回; 如果输入流的长度超出 MAX_BUFFER_SIZE 定义的值,则抛出 | |||||
* IllegalArgumentException ; | |||||
* | |||||
* @param in | |||||
* in | |||||
* @return byte[] | * @return byte[] | ||||
*/ | */ | ||||
public static byte[] copyToBytes(InputStream in) { | public static byte[] copyToBytes(InputStream in) { | ||||
@@ -98,7 +102,8 @@ public class BytesUtils { | |||||
* @param maxSize | * @param maxSize | ||||
* 最大字节大小; | * 最大字节大小; | ||||
* @return 返回实际复制的字节数; | * @return 返回实际复制的字节数; | ||||
* @throws IOException exception | |||||
* @throws IOException | |||||
* exception | |||||
*/ | */ | ||||
public static int copy(InputStream in, OutputStream out, int maxSize) throws IOException { | public static int copy(InputStream in, OutputStream out, int maxSize) throws IOException { | ||||
byte[] buffer = new byte[BUFFER_SIZE]; | byte[] buffer = new byte[BUFFER_SIZE]; | ||||
@@ -121,7 +126,8 @@ public class BytesUtils { | |||||
/** | /** | ||||
* 将 int 值转为4字节的二进制数组; | * 将 int 值转为4字节的二进制数组; | ||||
* | * | ||||
* @param value value | |||||
* @param value | |||||
* value | |||||
* @return 转换后的二进制数组,高位在前,低位在后; | * @return 转换后的二进制数组,高位在前,低位在后; | ||||
*/ | */ | ||||
public static byte[] toBytes(int value) { | public static byte[] toBytes(int value) { | ||||
@@ -139,7 +145,8 @@ public class BytesUtils { | |||||
/** | /** | ||||
* 将 long 值转为8字节的二进制数组; | * 将 long 值转为8字节的二进制数组; | ||||
* | * | ||||
* @param value value | |||||
* @param value | |||||
* value | |||||
* @return 转换后的二进制数组,高位在前,低位在后; | * @return 转换后的二进制数组,高位在前,低位在后; | ||||
*/ | */ | ||||
public static byte[] toBytes(long value) { | public static byte[] toBytes(long value) { | ||||
@@ -206,7 +213,6 @@ public class BytesUtils { | |||||
return 4; | return 4; | ||||
} | } | ||||
/** | /** | ||||
* 将 int 值转为4字节的二进制数组; | * 将 int 值转为4字节的二进制数组; | ||||
* <p> | * <p> | ||||
@@ -218,20 +224,20 @@ public class BytesUtils { | |||||
* 要保存转换结果的二进制数组;转换结果将从高位至低位的顺序写入数组从 offset 指定位置开始的4个元素; | * 要保存转换结果的二进制数组;转换结果将从高位至低位的顺序写入数组从 offset 指定位置开始的4个元素; | ||||
* @param offset | * @param offset | ||||
* 写入转换结果的起始位置; | * 写入转换结果的起始位置; | ||||
* @param len 写入长度;必须大于 0 ,小于等于 4; | |||||
* @param len | |||||
* 写入长度;必须大于 0 ,小于等于 4; | |||||
* @return 返回写入的长度; | * @return 返回写入的长度; | ||||
*/ | */ | ||||
public static int toBytesInReverse(int value, byte[] bytes, int offset, int len) { | public static int toBytesInReverse(int value, byte[] bytes, int offset, int len) { | ||||
int i = 0; | int i = 0; | ||||
int l = len > 4 ? 4 : len; | int l = len > 4 ? 4 : len; | ||||
for (; i < l; i++) { | for (; i < l; i++) { | ||||
bytes[offset + i] = (byte) ((value >>> (8*i)) & 0x00FF); | |||||
bytes[offset + i] = (byte) ((value >>> (8 * i)) & 0x00FF); | |||||
} | } | ||||
return i; | return i; | ||||
} | } | ||||
// public static int toBytes(int value, OutputStream out) { | // public static int toBytes(int value, OutputStream out) { | ||||
// try { | // try { | ||||
// out.write((value >>> 24) & 0x00FF); | // out.write((value >>> 24) & 0x00FF); | ||||
@@ -486,27 +492,60 @@ public class BytesUtils { | |||||
return value; | return value; | ||||
} | } | ||||
/** | |||||
* 从指定的输入流中读入2个字节,由前到后按由高位到低位的方式转为 short 整数; | |||||
* | |||||
* @param in | |||||
* in | |||||
* @return short | |||||
*/ | |||||
public static short readShort(InputStream in) { | |||||
try { | |||||
int v = in.read(); | |||||
if (v < 0) { | |||||
throw new IllegalDataException("No enough data to read as short from the specified input stream!"); | |||||
} | |||||
int value = (v & 0xFF) << 8; | |||||
v = in.read(); | |||||
if (v < 0) { | |||||
throw new IllegalDataException("No enough data to read as short from the specified input stream!"); | |||||
} | |||||
value = value | (v & 0xFF); | |||||
return (short) value; | |||||
} catch (IOException e) { | |||||
throw new RuntimeIOException(e.getMessage(), e); | |||||
} | |||||
} | |||||
public static int writeShort(short value, OutputStream out) { | |||||
try { | |||||
out.write((value >>> 8) & 0x00FF); | |||||
out.write(value & 0x00FF); | |||||
return 2; | |||||
} catch (IOException e) { | |||||
throw new RuntimeIOException(e.getMessage(), e); | |||||
} | |||||
} | |||||
/** | /** | ||||
* 从指定的输入流中读入4个字节,由前到后按由高位到低位的方式转为 int 整数; | * 从指定的输入流中读入4个字节,由前到后按由高位到低位的方式转为 int 整数; | ||||
* @param in in | |||||
* | |||||
* @param in | |||||
* in | |||||
* @return int | * @return int | ||||
*/ | */ | ||||
public static int readInt(InputStream in) { | public static int readInt(InputStream in) { | ||||
// try { | |||||
// byte[] buf = new byte[4]; | |||||
// if (in.read(buf) < 4) { | |||||
// throw new IllegalDataException("No enough data to read as integer from the specified input stream!"); | |||||
// specified input stream!"); | |||||
// } | |||||
// return toInt(buf); | |||||
// } catch (IOException e) { | |||||
// throw new RuntimeIOException(e.getMessage(), e); | |||||
// } | |||||
try { | try { | ||||
int value = 0; | int value = 0; | ||||
int v; | |||||
for (int i = 0; i < 4; i++) { | for (int i = 0; i < 4; i++) { | ||||
value = value | ((in.read() & 0xFF) << (8 * (3 - i))); | |||||
v = in.read(); | |||||
if (v < 0) { | |||||
throw new IllegalDataException( | |||||
"No enough data to read as integer from the specified input stream!"); | |||||
} | |||||
value = value | ((v & 0xFF) << (8 * (3 - i))); | |||||
} | } | ||||
return value; | return value; | ||||
} catch (IOException e) { | } catch (IOException e) { | ||||
@@ -515,13 +554,6 @@ public class BytesUtils { | |||||
} | } | ||||
public static int writeInt(int value, OutputStream out) { | public static int writeInt(int value, OutputStream out) { | ||||
// byte[] bytes = toBytes(value); | |||||
// try { | |||||
// out.write(bytes); | |||||
// } catch (IOException e) { | |||||
// throw new RuntimeIOException(e.getMessage(), e); | |||||
// } | |||||
try { | try { | ||||
out.write((value >>> 24) & 0x00FF); | out.write((value >>> 24) & 0x00FF); | ||||
out.write((value >>> 16) & 0x00FF); | out.write((value >>> 16) & 0x00FF); | ||||
@@ -534,17 +566,6 @@ public class BytesUtils { | |||||
} | } | ||||
public static long readLong(InputStream in) { | public static long readLong(InputStream in) { | ||||
// try { | |||||
// byte[] buf = new byte[8]; | |||||
// if (in.read(buf) < 8) { | |||||
// throw new IllegalDataException( | |||||
// "No enough data to read as long integer from the specified input stream!"); | |||||
// } | |||||
// return toLong(buf); | |||||
// } catch (IOException e) { | |||||
// throw new RuntimeIOException(e.getMessage(), e); | |||||
// } | |||||
try { | try { | ||||
long value = 0; | long value = 0; | ||||
int v; | int v; | ||||
@@ -565,13 +586,6 @@ public class BytesUtils { | |||||
} | } | ||||
public static int writeLong(long value, OutputStream out) { | public static int writeLong(long value, OutputStream out) { | ||||
// byte[] bytes = toBytes(value); | |||||
// try { | |||||
// out.write(bytes); | |||||
// } catch (IOException e) { | |||||
// throw new RuntimeIOException(e.getMessage(), e); | |||||
// } | |||||
try { | try { | ||||
out.write((int) ((value >>> 56) & 0x00FF)); | out.write((int) ((value >>> 56) & 0x00FF)); | ||||
out.write((int) ((value >>> 48) & 0x00FF)); | out.write((int) ((value >>> 48) & 0x00FF)); | ||||
@@ -644,25 +658,29 @@ public class BytesUtils { | |||||
/** | /** | ||||
* 从字节数组获取对象 | * 从字节数组获取对象 | ||||
* | * | ||||
* @param objBytes objBytes | |||||
* @param objBytes | |||||
* objBytes | |||||
* @return object | * @return object | ||||
* @throws Exception exception | |||||
* @throws Exception | |||||
* exception | |||||
*/ | */ | ||||
// public static Object getObjectFromBytes(byte[] objBytes) throws Exception { | |||||
// if (objBytes == null || objBytes.length == 0) { | |||||
// return null; | |||||
// } | |||||
// ByteArrayInputStream bi = new ByteArrayInputStream(objBytes); | |||||
// ObjectInputStream oi = new ObjectInputStream(bi); | |||||
// return oi.readObject(); | |||||
// } | |||||
// public static Object getObjectFromBytes(byte[] objBytes) throws Exception { | |||||
// if (objBytes == null || objBytes.length == 0) { | |||||
// return null; | |||||
// } | |||||
// ByteArrayInputStream bi = new ByteArrayInputStream(objBytes); | |||||
// ObjectInputStream oi = new ObjectInputStream(bi); | |||||
// return oi.readObject(); | |||||
// } | |||||
/** | /** | ||||
* 从对象获取一个字节数组; | * 从对象获取一个字节数组; | ||||
* | * | ||||
* @param obj obj | |||||
* @param obj | |||||
* obj | |||||
* @return byte array | * @return byte array | ||||
* @throws Exception exception | |||||
* @throws Exception | |||||
* exception | |||||
*/ | */ | ||||
public static byte[] getBytesFromObject(Object obj) throws Exception { | public static byte[] getBytesFromObject(Object obj) throws Exception { | ||||
if (obj == null) { | if (obj == null) { | ||||