@@ -8,12 +8,18 @@ import java.io.IOException; | |||
import java.io.InputStream; | |||
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; | |||
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 BLOCK_SIZE = 128 / 8; | |||
@@ -38,7 +44,7 @@ public class AESEncryptionFunction implements SymmetricEncryptionFunction { | |||
} | |||
// 验证密钥数据的算法标识对应AES算法 | |||
if (key.getAlgorithm().code() != AES.code()) { | |||
if (key.getAlgorithm() != AES.code()) { | |||
throw new CryptoException("The is not AES symmetric key!"); | |||
} | |||
@@ -103,7 +109,7 @@ public class AESEncryptionFunction implements SymmetricEncryptionFunction { | |||
} | |||
// 验证密钥数据的算法标识对应AES算法 | |||
if (key.getAlgorithm().code() != AES.code()) { | |||
if (key.getAlgorithm() != AES.code()) { | |||
throw new CryptoException("The is not AES symmetric key!"); | |||
} | |||
@@ -113,7 +119,7 @@ public class AESEncryptionFunction implements SymmetricEncryptionFunction { | |||
} | |||
// 验证密文数据算法标识对应AES算法 | |||
if (ciphertext.getAlgorithm().code() != AES.code()) { | |||
if (ciphertext.getAlgorithm() != AES.code()) { | |||
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.List; | |||
import com.jd.blockchain.crypto.CryptoAlgorithm; | |||
import com.jd.blockchain.crypto.CryptoAlgorithmDefinition; | |||
import com.jd.blockchain.crypto.CryptoFunction; | |||
import com.jd.blockchain.crypto.CryptoService; | |||
import com.jd.blockchain.provider.NamedProvider; | |||
@@ -14,25 +12,6 @@ import com.jd.blockchain.provider.NamedProvider; | |||
@NamedProvider("CLASSIC") | |||
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(); | |||
@@ -59,7 +59,7 @@ public class ECDSASignatureFunction implements SignatureFunction { | |||
@Override | |||
public CryptoAlgorithm getAlgorithm() { | |||
return ClassicCryptoService.ECDSA_ALGORITHM; | |||
return ClassicAlgorithm.ECDSA; | |||
} | |||
@Override | |||
@@ -20,7 +20,7 @@ import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters; | |||
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 PRIVKEY_SIZE = 32; | |||
@@ -44,7 +44,7 @@ public class ED25519SignatureFunction implements SignatureFunction { | |||
} | |||
// 验证密钥数据的算法标识对应ED25519签名算法 | |||
if (privKey.getAlgorithm().code() != ED25519.code()) { | |||
if (privKey.getAlgorithm() != ED25519.code()) { | |||
throw new CryptoException("This key is not ED25519 private key!"); | |||
} | |||
@@ -66,12 +66,12 @@ public class ED25519SignatureFunction implements SignatureFunction { | |||
} | |||
// 验证密钥数据的算法标识对应ED25519签名算法 | |||
if (pubKey.getAlgorithm().code() != ED25519.code()) { | |||
if (pubKey.getAlgorithm() != ED25519.code()) { | |||
throw new CryptoException("This key is not ED25519 public key!"); | |||
} | |||
// 验证密文数据的算法标识对应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!"); | |||
} | |||
@@ -8,7 +8,7 @@ import com.jd.blockchain.crypto.RandomGenerator; | |||
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() { | |||
@@ -12,7 +12,7 @@ import com.jd.blockchain.utils.security.RipeMD160Utils; | |||
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; | |||
@@ -12,7 +12,7 @@ import com.jd.blockchain.utils.security.ShaUtils; | |||
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; | |||
@@ -1,20 +1,28 @@ | |||
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.SYMMETRIC_KEY; | |||
import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; | |||
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 | |||
@@ -24,268 +32,261 @@ import static org.junit.Assert.*; | |||
*/ | |||
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; | |||
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.SIGNATURE_ALGORITHM; | |||
import static com.jd.blockchain.crypto.CryptoKeyType.PRIVATE; | |||
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 | |||
@@ -60,10 +74,8 @@ public class ED25519SignatureFunctionTest { | |||
assertEquals(PRIVATE.CODE,privKey.getKeyType().CODE); | |||
assertEquals(32, privKey.getRawKeyBytes().length); | |||
assertEquals(algorithm.name(),pubKey.getAlgorithm().name()); | |||
assertEquals(algorithm.code(),pubKey.getAlgorithm().code()); | |||
assertEquals(algorithm.name(),privKey.getAlgorithm().name()); | |||
assertEquals(algorithm.code(),privKey.getAlgorithm().code()); | |||
assertEquals(algorithm.code(),pubKey.getAlgorithm()); | |||
assertEquals(algorithm.code(),privKey.getAlgorithm()); | |||
assertEquals(2 + 1 + 32, pubKey.toBytes().length); | |||
assertEquals(2 + 1 + 32, privKey.toBytes().length); | |||
@@ -94,8 +106,7 @@ public class ED25519SignatureFunctionTest { | |||
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()); | |||
assertEquals(pubKey.getAlgorithm(),retrievedPubKey.getAlgorithm()); | |||
assertArrayEquals(pubKey.toBytes(),retrievedPubKey.toBytes()); | |||
} | |||
@@ -119,12 +130,11 @@ public class ED25519SignatureFunctionTest { | |||
byte[] signatureBytes = signatureDigest.toBytes(); | |||
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)), | |||
signatureAlgo.code()); | |||
signatureDigest.getAlgorithm()); | |||
byte[] algoBytes = CryptoAlgorithm.toBytes(signatureAlgo); | |||
byte[] algoBytes = BytesUtils.toBytes(signatureDigest.getAlgorithm()); | |||
byte[] rawSinatureBytes = signatureDigest.getRawDigest(); | |||
assertArrayEquals(BytesUtils.concat(algoBytes,rawSinatureBytes),signatureBytes); | |||
} | |||
@@ -192,9 +202,9 @@ public class ED25519SignatureFunctionTest { | |||
assertEquals(PRIVATE.CODE,resolvedPrivKey.getKeyType().CODE); | |||
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)), | |||
resolvedPrivKey.getAlgorithm().code()); | |||
resolvedPrivKey.getAlgorithm()); | |||
assertArrayEquals(privKeyBytes,resolvedPrivKey.toBytes()); | |||
algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); | |||
@@ -257,9 +267,9 @@ public class ED25519SignatureFunctionTest { | |||
assertEquals(PUBLIC.CODE,resolvedPubKey.getKeyType().CODE); | |||
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)), | |||
resolvedPubKey.getAlgorithm().code()); | |||
resolvedPubKey.getAlgorithm()); | |||
assertArrayEquals(pubKeyBytes,resolvedPubKey.toBytes()); | |||
algorithm = CryptoServiceProviders.getAlgorithm("ripemd160"); | |||
@@ -336,9 +346,9 @@ public class ED25519SignatureFunctionTest { | |||
SignatureDigest resolvedSignatureDigest = signatureFunction.resolveDigest(signatureDigestBytes); | |||
assertEquals(64, resolvedSignatureDigest.getRawDigest().length); | |||
assertEquals("ED25519",resolvedSignatureDigest.getAlgorithm().name()); | |||
assertEquals(ClassicAlgorithm.ED25519,resolvedSignatureDigest.getAlgorithm()); | |||
assertEquals((short) (SIGNATURE_ALGORITHM | ASYMMETRIC_KEY | ((byte) 21 & 0x00FF)), | |||
resolvedSignatureDigest.getAlgorithm().code()); | |||
resolvedSignatureDigest.getAlgorithm()); | |||
assertArrayEquals(signatureDigestBytes,resolvedSignatureDigest.toBytes()); | |||
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.HashDigest; | |||
import com.jd.blockchain.crypto.HashFunction; | |||
import com.jd.blockchain.crypto.service.classic.ClassicAlgorithm; | |||
import com.jd.blockchain.utils.io.BytesUtils; | |||
import org.junit.Test; | |||
@@ -22,152 +23,151 @@ import static org.junit.Assert.assertEquals; | |||
*/ | |||
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.HashDigest; | |||
import com.jd.blockchain.crypto.HashFunction; | |||
import com.jd.blockchain.crypto.service.classic.ClassicAlgorithm; | |||
import com.jd.blockchain.utils.io.BytesUtils; | |||
import org.junit.Test; | |||
@@ -22,152 +23,151 @@ import static org.junit.Assert.*; | |||
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; | |||
} | |||
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) { | |||
byte[] h1Bytes = ShaUtils.hash_256(pubKey.getRawKeyBytes()); | |||
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[] addressBytes = BytesUtils.concat(xBytes, checksum); | |||
@@ -11,7 +11,7 @@ public class AsymmetricCiphertext extends BaseCryptoBytes implements Ciphertext | |||
} | |||
@Override | |||
protected boolean support(CryptoAlgorithm algorithm) { | |||
protected boolean support(short algorithm) { | |||
return CryptoAlgorithm.isAsymmetricEncryptionAlgorithm(algorithm); | |||
} | |||
@@ -8,47 +8,60 @@ import com.jd.blockchain.utils.io.BytesUtils; | |||
public abstract class BaseCryptoBytes extends Bytes implements CryptoBytes { | |||
private CryptoAlgorithm algorithm; | |||
private short algorithm; | |||
public BaseCryptoBytes() { | |||
super(); | |||
} | |||
public BaseCryptoBytes(short algorithm, byte[] rawCryptoBytes) { | |||
super(encodeBytes(algorithm, rawCryptoBytes)); | |||
this.algorithm = algorithm; | |||
} | |||
public BaseCryptoBytes(CryptoAlgorithm algorithm, byte[] rawCryptoBytes) { | |||
super(encodeBytes(algorithm, rawCryptoBytes)); | |||
this.algorithm = algorithm; | |||
this.algorithm = algorithm.code(); | |||
} | |||
public BaseCryptoBytes(byte[] cryptoBytes) { | |||
super(cryptoBytes); | |||
CryptoAlgorithm algorithm = decodeAlgorithm(cryptoBytes); | |||
short algorithm = decodeAlgorithm(cryptoBytes); | |||
if (!support(algorithm)) { | |||
throw new CryptoException("Not supported algorithm[" + algorithm.toString() + "]!"); | |||
throw new CryptoException("Not supported algorithm [code:" + 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) { | |||
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) { | |||
return Arrays.copyOfRange(cryptoBytes, 1, cryptoBytes.length); | |||
} | |||
@Override | |||
public CryptoAlgorithm getAlgorithm() { | |||
public short getAlgorithm() { | |||
return algorithm; | |||
} | |||
@@ -13,6 +13,10 @@ public abstract class BaseCryptoKey extends BaseCryptoBytes implements CryptoKey | |||
// public BaseCryptoKey() { | |||
// super(); | |||
// } | |||
protected BaseCryptoKey(short algorithm, byte[] rawKeyBytes, CryptoKeyType keyType) { | |||
super(algorithm, encodeKeyBytes(rawKeyBytes, keyType)); | |||
} | |||
protected BaseCryptoKey(CryptoAlgorithm algorithm, byte[] rawKeyBytes, CryptoKeyType keyType) { | |||
super(algorithm, encodeKeyBytes(rawKeyBytes, keyType)); | |||
@@ -35,7 +39,7 @@ public abstract class BaseCryptoKey extends BaseCryptoBytes implements CryptoKey | |||
} | |||
@Override | |||
protected boolean support(CryptoAlgorithm algorithm) { | |||
protected boolean support(short algorithm) { | |||
return CryptoAlgorithm.hasAsymmetricKey(algorithm) || CryptoAlgorithm.hasSymmetricKey(algorithm); | |||
} | |||
@@ -1,5 +1,8 @@ | |||
package com.jd.blockchain.crypto; | |||
import java.io.InputStream; | |||
import java.io.OutputStream; | |||
import com.jd.blockchain.binaryproto.DataContract; | |||
import com.jd.blockchain.binaryproto.DataField; | |||
import com.jd.blockchain.consts.TypeCodes; | |||
@@ -90,6 +93,14 @@ public interface CryptoAlgorithm { | |||
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) { | |||
return algorithm.code() == BytesUtils.toShort(algorithmBytes, 0); | |||
} | |||
@@ -116,6 +127,24 @@ public interface CryptoAlgorithm { | |||
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 | |||
*/ | |||
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 | |||
*/ | |||
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 | |||
*/ | |||
static boolean hasSymmetricKey(short algorithm) { | |||
return SYMMETRIC_KEY == (algorithm & SYMMETRIC_KEY); | |||
} | |||
/** | |||
* 算法是否包含对称密钥; | |||
* | |||
@@ -171,6 +227,16 @@ public interface CryptoAlgorithm { | |||
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 | |||
*/ | |||
CryptoAlgorithm getAlgorithm(); | |||
short getAlgorithm(); | |||
/** | |||
* 返回编码后的摘要信息;<br> | |||
@@ -6,7 +6,7 @@ public class CryptoKeyPair { | |||
private PrivKey privKey; | |||
public CryptoAlgorithm getAlgorithm() { | |||
public short getAlgorithm() { | |||
return pubKey.getAlgorithm(); | |||
} | |||
@@ -19,7 +19,7 @@ public class CryptoKeyPair { | |||
} | |||
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!"); | |||
} | |||
this.pubKey = pubKey; | |||
@@ -19,7 +19,7 @@ public class HashDigest extends BaseCryptoBytes implements CryptoDigest,Serializ | |||
} | |||
@Override | |||
protected boolean support(CryptoAlgorithm algorithm) { | |||
protected boolean support(short algorithm) { | |||
return CryptoAlgorithm.isHashAlgorithm(algorithm); | |||
} | |||
@@ -8,6 +8,10 @@ package com.jd.blockchain.crypto; | |||
*/ | |||
public class PrivKey extends BaseCryptoKey { | |||
private static final long serialVersionUID = 6265440395252295646L; | |||
public PrivKey(short algorithm, byte[] rawCryptoBytes) { | |||
super(algorithm, rawCryptoBytes, CryptoKeyType.PRIVATE); | |||
} | |||
public PrivKey(CryptoAlgorithm algorithm, byte[] rawCryptoBytes) { | |||
super(algorithm, rawCryptoBytes, CryptoKeyType.PRIVATE); | |||
@@ -9,6 +9,10 @@ package com.jd.blockchain.crypto; | |||
public class PubKey extends BaseCryptoKey { | |||
private static final long serialVersionUID = -2055071197736385328L; | |||
public PubKey(short algorithm, byte[] rawCryptoBytes) { | |||
super(algorithm, rawCryptoBytes, CryptoKeyType.PUBLIC); | |||
} | |||
public PubKey(CryptoAlgorithm algorithm, byte[] rawCryptoBytes) { | |||
super(algorithm, rawCryptoBytes, CryptoKeyType.PUBLIC); | |||
@@ -14,7 +14,7 @@ public class SignatureDigest extends BaseCryptoBytes implements CryptoDigest { | |||
} | |||
@Override | |||
protected boolean support(CryptoAlgorithm algorithm) { | |||
protected boolean support(short algorithm) { | |||
return CryptoAlgorithm.isSignatureAlgorithm(algorithm); | |||
} | |||
@@ -11,7 +11,7 @@ public class SymmetricCiphertext extends BaseCryptoBytes implements Ciphertext { | |||
} | |||
@Override | |||
protected boolean support(CryptoAlgorithm algorithm) { | |||
protected boolean support(short algorithm) { | |||
return CryptoAlgorithm.isEncryptionAlgorithm(algorithm) && CryptoAlgorithm.hasSymmetricKey(algorithm); | |||
} | |||
@@ -1,5 +1,7 @@ | |||
package com.jd.blockchain.crypto.serialize; | |||
import java.lang.reflect.Type; | |||
import com.alibaba.fastjson.serializer.JSONSerializer; | |||
import com.alibaba.fastjson.serializer.ObjectSerializer; | |||
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.io.BytesSlice; | |||
import java.io.IOException; | |||
import java.lang.reflect.Type; | |||
public class ByteArrayObjectSerializer implements ObjectSerializer { | |||
private Class<?> clazz; | |||
@@ -51,11 +50,13 @@ public class ByteArrayObjectSerializer implements ObjectSerializer { | |||
this.value = value; | |||
} | |||
public String getValue() { | |||
@SuppressWarnings("unused") | |||
public String getValue() { | |||
return value; | |||
} | |||
public void setValue(String value) { | |||
@SuppressWarnings("unused") | |||
public void setValue(String 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.PUBLIC; | |||
import com.jd.blockchain.crypto.*; | |||
import org.bouncycastle.crypto.AsymmetricCipherKeyPair; | |||
import org.bouncycastle.crypto.params.ECPrivateKeyParameters; | |||
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; | |||
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 PRIVKEY_SIZE = 32; | |||
@@ -39,7 +48,7 @@ public class SM2CryptoFunction implements AsymmetricEncryptionFunction, Signatur | |||
} | |||
// 验证密钥数据的算法标识对应SM2算法 | |||
if (pubKey.getAlgorithm().code() != SM2.code()) { | |||
if (pubKey.getAlgorithm() != SM2.code()) { | |||
throw new CryptoException("The is not sm2 public key!"); | |||
} | |||
@@ -59,12 +68,12 @@ public class SM2CryptoFunction implements AsymmetricEncryptionFunction, Signatur | |||
} | |||
// 验证密钥数据的算法标识对应SM2算法 | |||
if (privKey.getAlgorithm().code() != SM2.code()) { | |||
if (privKey.getAlgorithm() != SM2.code()) { | |||
throw new CryptoException("This key is not SM2 private key!"); | |||
} | |||
// 验证密文数据的算法标识对应SM2签名算法,并且原始摘要长度为64字节 | |||
if (ciphertext.getAlgorithm().code() != SM2.code() | |||
if (ciphertext.getAlgorithm() != SM2.code() | |||
|| rawCiphertextBytes.length < ECPOINT_SIZE + HASHDIGEST_SIZE) { | |||
throw new CryptoException("This is not SM2 ciphertext!"); | |||
} | |||
@@ -147,7 +156,7 @@ public class SM2CryptoFunction implements AsymmetricEncryptionFunction, Signatur | |||
} | |||
// 验证密钥数据的算法标识对应SM2签名算法 | |||
if (privKey.getAlgorithm().code() != SM2.code()) { | |||
if (privKey.getAlgorithm() != SM2.code()) { | |||
throw new CryptoException("This key is not SM2 private key!"); | |||
} | |||
@@ -167,12 +176,12 @@ public class SM2CryptoFunction implements AsymmetricEncryptionFunction, Signatur | |||
} | |||
// 验证密钥数据的算法标识对应SM2签名算法 | |||
if (pubKey.getAlgorithm().code() != SM2.code()) { | |||
if (pubKey.getAlgorithm() != SM2.code()) { | |||
throw new CryptoException("This key is not SM2 public key!"); | |||
} | |||
// 验证签名数据的算法标识对应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!"); | |||
} | |||
@@ -11,7 +11,7 @@ import com.jd.blockchain.crypto.utils.sm.SM3Utils; | |||
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; | |||
@@ -13,7 +13,7 @@ import com.jd.blockchain.crypto.utils.sm.SM4Utils; | |||
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 BLOCK_SIZE = 128 / 8; | |||
@@ -38,7 +38,7 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | |||
} | |||
// 验证密钥数据的算法标识对应SM4算法 | |||
if (key.getAlgorithm().code() != SM4.code()) { | |||
if (key.getAlgorithm() != SM4.code()) { | |||
throw new CryptoException("The is not SM4 symmetric key!"); | |||
} | |||
@@ -53,7 +53,8 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | |||
try { | |||
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 | |||
byte[] plaintextWithPadding = new byte[buffBytes.length + 1]; | |||
@@ -62,21 +63,21 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | |||
int len; | |||
int i; | |||
while((len=in.read(buffBytes)) > 0) { | |||
while ((len = in.read(buffBytes)) > 0) { | |||
padding = (byte) (PLAINTEXT_BUFFER_LENGTH - len); | |||
i = len; | |||
while (i < plaintextWithPadding.length) { | |||
plaintextWithPadding[i] = padding; | |||
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) { | |||
throw new CryptoException(e.getMessage(), e); | |||
} | |||
@@ -94,7 +95,7 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | |||
} | |||
// 验证密钥数据的算法标识对应SM4算法 | |||
if (key.getAlgorithm().code() != SM4.code()) { | |||
if (key.getAlgorithm() != SM4.code()) { | |||
throw new CryptoException("The is not SM4 symmetric key!"); | |||
} | |||
@@ -104,7 +105,7 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | |||
} | |||
// 验证密文数据算法标识对应SM4算法 | |||
if (ciphertext.getAlgorithm().code() != SM4.code()) { | |||
if (ciphertext.getAlgorithm() != SM4.code()) { | |||
throw new CryptoException("This is not SM4 ciphertext!"); | |||
} | |||
@@ -122,7 +123,7 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | |||
byte padding; | |||
byte[] plaintext; | |||
int len,i; | |||
int len, i; | |||
while ((len = in.read(buffBytes)) > 0) { | |||
if (len != CIPHERTEXT_BUFFER_LENGTH) { | |||
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!"); | |||
} | |||
plaintextWithPadding = decrypt(key,resolveCiphertext(buffBytes)); | |||
plaintextWithPadding = decrypt(key, resolveCiphertext(buffBytes)); | |||
if (plaintextWithPadding.length != (PLAINTEXT_BUFFER_LENGTH + 1)) { | |||
throw new CryptoException("The decrypted plaintext is invalid"); | |||
@@ -148,19 +149,19 @@ public class SM4EncryptionFunction implements SymmetricEncryptionFunction { | |||
i--; | |||
} | |||
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); | |||
} | |||
// 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) { | |||
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.List; | |||
import com.jd.blockchain.crypto.CryptoAlgorithm; | |||
import com.jd.blockchain.crypto.CryptoAlgorithmDefinition; | |||
import com.jd.blockchain.crypto.CryptoFunction; | |||
import com.jd.blockchain.crypto.CryptoService; | |||
import com.jd.blockchain.provider.NamedProvider; | |||
@@ -20,14 +18,6 @@ import com.jd.blockchain.provider.NamedProvider; | |||
@NamedProvider("SM-SOFTWARE") | |||
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 SM3HashFunction SM3 = new SM3HashFunction(); | |||
public static final SM4EncryptionFunction SM4 = new SM4EncryptionFunction(); | |||
@@ -1,6 +1,7 @@ | |||
package test.com.jd.blockchain.crypto.service.sm; | |||
import com.jd.blockchain.crypto.*; | |||
import com.jd.blockchain.crypto.service.sm.SMAlgorithm; | |||
import com.jd.blockchain.utils.io.BytesUtils; | |||
import org.junit.Test; | |||
@@ -19,479 +20,469 @@ import static org.junit.Assert.*; | |||
*/ | |||
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.HashDigest; | |||
import com.jd.blockchain.crypto.HashFunction; | |||
import com.jd.blockchain.crypto.service.sm.SMAlgorithm; | |||
import com.jd.blockchain.utils.io.BytesUtils; | |||
import org.junit.Test; | |||
@@ -60,8 +61,7 @@ public class SM3HashFunctionTest { | |||
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; | |||
@@ -132,8 +132,8 @@ public class SM3HashFunctionTest { | |||
HashDigest resolvedDigest = hashFunction.resolveHashDigest(digestBytes); | |||
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()); | |||
algorithm = CryptoServiceProviders.getAlgorithm("sm4"); | |||
@@ -1,16 +1,28 @@ | |||
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.SYMMETRIC_KEY; | |||
import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; | |||
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 | |||
@@ -19,262 +31,256 @@ import static org.junit.Assert.*; | |||
* @date 2019-04-03, 16:35 | |||
*/ | |||
public class SM4EncryptionFunctionTest { | |||
@Test | |||
public void getAlgorithmTest(){ | |||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm4"); | |||
assertNotNull(algorithm); | |||
SymmetricEncryptionFunction symmetricEncryptionFunction = | |||
CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); | |||
assertEquals(symmetricEncryptionFunction.getAlgorithm().name(), algorithm.name()); | |||
assertEquals(symmetricEncryptionFunction.getAlgorithm().code(), algorithm.code()); | |||
algorithm = CryptoServiceProviders.getAlgorithm("sM4"); | |||
assertNotNull(algorithm); | |||
assertEquals(symmetricEncryptionFunction.getAlgorithm().name(), algorithm.name()); | |||
assertEquals(symmetricEncryptionFunction.getAlgorithm().code(), algorithm.code()); | |||
algorithm = CryptoServiceProviders.getAlgorithm("smm4"); | |||
assertNull(algorithm); | |||
} | |||
@Test | |||
public void generateSymmetricKeyTest(){ | |||
CryptoAlgorithm algorithm = CryptoServiceProviders.getAlgorithm("sm4"); | |||
assertNotNull(algorithm); | |||
SymmetricEncryptionFunction symmetricEncryptionFunction = | |||
CryptoServiceProviders.getSymmetricEncryptionFunction(algorithm); | |||
SymmetricKey symmetricKey = (SymmetricKey) symmetricEncryptionFunction.generateSymmetricKey(); | |||
assertEquals(SYMMETRIC.CODE,symmetricKey.getKeyType().CODE); | |||
assertEquals(128 / 8, symmetricKey.getRawKeyBytes().length); | |||
assertEquals(algorithm.name(),symmetricKey.getAlgorithm().name()); | |||
assertEquals(algorithm.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.utils.io.ByteArray; | |||
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.RuntimeIOException; | |||
@@ -34,9 +35,9 @@ public class CryptoKeyEncoding { | |||
} | |||
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); | |||
return size; | |||
} catch (IOException e) { | |||
@@ -55,8 +56,7 @@ public class CryptoKeyEncoding { | |||
if (magicNum != MagicNumber.PUB_KEY && magicNum != MagicNumber.PRIV_KEY) { | |||
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); | |||
if (magicNum == MagicNumber.PUB_KEY) { | |||
@@ -80,8 +80,7 @@ public class CryptoKeyEncoding { | |||
if (magicNum != MagicNumber.PUB_KEY) { | |||
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); | |||
return new PubKey(algorithm, value.bytes()); | |||
} catch (IOException e) { | |||
@@ -100,8 +99,7 @@ public class CryptoKeyEncoding { | |||
if (magicNum != MagicNumber.PRIV_KEY) { | |||
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); | |||
return new PrivKey(algorithm, value.bytes()); | |||
} catch (IOException e) { | |||
@@ -66,14 +66,14 @@ public class NodeSigningAppender implements TransactionService { | |||
// 生成网关签名; | |||
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); | |||
txMessage.addNodeSignatures(new DigitalSignatureBlob(nodeKeyPair.getPubKey(), signDigest)); | |||
// 计算交易哈希; | |||
byte[] nodeRequestBytes = BinaryEncodingUtils.encode(txMessage, TransactionRequest.class); | |||
HashFunction hashFunc = CryptoServiceProviders.getHashFunction(nodeKeyPair.getAlgorithm()); | |||
HashFunction hashFunc = CryptoServiceProviders.getHashFunction(signAlgorithm); | |||
HashDigest txHash = hashFunc.hash(nodeRequestBytes); | |||
txMessage.setHash(txHash); | |||
@@ -3,7 +3,6 @@ package com.jd.blockchain.sdk.client; | |||
import java.io.Closeable; | |||
import com.jd.blockchain.binaryproto.BinaryEncodingUtils; | |||
import com.jd.blockchain.crypto.CryptoAlgorithm; | |||
import com.jd.blockchain.crypto.CryptoServiceProviders; | |||
import com.jd.blockchain.crypto.PrivKey; | |||
import com.jd.blockchain.crypto.SignatureDigest; | |||
@@ -139,8 +138,7 @@ public class GatewayServiceFactory implements BlockchainServiceFactory, Closeabl | |||
byte[] txContentBytes = BinaryEncodingUtils.encode(txRequest.getTransactionContent(), | |||
TransactionContent.class); | |||
PrivKey userPrivKey = userKey.getPrivKey(); | |||
CryptoAlgorithm userAlgorithm = userKey.getAlgorithm(); | |||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(userAlgorithm); | |||
SignatureFunction signatureFunction = CryptoServiceProviders.getSignatureFunction(userKey.getAlgorithm()); | |||
if (signatureFunction != null) { | |||
SignatureDigest signatureDigest = signatureFunction.sign(userPrivKey, txContentBytes); | |||
DigitalSignature signature = new DigitalSignatureBlob(userKey.getPubKey(), signatureDigest); | |||
@@ -673,7 +673,7 @@ public class LedgerInitializeWebController implements LedgerInitProcess, LedgerI | |||
return false; | |||
} | |||
return validateAndRecordDecision(targetDecision, resultHandle, privKey.getAlgorithm()); | |||
return validateAndRecordDecision(targetDecision, resultHandle); | |||
} catch (Exception e) { | |||
prompter.error(e, "Error occurred on synchronizing decision from participant[%s] to participant[%s] ! --%s", | |||
currentId, targetId, e.getMessage()); | |||
@@ -693,7 +693,7 @@ public class LedgerInitializeWebController implements LedgerInitProcess, LedgerI | |||
* @return | |||
*/ | |||
private synchronized boolean validateAndRecordDecision(LedgerInitDecision targetDecision, | |||
DecisionResultHandle resultHandle, CryptoAlgorithm hashAlgorithm) { | |||
DecisionResultHandle resultHandle) { | |||
if ((!localDecision.getLedgerHash().equals(targetDecision.getLedgerHash())) | |||
&& resultHandle.getResult() == null) { | |||
// 如果结果已经被 | |||
@@ -730,9 +730,8 @@ public class LedgerInitializeWebController implements LedgerInitProcess, LedgerI | |||
// 当前参与者尚未准备就绪,返回 null; | |||
return null; | |||
} | |||
PubKey pubKey = ledgerInitSetting.getConsensusParticipants()[remoteId].getPubKey(); | |||
DecisionResultHandle resultHandle = this.decisions[remoteId]; | |||
if (!validateAndRecordDecision(initDecision, resultHandle, pubKey.getAlgorithm())) { | |||
if (!validateAndRecordDecision(initDecision, resultHandle)) { | |||
// 签名无效; | |||
throw new LedgerInitException( | |||
String.format("Reject decision because of invalid signature! --[Id=%s]", remoteId)); | |||
@@ -28,8 +28,10 @@ public class BytesUtils { | |||
* | |||
* 此方法不处理两者其中之一为 null 的情形,因为无法定义相等性,所以将引发 {@link NullPointerException} 异常; | |||
* | |||
* @param bytes1 bytes1 | |||
* @param bytes2 bytes2 | |||
* @param bytes1 | |||
* bytes1 | |||
* @param bytes2 | |||
* bytes2 | |||
* @return boolean | |||
*/ | |||
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[] | |||
*/ | |||
public static byte[] copyToBytes(InputStream in) { | |||
@@ -98,7 +102,8 @@ public class BytesUtils { | |||
* @param maxSize | |||
* 最大字节大小; | |||
* @return 返回实际复制的字节数; | |||
* @throws IOException exception | |||
* @throws IOException | |||
* exception | |||
*/ | |||
public static int copy(InputStream in, OutputStream out, int maxSize) throws IOException { | |||
byte[] buffer = new byte[BUFFER_SIZE]; | |||
@@ -121,7 +126,8 @@ public class BytesUtils { | |||
/** | |||
* 将 int 值转为4字节的二进制数组; | |||
* | |||
* @param value value | |||
* @param value | |||
* value | |||
* @return 转换后的二进制数组,高位在前,低位在后; | |||
*/ | |||
public static byte[] toBytes(int value) { | |||
@@ -139,7 +145,8 @@ public class BytesUtils { | |||
/** | |||
* 将 long 值转为8字节的二进制数组; | |||
* | |||
* @param value value | |||
* @param value | |||
* value | |||
* @return 转换后的二进制数组,高位在前,低位在后; | |||
*/ | |||
public static byte[] toBytes(long value) { | |||
@@ -206,7 +213,6 @@ public class BytesUtils { | |||
return 4; | |||
} | |||
/** | |||
* 将 int 值转为4字节的二进制数组; | |||
* <p> | |||
@@ -218,20 +224,20 @@ public class BytesUtils { | |||
* 要保存转换结果的二进制数组;转换结果将从高位至低位的顺序写入数组从 offset 指定位置开始的4个元素; | |||
* @param offset | |||
* 写入转换结果的起始位置; | |||
* @param len 写入长度;必须大于 0 ,小于等于 4; | |||
* @param len | |||
* 写入长度;必须大于 0 ,小于等于 4; | |||
* @return 返回写入的长度; | |||
*/ | |||
public static int toBytesInReverse(int value, byte[] bytes, int offset, int len) { | |||
int i = 0; | |||
int l = len > 4 ? 4 : len; | |||
for (; i < l; i++) { | |||
bytes[offset + i] = (byte) ((value >>> (8*i)) & 0x00FF); | |||
bytes[offset + i] = (byte) ((value >>> (8 * i)) & 0x00FF); | |||
} | |||
return i; | |||
} | |||
// public static int toBytes(int value, OutputStream out) { | |||
// try { | |||
// out.write((value >>> 24) & 0x00FF); | |||
@@ -486,27 +492,60 @@ public class BytesUtils { | |||
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 整数; | |||
* @param in in | |||
* | |||
* @param in | |||
* in | |||
* @return int | |||
*/ | |||
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 { | |||
int value = 0; | |||
int v; | |||
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; | |||
} catch (IOException e) { | |||
@@ -515,13 +554,6 @@ public class BytesUtils { | |||
} | |||
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 { | |||
out.write((value >>> 24) & 0x00FF); | |||
out.write((value >>> 16) & 0x00FF); | |||
@@ -534,17 +566,6 @@ public class BytesUtils { | |||
} | |||
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 { | |||
long value = 0; | |||
int v; | |||
@@ -565,13 +586,6 @@ public class BytesUtils { | |||
} | |||
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 { | |||
out.write((int) ((value >>> 56) & 0x00FF)); | |||
out.write((int) ((value >>> 48) & 0x00FF)); | |||
@@ -644,25 +658,29 @@ public class BytesUtils { | |||
/** | |||
* 从字节数组获取对象 | |||
* | |||
* @param objBytes objBytes | |||
* @param objBytes | |||
* objBytes | |||
* @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 | |||
* @throws Exception exception | |||
* @throws Exception | |||
* exception | |||
*/ | |||
public static byte[] getBytesFromObject(Object obj) throws Exception { | |||
if (obj == null) { | |||