min-dev-java/src/main/java/minsecurity/certificate/cert/CertUtils.java

package minsecurity.certificate.cert;

import minsecurity.Common;
import minsecurity.crypto.PublicKeyInterface;
import minsecurity.crypto.sm2.Sm2PublicKey;

/*
 * @Author: hongyu guo
 * @Description:
 * @Version: 1.0.0
 * @Date: 17:09 2021/03/05
 * @Copyright: MIN-Group；国家重大科技基础设施——未来网络北大实验室；深圳市信息论与未来网络重点实验室
 */
public class CertUtils {

    public static final int VERSION1 = 1;

    public static InnerCertificate parseCertToInnerCert(Certificate certificate){
        TbsCertificate tbsCertificate = new TbsCertificate();
        tbsCertificate.setVersion(certificate.getVersion());
        tbsCertificate.setSerialNumber(certificate.getSerialNumber());
        tbsCertificate.setPublicKey(certificate.getPublicKey().getBytes());
        tbsCertificate.setSignatureAlgorithm(certificate.getSignatureAlgorithm());
        tbsCertificate.setPublicKeyAlgorithm(certificate.getPublicKeyAlgorithm());
        tbsCertificate.setIssueTo(certificate.getIssueTo());
        tbsCertificate.setIssuer(certificate.getIssuer());
        tbsCertificate.setNotAfter(certificate.getNotAfter());
        tbsCertificate.setNotBefore(certificate.getNotBefore());
        tbsCertificate.setKeyUsage(certificate.getKeyUsage());
        tbsCertificate.setCA(certificate.isCA());
        tbsCertificate.setTimestamp(certificate.getTimestamp());

        InnerCertificate innerCertificate = new InnerCertificate();
        innerCertificate.setSignatureAlgorithm(certificate.getSignatureAlgorithm());
        innerCertificate.setSignatureValue(certificate.getSignature());
        innerCertificate.setTbsCertificate(tbsCertificate);
        return innerCertificate;
    }

    public static Certificate parseInnerCertToCert(InnerCertificate i){
        Certificate certificate = new Certificate();

        certificate.setVersion(i.getTbsCertificate().getVersion());
        certificate.setSerialNumber(i.getTbsCertificate().getSerialNumber());
        PublicKeyInterface publicKey = unMarshalPublicKey(i.getTbsCertificate().getPublicKey(),i.getSignatureAlgorithm());
        certificate.setPublicKey(publicKey);
        certificate.setSignature(i.getSignatureValue());
        certificate.setSignatureAlgorithm(i.getTbsCertificate().getSignatureAlgorithm());
        certificate.setPublicKeyAlgorithm(i.getTbsCertificate().getPublicKeyAlgorithm());
        certificate.setIssueTo(i.getTbsCertificate().getIssueTo());
        certificate.setIssuer(i.getTbsCertificate().getIssuer());
        certificate.setNotBefore(i.getTbsCertificate().getNotBefore());
        certificate.setNotAfter(i.getTbsCertificate().getNotAfter());
        certificate.setKeyUsage(i.getTbsCertificate().getKeyUsage());
        certificate.setCA(i.getTbsCertificate().isCA());
        certificate.setTimestamp(i.getTbsCertificate().getTimestamp());

        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)
            return false;
        if(innerCertificate.getTbsCertificate().getNotBefore() < curTime)
            return false;
        return true;
    }


    public static boolean checkSign(InnerCertificate cert, PublicKeyInterface publicKey) throws Exception {
        switch (cert.getTbsCertificate().getSignatureAlgorithm()){
            case Common.SM3withSM2:
                // TODO: 证书序列化方法
                byte[] bytesOfCert = serialization(cert);
                // byte[] digest = HashAlgo.sm3(bytesOfCert);
                return publicKey.verify(bytesOfCert, cert.getSignatureValue());
            default:
                throw new Exception("未定义的签名方法");
        }
    }

    // TODO: 证书序列化方法
    public static byte[] serialization(InnerCertificate innerCertificate){
        return new byte[0];
    }

    // TODO: 证书反序列化
    public static InnerCertificate deserialization(byte[] bytesOfCert){
        return new InnerCertificate();
    }

}