From 962e0f200b807c8971fb2c9be67d085813159fb9 Mon Sep 17 00:00:00 2001 From: zhanglin33 Date: Thu, 16 May 2019 08:50:41 +0800 Subject: [PATCH] add SHA1WITHRSA2048 without junitTest --- .../service/classic/RSACryptoFunction.java | 8 +- .../crypto/utils/classic/RSAUtils.java | 6 +- .../classic/RSACryptoFunctionTest.java | 12 +- .../crypto/service/pki/PKIAlgorithm.java | 26 +++ .../crypto/service/pki/PKICryptoService.java | 36 +++ .../pki/SHA1WITHRSA2048SignatureFunction.java | 206 ++++++++++++++++++ .../pki/SHA1WITHRSA4096SignatureFunction.java | 68 ++++++ .../pki/SM3WITHSM2SignatureFunction.java | 68 ++++++ .../crypto/{ => utils}/CSRBuilder.java | 3 +- .../crypto/{ => utils}/CertParser.java | 5 +- .../com.jd.blockchain.crypto.CryptoService | 1 + .../crypto/{ => utils}/CSRBuilderTest.java | 3 +- .../crypto/{ => utils}/CertParserTest.java | 3 +- 13 files changed, 427 insertions(+), 18 deletions(-) create mode 100644 source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/PKIAlgorithm.java create mode 100644 source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/PKICryptoService.java create mode 100644 source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/SHA1WITHRSA2048SignatureFunction.java create mode 100644 source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/SHA1WITHRSA4096SignatureFunction.java create mode 100644 source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/SM3WITHSM2SignatureFunction.java rename source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/{ => utils}/CSRBuilder.java (98%) rename source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/{ => utils}/CertParser.java (96%) create mode 100644 source/crypto/crypto-pki/src/main/resources/services/com.jd.blockchain.crypto.CryptoService rename source/crypto/crypto-pki/src/test/java/com/jd/blockchain/crypto/{ => utils}/CSRBuilderTest.java (98%) rename source/crypto/crypto-pki/src/test/java/com/jd/blockchain/crypto/{ => utils}/CertParserTest.java (97%) diff --git a/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/RSACryptoFunction.java b/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/RSACryptoFunction.java index b7bd9c8d..ab078bfb 100644 --- a/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/RSACryptoFunction.java +++ b/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/service/classic/RSACryptoFunction.java @@ -21,11 +21,11 @@ public class RSACryptoFunction implements AsymmetricEncryptionFunction, Signatur private static final CryptoAlgorithm RSA = ClassicAlgorithm.RSA; - // modulus.length = 256, publicExponent.length = 1 - private static final int PUBKEY_SIZE = 257; - // modulus.length = 256, publicExponent.length = 1, privateExponent.length = 256, p.length = 128, q.length =128, + // modulus.length = 256, publicExponent.length = 3 + private static final int PUBKEY_SIZE = 259; + // modulus.length = 256, publicExponent.length = 3, privateExponent.length = 256, p.length = 128, q.length =128, // dP.length = 128, dQ.length = 128, qInv.length = 128 - private static final int PRIVKEY_SIZE = 1153; + private static final int PRIVKEY_SIZE = 1155; private static final int SIGNATUREDIGEST_SIZE = 256; private static final int CIPHERTEXTBLOCK_SIZE = 256; diff --git a/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/utils/classic/RSAUtils.java b/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/utils/classic/RSAUtils.java index f17dcdf2..b69a271b 100644 --- a/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/utils/classic/RSAUtils.java +++ b/source/crypto/crypto-classic/src/main/java/com/jd/blockchain/crypto/utils/classic/RSAUtils.java @@ -308,14 +308,14 @@ public class RSAUtils { X509EncodedKeySpec keySpec = new X509EncodedKeySpec(pubKeyBytes); - KeyFactory keyFactory = null; + KeyFactory keyFactory; try { keyFactory = KeyFactory.getInstance("RSA"); } catch (NoSuchAlgorithmException e) { throw new com.jd.blockchain.crypto.CryptoException(e.getMessage(), e); } - RSAPublicKey publicKey = null; + RSAPublicKey publicKey; try { publicKey = (RSAPublicKey) keyFactory.generatePublic(keySpec); } catch (InvalidKeySpecException e) { @@ -451,7 +451,7 @@ public class RSAUtils { PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privKeyBytes); - KeyFactory keyFactory = null; + KeyFactory keyFactory; try { keyFactory = KeyFactory.getInstance("RSA"); } catch (NoSuchAlgorithmException e) { diff --git a/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/RSACryptoFunctionTest.java b/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/RSACryptoFunctionTest.java index 3eefed1c..cff875f7 100644 --- a/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/RSACryptoFunctionTest.java +++ b/source/crypto/crypto-classic/src/test/java/test/com/jd/blockchain/crypto/service/classic/RSACryptoFunctionTest.java @@ -55,15 +55,15 @@ public class RSACryptoFunctionTest { PrivKey privKey = keyPair.getPrivKey(); assertEquals(PUBLIC.CODE, pubKey.getKeyType().CODE); - assertEquals(257, pubKey.getRawKeyBytes().length); + assertEquals(259, pubKey.getRawKeyBytes().length); assertEquals(PRIVATE.CODE, privKey.getKeyType().CODE); - assertEquals(1153, privKey.getRawKeyBytes().length); + assertEquals(1155, privKey.getRawKeyBytes().length); assertEquals(algorithm.code(), pubKey.getAlgorithm()); assertEquals(algorithm.code(), privKey.getAlgorithm()); - assertEquals(2 + 1 + 257, pubKey.toBytes().length); - assertEquals(2 + 1 + 1153, privKey.toBytes().length); + assertEquals(2 + 1 + 259, pubKey.toBytes().length); + assertEquals(2 + 1 + 1155, privKey.toBytes().length); byte[] algoBytes = CryptoAlgorithm.toBytes(algorithm); byte[] pubKeyTypeBytes = new byte[] { PUBLIC.CODE }; @@ -243,7 +243,7 @@ public class RSACryptoFunctionTest { PrivKey resolvedPrivKey = signatureFunction.resolvePrivKey(privKeyBytes); assertEquals(PRIVATE.CODE, resolvedPrivKey.getKeyType().CODE); - assertEquals(1153, resolvedPrivKey.getRawKeyBytes().length); + assertEquals(1155, resolvedPrivKey.getRawKeyBytes().length); assertEquals(ClassicAlgorithm.RSA.code(), resolvedPrivKey.getAlgorithm()); assertEquals((short) (SIGNATURE_ALGORITHM | ENCRYPTION_ALGORITHM | ASYMMETRIC_KEY | ((byte) 23 & 0x00FF)), resolvedPrivKey.getAlgorithm()); @@ -308,7 +308,7 @@ public class RSACryptoFunctionTest { PubKey resolvedPubKey = signatureFunction.resolvePubKey(pubKeyBytes); assertEquals(PUBLIC.CODE, resolvedPubKey.getKeyType().CODE); - assertEquals(257, resolvedPubKey.getRawKeyBytes().length); + assertEquals(259, resolvedPubKey.getRawKeyBytes().length); assertEquals(ClassicAlgorithm.RSA.code(), resolvedPubKey.getAlgorithm()); assertEquals((short) (SIGNATURE_ALGORITHM | ENCRYPTION_ALGORITHM | ASYMMETRIC_KEY | ((byte) 23 & 0x00FF)), resolvedPubKey.getAlgorithm()); diff --git a/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/PKIAlgorithm.java b/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/PKIAlgorithm.java new file mode 100644 index 00000000..0aff4c6b --- /dev/null +++ b/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/PKIAlgorithm.java @@ -0,0 +1,26 @@ +package com.jd.blockchain.crypto.service.pki; + +import com.jd.blockchain.crypto.CryptoAlgorithm; +import com.jd.blockchain.crypto.CryptoAlgorithmDefinition; + +/** + * @author zhanglin33 + * @title: PKIAlgorithm + * @description: TODO + * @date 2019-05-15, 16:34 + */ +public class PKIAlgorithm { + + public static final CryptoAlgorithm SHA1WITHRSA2048 = CryptoAlgorithmDefinition.defineSignature("SHA1WITHRSA2048", + false, (byte) 31); + + public static final CryptoAlgorithm SHA1WITHRSA4096 = CryptoAlgorithmDefinition.defineSignature("SHA1WITHRSA4096", + false, (byte) 32); + + public static final CryptoAlgorithm SM3WITHSM2 = CryptoAlgorithmDefinition.defineSignature("SM3WITHSM2", + false, (byte) 33); + + private PKIAlgorithm() { + } + +} diff --git a/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/PKICryptoService.java b/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/PKICryptoService.java new file mode 100644 index 00000000..3c013bbc --- /dev/null +++ b/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/PKICryptoService.java @@ -0,0 +1,36 @@ +package com.jd.blockchain.crypto.service.pki; + +import com.jd.blockchain.crypto.CryptoFunction; +import com.jd.blockchain.crypto.CryptoService; + +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +/** + * @author zhanglin33 + * @title: PKICryptoService + * @description: TODO + * @date 2019-05-15, 16:35 + */ +public class PKICryptoService implements CryptoService { + + public static final SHA1WITHRSA2048SignatureFunction SHA1WITHRSA2048 = new SHA1WITHRSA2048SignatureFunction(); + + public static final SHA1WITHRSA4096SignatureFunction SHA1WITHRSA4096 = new SHA1WITHRSA4096SignatureFunction(); + + public static final SM3WITHSM2SignatureFunction SM3WITHSM2 = new SM3WITHSM2SignatureFunction(); + + private static final Collection FUNCTIONS; + + static { + List funcs = Arrays.asList(SHA1WITHRSA2048, SHA1WITHRSA4096, SM3WITHSM2); + FUNCTIONS = Collections.unmodifiableList(funcs); + } + + @Override + public Collection getFunctions() { + return FUNCTIONS; + } +} diff --git a/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/SHA1WITHRSA2048SignatureFunction.java b/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/SHA1WITHRSA2048SignatureFunction.java new file mode 100644 index 00000000..48e65765 --- /dev/null +++ b/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/SHA1WITHRSA2048SignatureFunction.java @@ -0,0 +1,206 @@ +package com.jd.blockchain.crypto.service.pki; + +import com.jd.blockchain.crypto.*; +import org.bouncycastle.asn1.DERNull; +import org.bouncycastle.asn1.pkcs.PKCSObjectIdentifiers; +import org.bouncycastle.asn1.x509.AlgorithmIdentifier; +import org.bouncycastle.jcajce.provider.asymmetric.rsa.BCRSAPrivateCrtKey; +import org.bouncycastle.jcajce.provider.asymmetric.util.KeyUtil; +import org.bouncycastle.jce.provider.BouncyCastleProvider; +import sun.security.rsa.RSAPrivateCrtKeyImpl; +import sun.security.rsa.RSAPrivateKeyImpl; +import sun.security.rsa.RSAPublicKeyImpl; + +import java.math.BigInteger; +import java.security.*; +import java.security.interfaces.RSAPrivateCrtKey; +import java.security.interfaces.RSAPrivateKey; +import java.security.interfaces.RSAPublicKey; + +import static com.jd.blockchain.crypto.BaseCryptoKey.KEY_TYPE_BYTES; +import static com.jd.blockchain.crypto.CryptoBytes.ALGORYTHM_CODE_SIZE; +import static com.jd.blockchain.crypto.CryptoKeyType.PRIVATE; +import static com.jd.blockchain.crypto.CryptoKeyType.PUBLIC; +import static com.jd.blockchain.crypto.service.pki.PKIAlgorithm.SHA1WITHRSA2048; + +/** + * @author zhanglin33 + * @title: SHA1WITHRSA2048SignatureFunction + * @description: TODO + * @date 2019-05-15, 16:37 + */ +public class SHA1WITHRSA2048SignatureFunction implements SignatureFunction { + + + private static final int RAW_PUBKEY_SIZE = 259; + private static final int RAW_PRIVKEY_SIZE = 1155; + + private static final int RAW_SIGNATUREDIGEST_SIZE = 256; + + private static final AlgorithmIdentifier RSA_ALGORITHM_IDENTIFIER = + new AlgorithmIdentifier(PKCSObjectIdentifiers.rsaEncryption, DERNull.INSTANCE); + + @Override + public SignatureDigest sign(PrivKey privKey, byte[] data) { + + byte[] rawPrivKeyBytes = privKey.getRawKeyBytes(); + + if (rawPrivKeyBytes.length < RAW_PRIVKEY_SIZE) { + throw new CryptoException("This key has wrong format!"); + } + + if (privKey.getAlgorithm() != SHA1WITHRSA2048.code()) { + throw new CryptoException("This key is not SHA1WITHRSA2048 private key!"); + } + + RSAPrivateCrtKey rawPrivKey; + Signature signer; + byte[] signature; + try { + rawPrivKey = (RSAPrivateCrtKey) RSAPrivateCrtKeyImpl.newKey(rawPrivKeyBytes); + signer = Signature.getInstance("SHA1withRSA"); + signer.initSign(rawPrivKey); + signer.update(data); + signature = signer.sign(); + } catch (NoSuchAlgorithmException | InvalidKeyException | SignatureException e) { + throw new CryptoException(e.getMessage(), e); + } + + return new SignatureDigest(SHA1WITHRSA2048, signature); + } + + @Override + public boolean verify(SignatureDigest digest, PubKey pubKey, byte[] data) { + + byte[] rawPubKeyBytes = pubKey.getRawKeyBytes(); + byte[] rawDigestBytes = digest.getRawDigest(); + + if (rawPubKeyBytes.length < RAW_PUBKEY_SIZE) { + throw new CryptoException("This key has wrong format!"); + } + + if (pubKey.getAlgorithm() != SHA1WITHRSA2048.code()) { + throw new CryptoException("This key is not SHA1WITHRSA2048 public key!"); + } + + if (digest.getAlgorithm() != SHA1WITHRSA2048.code() || rawDigestBytes.length != RAW_SIGNATUREDIGEST_SIZE) { + throw new CryptoException("This is not SHA1WITHRSA2048 signature digest!"); + } + RSAPublicKeyImpl rawPubKey; + Signature verifier; + boolean isValid = false; + try { + rawPubKey = new RSAPublicKeyImpl(rawPubKeyBytes); + verifier = Signature.getInstance("SHA1withRSA"); + verifier.initVerify(rawPubKey); + verifier.update(data); + isValid = verifier.verify(rawDigestBytes); + } catch (NoSuchAlgorithmException | InvalidKeyException | SignatureException e) { + e.printStackTrace(); + } + + return isValid; + } + + @Override + public boolean supportPubKey(byte[] pubKeyBytes) { + return pubKeyBytes.length > (ALGORYTHM_CODE_SIZE + KEY_TYPE_BYTES + RAW_PUBKEY_SIZE) + && CryptoAlgorithm.match(SHA1WITHRSA2048, pubKeyBytes) + && pubKeyBytes[ALGORYTHM_CODE_SIZE] == PUBLIC.CODE; + } + + @Override + public PubKey resolvePubKey(byte[] pubKeyBytes) { + if (supportPubKey(pubKeyBytes)) { + return new PubKey(pubKeyBytes); + } else { + throw new CryptoException("pubKeyBytes are invalid!"); + } + } + + @Override + public boolean supportPrivKey(byte[] privKeyBytes) { + return privKeyBytes.length > (ALGORYTHM_CODE_SIZE + KEY_TYPE_BYTES + RAW_PRIVKEY_SIZE) + && CryptoAlgorithm.match(SHA1WITHRSA2048, privKeyBytes) + && privKeyBytes[ALGORYTHM_CODE_SIZE] == PRIVATE.CODE; + } + + @Override + public PrivKey resolvePrivKey(byte[] privKeyBytes) { + if (supportPrivKey(privKeyBytes)) { + return new PrivKey(privKeyBytes); + } else { + throw new CryptoException("privKeyBytes are invalid!"); + } + } + + @Override + public PubKey retrievePubKey(PrivKey privKey) { + + byte[] rawPrivKeyBytes = privKey.getRawKeyBytes(); + + if (rawPrivKeyBytes.length < RAW_PRIVKEY_SIZE) { + throw new CryptoException("This key has wrong format!"); + } + + if (privKey.getAlgorithm() != SHA1WITHRSA2048.code()) { + throw new CryptoException("This key is not SHA1WITHRSA2048 private key!"); + } + byte[] rawPubKeyBytes; + try { + RSAPrivateCrtKey rawPrivKey = (RSAPrivateCrtKey) RSAPrivateCrtKeyImpl.newKey(rawPrivKeyBytes); + BigInteger modulus = rawPrivKey.getModulus(); + BigInteger exponent = rawPrivKey.getPublicExponent(); + rawPubKeyBytes = KeyUtil.getEncodedSubjectPublicKeyInfo(RSA_ALGORITHM_IDENTIFIER, + new org.bouncycastle.asn1.pkcs.RSAPublicKey(modulus, exponent)); + } catch (InvalidKeyException e) { + throw new CryptoException(e.getMessage(), e); + } + + return new PubKey(SHA1WITHRSA2048, rawPubKeyBytes); + } + + @Override + public boolean supportDigest(byte[] digestBytes) { + return digestBytes.length == (RAW_SIGNATUREDIGEST_SIZE + ALGORYTHM_CODE_SIZE) + && CryptoAlgorithm.match(SHA1WITHRSA2048, digestBytes); + } + + @Override + public SignatureDigest resolveDigest(byte[] digestBytes) { + if (supportDigest(digestBytes)) { + return new SignatureDigest(digestBytes); + } else { + throw new CryptoException("digestBytes are invalid!"); + } + } + + @Override + public AsymmetricKeypair generateKeypair() { + + Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider()); + KeyPairGenerator generator; + PublicKey pubKey; + PrivateKey privKey; + try { + generator = KeyPairGenerator.getInstance("RSA", BouncyCastleProvider.PROVIDER_NAME); + generator.initialize(2048); + KeyPair keyPair = generator.generateKeyPair(); + pubKey = keyPair.getPublic(); + privKey = keyPair.getPrivate(); + } catch (NoSuchAlgorithmException | NoSuchProviderException e) { + throw new CryptoException(e.getMessage(), e); + } + + byte[] pubKeyBytes = pubKey.getEncoded(); + byte[] privKeyBytes = privKey.getEncoded(); + + return new AsymmetricKeypair(new PubKey(SHA1WITHRSA2048, pubKeyBytes), + new PrivKey(SHA1WITHRSA2048, privKeyBytes)); + } + + @Override + public CryptoAlgorithm getAlgorithm() { + return SHA1WITHRSA2048; + } +} diff --git a/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/SHA1WITHRSA4096SignatureFunction.java b/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/SHA1WITHRSA4096SignatureFunction.java new file mode 100644 index 00000000..2cde634b --- /dev/null +++ b/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/SHA1WITHRSA4096SignatureFunction.java @@ -0,0 +1,68 @@ +package com.jd.blockchain.crypto.service.pki; + +import com.jd.blockchain.crypto.*; + +import static com.jd.blockchain.crypto.service.pki.PKIAlgorithm.SHA1WITHRSA4096; + +/** + * @author zhanglin33 + * @title: SHA1WITHRSA4096SignatureFunction + * @description: TODO + * @date 2019-05-15, 17:13 + */ +public class SHA1WITHRSA4096SignatureFunction implements SignatureFunction { + @Override + public SignatureDigest sign(PrivKey privKey, byte[] data) { + return null; + } + + @Override + public boolean verify(SignatureDigest digest, PubKey pubKey, byte[] data) { + return false; + } + + @Override + public PubKey retrievePubKey(PrivKey privKey) { + return null; + } + + @Override + public boolean supportPrivKey(byte[] privKeyBytes) { + return false; + } + + @Override + public PrivKey resolvePrivKey(byte[] privKeyBytes) { + return null; + } + + @Override + public boolean supportPubKey(byte[] pubKeyBytes) { + return false; + } + + @Override + public PubKey resolvePubKey(byte[] pubKeyBytes) { + return null; + } + + @Override + public boolean supportDigest(byte[] digestBytes) { + return false; + } + + @Override + public SignatureDigest resolveDigest(byte[] digestBytes) { + return null; + } + + @Override + public AsymmetricKeypair generateKeypair() { + return null; + } + + @Override + public CryptoAlgorithm getAlgorithm() { + return SHA1WITHRSA4096; + } +} diff --git a/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/SM3WITHSM2SignatureFunction.java b/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/SM3WITHSM2SignatureFunction.java new file mode 100644 index 00000000..7bbea7a1 --- /dev/null +++ b/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/service/pki/SM3WITHSM2SignatureFunction.java @@ -0,0 +1,68 @@ +package com.jd.blockchain.crypto.service.pki; + +import com.jd.blockchain.crypto.*; + +import static com.jd.blockchain.crypto.service.pki.PKIAlgorithm.SM3WITHSM2; + +/** + * @author zhanglin33 + * @title: SM3WITHSM2SignatureFunction + * @description: TODO + * @date 2019-05-15, 16:39 + */ +public class SM3WITHSM2SignatureFunction implements SignatureFunction { + @Override + public SignatureDigest sign(PrivKey privKey, byte[] data) { + return null; + } + + @Override + public boolean verify(SignatureDigest digest, PubKey pubKey, byte[] data) { + return false; + } + + @Override + public PubKey retrievePubKey(PrivKey privKey) { + return null; + } + + @Override + public boolean supportPrivKey(byte[] privKeyBytes) { + return false; + } + + @Override + public PrivKey resolvePrivKey(byte[] privKeyBytes) { + return null; + } + + @Override + public boolean supportPubKey(byte[] pubKeyBytes) { + return false; + } + + @Override + public PubKey resolvePubKey(byte[] pubKeyBytes) { + return null; + } + + @Override + public boolean supportDigest(byte[] digestBytes) { + return false; + } + + @Override + public SignatureDigest resolveDigest(byte[] digestBytes) { + return null; + } + + @Override + public AsymmetricKeypair generateKeypair() { + return null; + } + + @Override + public CryptoAlgorithm getAlgorithm() { + return SM3WITHSM2; + } +} diff --git a/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/CSRBuilder.java b/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/utils/CSRBuilder.java similarity index 98% rename from source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/CSRBuilder.java rename to source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/utils/CSRBuilder.java index 9d84a952..6659134b 100644 --- a/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/CSRBuilder.java +++ b/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/utils/CSRBuilder.java @@ -1,5 +1,6 @@ -package com.jd.blockchain.crypto; +package com.jd.blockchain.crypto.utils; +import com.jd.blockchain.crypto.CryptoException; import org.bouncycastle.asn1.x500.X500Name; import org.bouncycastle.asn1.x500.X500NameBuilder; import org.bouncycastle.asn1.x500.style.BCStrictStyle; diff --git a/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/CertParser.java b/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/utils/CertParser.java similarity index 96% rename from source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/CertParser.java rename to source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/utils/CertParser.java index 004079c9..246c4759 100644 --- a/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/CertParser.java +++ b/source/crypto/crypto-pki/src/main/java/com/jd/blockchain/crypto/utils/CertParser.java @@ -1,5 +1,6 @@ -package com.jd.blockchain.crypto; +package com.jd.blockchain.crypto.utils; +import com.jd.blockchain.crypto.CryptoException; import org.bouncycastle.jce.provider.BouncyCastleProvider; import org.bouncycastle.util.encoders.Base64; import org.bouncycastle.util.io.pem.PemReader; @@ -15,7 +16,7 @@ import java.util.Date; /** * @author zhanglin33 * @title: CertParser - * @description: TODO + * @description: A parser for standard certificate, along with validation process * @date 2019-05-10, 15:17 */ public class CertParser { diff --git a/source/crypto/crypto-pki/src/main/resources/services/com.jd.blockchain.crypto.CryptoService b/source/crypto/crypto-pki/src/main/resources/services/com.jd.blockchain.crypto.CryptoService new file mode 100644 index 00000000..14a8682f --- /dev/null +++ b/source/crypto/crypto-pki/src/main/resources/services/com.jd.blockchain.crypto.CryptoService @@ -0,0 +1 @@ +com.jd.blockchain.crypto.service.pki.PKICryptoService \ No newline at end of file diff --git a/source/crypto/crypto-pki/src/test/java/com/jd/blockchain/crypto/CSRBuilderTest.java b/source/crypto/crypto-pki/src/test/java/com/jd/blockchain/crypto/utils/CSRBuilderTest.java similarity index 98% rename from source/crypto/crypto-pki/src/test/java/com/jd/blockchain/crypto/CSRBuilderTest.java rename to source/crypto/crypto-pki/src/test/java/com/jd/blockchain/crypto/utils/CSRBuilderTest.java index a1bb5645..382ecefe 100644 --- a/source/crypto/crypto-pki/src/test/java/com/jd/blockchain/crypto/CSRBuilderTest.java +++ b/source/crypto/crypto-pki/src/test/java/com/jd/blockchain/crypto/utils/CSRBuilderTest.java @@ -1,5 +1,6 @@ -package com.jd.blockchain.crypto; +package com.jd.blockchain.crypto.utils; +import com.jd.blockchain.crypto.utils.CSRBuilder; import org.bouncycastle.asn1.ASN1Encoding; import org.bouncycastle.asn1.DERSet; import org.bouncycastle.asn1.pkcs.CertificationRequestInfo; diff --git a/source/crypto/crypto-pki/src/test/java/com/jd/blockchain/crypto/CertParserTest.java b/source/crypto/crypto-pki/src/test/java/com/jd/blockchain/crypto/utils/CertParserTest.java similarity index 97% rename from source/crypto/crypto-pki/src/test/java/com/jd/blockchain/crypto/CertParserTest.java rename to source/crypto/crypto-pki/src/test/java/com/jd/blockchain/crypto/utils/CertParserTest.java index 64b55d4a..59ad3814 100644 --- a/source/crypto/crypto-pki/src/test/java/com/jd/blockchain/crypto/CertParserTest.java +++ b/source/crypto/crypto-pki/src/test/java/com/jd/blockchain/crypto/utils/CertParserTest.java @@ -1,5 +1,6 @@ -package com.jd.blockchain.crypto; +package com.jd.blockchain.crypto.utils; +import com.jd.blockchain.crypto.utils.CertParser; import org.junit.Test; import static org.junit.Assert.assertEquals;