package minsecurity.certificate.x509;

import minsecurity.Common;
import minsecurity.certificate.X509.X509CertMaker;
import minsecurity.certificate.X509.X509CertUtil;
import minsecurity.crypto.sm2.SM2Base;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.pqc.math.linearalgebra.ByteUtils;
import org.bouncycastle.util.io.pem.PemObject;
import org.bouncycastle.util.io.pem.PemWriter;
import org.junit.Test;
import static org.junit.Assert.*;
import org.slf4j.LoggerFactory;
import util.FileUtil;

import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.StringWriter;
import java.security.*;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.spec.PKCS8EncodedKeySpec;

import static minsecurity.certificate.X509.X509CertMaker.makeRootCA;

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

    // WARNING: X509不需要测试!!!!!!!
    // WARNING: X509不需要测试!!!!!!!
    // WARNING: X509不需要测试!!!!!!!
    // WARNING: X509不需要测试!!!!!!!
    // WARNING: X509不需要测试!!!!!!!


    static {
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
    }
    private static final org.slf4j.Logger logger = LoggerFactory.getLogger(TestX509.class);
    private static final Provider BC = new BouncyCastleProvider();

    @Test
    public void testRebuildKeyPair(){
        try {

            KeyPair rootKP = SM2Base.generateKeyPair();
            X509Certificate rootCA = makeRootCA(rootKP,"CN","MIN",
                    "MIN-GROUP","MIN ROOT CA",
                    365L * 24 * 60 * 60 * 1000, "SM3withSM2");
            FileUtil.writeFile("./target/root.cer",rootCA.getEncoded());
            FileUtil.writeFile("./target/root.priv",rootKP.getPrivate().getEncoded());
            rootCA.verify(rootKP.getPublic());

            System.out.println(rootKP.getPrivate().getFormat());
            CertificateFactory fact = CertificateFactory.getInstance(Common.X509, Common.BC_NAME);
            X509Certificate cert =
                    (X509Certificate) fact.generateCertificate(
                            new ByteArrayInputStream(rootCA.getEncoded()));

            PublicKey publicKey = cert.getPublicKey();
            KeyFactory keyFac = KeyFactory.getInstance("EC", BouncyCastleProvider.PROVIDER_NAME);
            byte[] privBytes = FileUtil.readFile("./target/root.priv");
            PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(privBytes);
            PrivateKey privateKey = keyFac.generatePrivate(keySpec);
            KeyPair rootKeyPair = new KeyPair(publicKey, privateKey);

            logger.debug("origin: {}", ByteUtils.toHexString(rootKP.getPrivate().getEncoded()));
            logger.debug("rebuild:{}", ByteUtils.toHexString(rootKeyPair.getPrivate().getEncoded()));

            logger.debug("origin: {}", ByteUtils.toHexString(rootKP.getPublic().getEncoded()));
            logger.debug("rebuild:{}", ByteUtils.toHexString(rootKeyPair.getPublic().getEncoded()));

            KeyPair subKeyPair = SM2Base.generateKeyPair();
            X509Certificate subCert =
                    X509CertMaker.makeSubCACert(rootKeyPair,
                            cert,
                            subKeyPair,
                            "c","o","ou","cn",
                            365L * 24 * 60 * 60 * 1000,
                            "SM3withSM2");
            FileUtil.writeFile("./target/sub.cer",subCert.getEncoded());

            subCert.verify(rootKeyPair.getPublic());
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Test
    public void testVerify() throws IOException, CertificateException, NoSuchProviderException {
        //  保存在本地的已有证书
        byte[] bytesOfCert = FileUtil.readFile("./target/root.cer");
        CertificateFactory fact = CertificateFactory.getInstance(Common.X509, "BC");
        X509Certificate cert =
                (X509Certificate) fact.generateCertificate(
                        new ByteArrayInputStream(bytesOfCert));
        assertFalse(X509CertUtil.isExpired(cert));
        assertTrue(X509CertUtil.isValid(cert,cert.getPublicKey()));
    }

    @Test
    public void testX509toPem() throws IOException, CertificateException, NoSuchProviderException {
        byte[] bytesOfCert = FileUtil.readFile("./target/root.cer");
        CertificateFactory fact = CertificateFactory.getInstance(Common.X509, "BC");
        X509Certificate cert =
                (X509Certificate) fact.generateCertificate(
                        new ByteArrayInputStream(bytesOfCert));
        StringWriter sw = new StringWriter();
        PemObject pemCSR = new PemObject("CERTIFICATE REQUEST", cert.getEncoded());
        PemWriter pemWriter = new PemWriter(sw);
        pemWriter.writeObject(pemCSR);
        pemWriter.close();
        logger.debug(sw.toString());
    }
}