cert 初步测试通过

src/main/java/minsecurity/Common.java

@@ -25,6 +25,10 @@ public class Common {
     public static final int ContentCommitment = 0;
     public static final int DataEncipherment = 1;
     public static final int CertSign = 2;
+    /* tpyeOfCert */
+    public static final int InnerCertificate = 0;
+    public static final int Certificate = 1;
+    public static final int TbsCertificate = 2;
     // public enum Storage {
     //     SQLITE;
     // }

src/main/java/minsecurity/certificate/cert/CertUtils.java

@@ -1,8 +1,14 @@
 package minsecurity.certificate.cert;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import minsecurity.Common;
 import minsecurity.crypto.PublicKeyInterface;
-import minsecurity.crypto.sm2.Sm2PublicKey;
+import minsecurity.crypto.PublicKeyUtils;
+import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
 
 /*
  * @Author: hongyu guo
@@ -12,7 +18,7 @@ import minsecurity.crypto.sm2.Sm2PublicKey;
  * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室
  */
 public class CertUtils {
-
+    private static final org.slf4j.Logger logger = LoggerFactory.getLogger(CertUtils.class);
     public static final int VERSION1 = 1;
 
     public static InnerCertificate parseCertToInnerCert(Certificate certificate){
@@ -42,7 +48,7 @@ public class CertUtils {
 
         certificate.setVersion(i.getTbsCertificate().getVersion());
         certificate.setSerialNumber(i.getTbsCertificate().getSerialNumber());
-        PublicKeyInterface publicKey = unMarshalPublicKey(i.getTbsCertificate().getPublicKey(),i.getSignatureAlgorithm());
+        PublicKeyInterface publicKey = PublicKeyUtils.unMarshalPublicKey(i.getTbsCertificate().getPublicKey(),i.getSignatureAlgorithm());
         certificate.setPublicKey(publicKey);
         certificate.setSignature(i.getSignatureValue());
         certificate.setSignatureAlgorithm(i.getTbsCertificate().getSignatureAlgorithm());
@@ -58,36 +64,29 @@ public class CertUtils {
         return certificate;
     }
 
-    public static PublicKeyInterface unMarshalPublicKey(byte[] bytesOfPublicKey, int algorithm) {
-        if (bytesOfPublicKey == null || bytesOfPublicKey.length == 0) {
-            return null;
-        }
-        switch (algorithm) {
-            case Common.SM2:
-                Sm2PublicKey sm2PublicKey = new Sm2PublicKey();
-                sm2PublicKey.setBytes(bytesOfPublicKey);
-                return sm2PublicKey;
-            default:
-                return null;
-        }
-    }
-
     public static boolean checkDuration(InnerCertificate innerCertificate){
         long curTime = System.currentTimeMillis();
-        if(innerCertificate.getTbsCertificate().getNotAfter() > curTime)
+        // logger.debug("current time: {}", curTime);
+        if(innerCertificate.getTbsCertificate().getNotAfter() < curTime)
             return false;
-        if(innerCertificate.getTbsCertificate().getNotBefore() < curTime)
+        if(innerCertificate.getTbsCertificate().getNotBefore() > curTime)
             return false;
         return true;
     }
 
+    // cur       = 1615018693993
+    // notbefore = 1615018693858
+    // notafter  = 1615018694058
+
 
     public static boolean checkSign(InnerCertificate cert, PublicKeyInterface publicKey) throws Exception {
         switch (cert.getTbsCertificate().getSignatureAlgorithm()){
             case Common.SM3withSM2:
                 // TODO: 证书序列化方法
-                byte[] bytesOfCert = serialization(cert);
+                byte[] bytesOfCert = serialization(cert.getTbsCertificate());
+                logger.debug("验签序列化bytes: {}", ByteUtils.toHexString(bytesOfCert));
                 // byte[] digest = HashAlgo.sm3(bytesOfCert);
+                logger.debug("验签sign: {}", ByteUtils.toHexString(cert.getSignatureValue()));
                 return publicKey.verify(bytesOfCert, cert.getSignatureValue());
             default:
                 throw new Exception("未定义的签名方法");
@@ -95,13 +94,49 @@ public class CertUtils {
     }
 
     // TODO: 证书序列化方法
+    public static byte[] serialization(TbsCertificate tbsCertificate){
+        ObjectMapper mapper = new ObjectMapper();
+        byte[] bytesOfCertJson;
+        try {
+            bytesOfCertJson = mapper.writeValueAsBytes(tbsCertificate);
+            return bytesOfCertJson;
+        } catch (JsonProcessingException e) {
+            e.printStackTrace();
+        }
+        return new byte[0];
+    }
+
     public static byte[] serialization(InnerCertificate innerCertificate){
+        ObjectMapper mapper = new ObjectMapper();
+        byte[] bytesOfCertJson;
+        try {
+            bytesOfCertJson = mapper.writeValueAsBytes(innerCertificate);
+            return bytesOfCertJson;
+        } catch (JsonProcessingException e) {
+            e.printStackTrace();
+        }
         return new byte[0];
     }
 
     // TODO: 证书反序列化
-    public static InnerCertificate deserialization(byte[] bytesOfCert){
-        return new InnerCertificate();
+    public static Object deserialization(byte[] bytesOfCert, int typeOfCert){
+        ObjectMapper mapper = new ObjectMapper();
+        try {
+            switch (typeOfCert) {
+                case Common.TbsCertificate:
+                    TbsCertificate tbsCertificate = mapper.readValue(bytesOfCert, TbsCertificate.class);
+                    return tbsCertificate;
+                case Common.InnerCertificate:
+                    InnerCertificate innerCertificate = mapper.readValue(bytesOfCert, InnerCertificate.class);
+                    return innerCertificate;
+                default:
+                    throw new CertException("未知证书类型");
+            }
+        } catch (IOException | CertException e) {
+            e.printStackTrace();
+        }
+        return null;
     }
 
+
 }

src/main/java/minsecurity/certificate/cert/Certificate.java

@@ -5,16 +5,16 @@ import minsecurity.crypto.HashAlgo;
 import minsecurity.crypto.PrivateKeyInterface;
 import minsecurity.crypto.PublicKeyInterface;
 import minsecurity.crypto.Sm4;
+import minsecurity.crypto.sm2.Sm2PublicKey;
+import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;
+import org.slf4j.LoggerFactory;
 
 
 import javax.crypto.BadPaddingException;
 import javax.crypto.IllegalBlockSizeException;
 import javax.crypto.NoSuchPaddingException;
 import java.lang.reflect.Array;
-import java.security.InvalidAlgorithmParameterException;
-import java.security.InvalidKeyException;
-import java.security.NoSuchAlgorithmException;
-import java.security.NoSuchProviderException;
+import java.security.*;
 import java.util.Base64;
 
 import static minsecurity.certificate.cert.CertUtils.*;
@@ -28,6 +28,8 @@ import static minsecurity.certificate.cert.CertUtils.*;
  * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室
  */
 public class Certificate {
+    private static final org.slf4j.Logger logger = LoggerFactory.getLogger(Certificate.class);
+
     private int version;
     private long serialNumber;
     private PublicKeyInterface publicKey;
@@ -174,24 +176,28 @@ public class Certificate {
 
 
     public void signCert(PrivateKeyInterface priv) throws Exception {
-        InnerCertificate inner = CertUtils.parseCertToInnerCert(this);
-        byte[] bytesOfCert = serialization(CertUtils.parseCertToInnerCert(this));
+        byte[] bytesOfCert = serialization(CertUtils.parseCertToInnerCert(this).getTbsCertificate());
+        logger.debug("签名序列化bytes: {}", ByteUtils.toHexString(bytesOfCert));
         switch (this.signatureAlgorithm){
             case Common.SM3withSM2:
                 // byte[] digest = HashAlgo.sm3(bytesOfCert);
-                byte[] sign = priv.sign(bytesOfCert);
-                this.signature = sign;
-                return;
+                this.signature = priv.sign(bytesOfCert);
+                logger.debug("签名sign: {}", ByteUtils.toHexString(this.signature));
+                // Sm2PublicKey sm2PublicKey = (Sm2PublicKey) this.publicKey;
+                // logger.debug("临时验签: {}", sm2PublicKey.verify(bytesOfCert, signature));
+                break;
             default:
+                logger.debug("signAlgo: {}",this.signatureAlgorithm);
                 throw new Exception("未定义的签名方法");
         }
     }
 
-    public boolean verifyCert(Certificate ca, Certificate sub) throws Exception {
+    public static boolean verifyCert(Certificate ca, Certificate sub) throws Exception {
         InnerCertificate innerCertificate = CertUtils.parseCertToInnerCert(sub);
         switch (innerCertificate.getTbsCertificate().getVersion()){
             case CertUtils.VERSION1:
                 boolean isValid = CertUtils.checkDuration(innerCertificate);
+                logger.debug("有效期内：{}", isValid);
                 if(!isValid)
                     return false;
                 if(sub.isCA()){
@@ -210,7 +216,7 @@ public class Certificate {
         }
         byte[] bytesOfCert = serialization(CertUtils.parseCertToInnerCert(this));
         byte[] ret = new byte[0];
-        if(passwd.length > 0){
+        if(passwd != null && passwd.length > 0){
             byte[] hashPasswd = HashAlgo.sm3(passwd);
             if( hashPasswd.length == 32){
                 for(int i = 0; i < 16; i++){
@@ -223,10 +229,12 @@ public class Certificate {
             switch (symAlgoMode){
                 case Common.SM4CBC:{
                     // TODO: PADDING???  IV?????
-                    ret = Sm4.encrypt_CBC_NoPadding(sm4Key, new byte[16],bytesOfCert);
+                    ret = Sm4.encrypt_CBC_Padding(sm4Key, new byte[16],bytesOfCert);
+                    break;
                 }
                 case Common.SM4ECB:{
-                    ret = Sm4.encrypt_ECB_NoPadding(sm4Key, bytesOfCert);
+                    ret = Sm4.encrypt_ECB_Padding(sm4Key, bytesOfCert);
+                    break;
                 }
                 default:
                     throw new CertException("未定义的对称加密算法");
@@ -237,13 +245,13 @@ public class Certificate {
         return Base64.getEncoder().encodeToString(ret);
     }
 
-    public Certificate fromPem(String pemString, byte[] passwd, int symAlgoMode) throws CertException, BadPaddingException, NoSuchPaddingException, InvalidAlgorithmParameterException, NoSuchAlgorithmException, IllegalBlockSizeException, NoSuchProviderException, InvalidKeyException {
+    public static Certificate fromPem(String pemString, byte[] passwd, int symAlgoMode) throws CertException, BadPaddingException, NoSuchPaddingException, InvalidAlgorithmParameterException, NoSuchAlgorithmException, IllegalBlockSizeException, NoSuchProviderException, InvalidKeyException {
         if(pemString == null || pemString.equals("")){
             throw new CertException("pem串为空");
         }
         byte[] bytesOfPem = Base64.getDecoder().decode(pemString);
         byte[] bytesOfCert = new byte[0];
-        if(passwd.length > 0){
+        if(passwd != null && passwd.length > 0){
             byte[] hashPasswd = HashAlgo.sm3(passwd);
             if( hashPasswd.length == 32){
                 for(int i = 0; i < 16; i++){
@@ -262,7 +270,7 @@ public class Certificate {
         } else {
             bytesOfCert = bytesOfPem;
         }
-        InnerCertificate innerCertificate = deserialization(bytesOfCert);
+        InnerCertificate innerCertificate = (InnerCertificate) deserialization(bytesOfCert, Common.InnerCertificate);
         return CertUtils.parseInnerCertToCert(innerCertificate);
     }
 

src/main/java/minsecurity/certificate/cert/InnerCertificate.java

@@ -1,6 +1,9 @@
 package minsecurity.certificate.cert;
 
 import minsecurity.Common;
+import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;
+
+import java.util.Arrays;
 
 /*
  * @Author: hongyu guo
@@ -37,4 +40,13 @@ public class InnerCertificate {
     public void setSignatureValue(byte[] signatureValue) {
         this.signatureValue = signatureValue;
     }
+
+    @Override
+    public String toString() {
+        return "InnerCertificate{" +
+                "tbsCertificate=" + tbsCertificate.toString() +
+                ", signatureAlgorithm=" + signatureAlgorithm +
+                ", signatureValue=" + ByteUtils.toHexString(signatureValue) +
+                '}';
+    }
 }

src/main/java/minsecurity/certificate/cert/TbsCertificate.java

@@ -1,6 +1,9 @@
 package minsecurity.certificate.cert;
 
 import minsecurity.Common;
+import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;
+
+import java.util.Arrays;
 
 /*
  * @Author: hongyu guo
@@ -142,4 +145,23 @@ public class TbsCertificate {
     public void setTimestamp(long timestamp) {
         this.timestamp = timestamp;
     }
+
+
+    @Override
+    public String toString() {
+        return "TbsCertificate{" +
+                "version=" + version +
+                ", serialNumber=" + serialNumber +
+                ", publicKey=" + ByteUtils.toHexString(publicKey) +
+                ", signatureAlgorithm=" + signatureAlgorithm +
+                ", publicKeyAlgorithm=" + publicKeyAlgorithm +
+                ", issueTo='" + issueTo + '\'' +
+                ", issuer='" + issuer + '\'' +
+                ", notBefore=" + notBefore +
+                ", notAfter=" + notAfter +
+                ", keyUsage=" + keyUsage +
+                ", isCA=" + isCA +
+                ", timestamp=" + timestamp +
+                '}';
+    }
 }

src/main/java/minsecurity/crypto/PublicKeyUtils.java

@@ -0,0 +1,27 @@
+package minsecurity.crypto;
+
+import minsecurity.Common;
+import minsecurity.crypto.sm2.Sm2PublicKey;
+
+/*
+ * @Author: hongyu guo
+ * @Description:
+ * @Version: 1.0.0
+ * @Date: 16:02 2021/03/06
+ * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室
+ */
+public class PublicKeyUtils {
+    public static PublicKeyInterface unMarshalPublicKey(byte[] bytesOfPublicKey, int algorithm) {
+        if (bytesOfPublicKey == null || bytesOfPublicKey.length == 0) {
+            return null;
+        }
+        switch (algorithm) {
+            case Common.SM2:
+                Sm2PublicKey sm2PublicKey = new Sm2PublicKey();
+                sm2PublicKey.setBytes(bytesOfPublicKey);
+                return sm2PublicKey;
+            default:
+                return null;
+        }
+    }
+}

src/main/java/minsecurity/crypto/sm2/Sm2PrivateKey.java

@@ -22,9 +22,9 @@ import java.security.SecureRandom;
  */
 public class Sm2PrivateKey implements PrivateKeyInterface {
 
-    Sm2PrivateKey(){}
+    public Sm2PrivateKey(){}
     
-    Sm2PrivateKey(byte[] d) {
+    public Sm2PrivateKey(byte[] d) {
         if(d.length == 32 || d.length == 33)
             privateKey = new ECPrivateKeyParameters(new BigInteger(d), Sm2Base.DOMAIN_PARAMS);
         else {
@@ -35,7 +35,7 @@ public class Sm2PrivateKey implements PrivateKeyInterface {
             }
         }
     }
-    Sm2PrivateKey(byte[] d, ECDomainParameters parameters){
+    public Sm2PrivateKey(byte[] d, ECDomainParameters parameters){
         if(d.length == 32 || d.length == 33)
             privateKey = new ECPrivateKeyParameters(new BigInteger(d), parameters);
         else {

src/main/java/util/ByteHelper.java

@@ -1,7 +1,7 @@
-package main.java.util;
+package util;
 
 
-import main.java.encoding.VlInt;
+import encoding.VlInt;
 
 /*
  * @Author: Wang Feng