testsigandenvdata.java

进行与数字证书相关开发必须的java源码

// Decompiled by Jad v1.5.7g. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi 
// Source File Name:   TestSigAndEnvData.java

package jit.test;

import java.io.FileInputStream;
import java.io.PrintStream;
import jit.asn1.ASN1OctetString;
import jit.asn1.DERObjectIdentifier;
import jit.asn1.pkcs.PKCSObjectIdentifiers;
import jit.asn1.pkcs.pkcs12.Pfx;
import jit.asn1.pkcs.pkcs7.*;
import jit.asn1.x509.*;
import jit.asn1parser.pkcs.PKCS12Parser;
import jit.asn1parser.pkcs.pkcs7.SigAndEnvelopParser;
import jit.asn1parser.x509.SPKIParser;
import jit.asn1parser.x509.X509Cert;
import jit.jcrypto.*;
import jit.jcrypto.soft.JMechanism;
import jit.math.BigInteger;

public class TestSigAndEnvData
{

    public TestSigAndEnvData()
    {
    }

    public ContentInfo generateSEEnvelop(Session session, int selection, String filePath, JKey sigPrvKey, X509Cert sigCert, String recipientCertPath, boolean isExtend)
    {
        try
        {
            SigAndEnvelopParser parser = new SigAndEnvelopParser(session);
            FileInputStream fin = new FileInputStream(filePath);
            byte sourceData[] = new byte[fin.available()];
            fin.read(sourceData);
            fin.close();
            Mechanism keyGenM = null;
            DERObjectIdentifier contentEncryptAlg = null;
            switch(selection)
            {
            case 1: // '\001'
                keyGenM = new JMechanism(288);
                contentEncryptAlg = PKCSObjectIdentifiers.desCBCEncryption;
                break;

            case 2: // '\002'
                keyGenM = new JMechanism(256);
                contentEncryptAlg = PKCSObjectIdentifiers.rc2CBCEncryption;
                break;

            case 3: // '\003'
                keyGenM = new JMechanism(305);
                contentEncryptAlg = PKCSObjectIdentifiers.des3CBCEncryption;
                break;

            default:
                System.out.println(String.valueOf(String.valueOf((new StringBuffer("the selection: ")).append(selection).append(" for generate SignedData is not suitable."))));
                ContentInfo contentinfo1 = null;
                return contentinfo1;
            }
            JKey contentEncryptionKey = session.generateKey(keyGenM, 0);
            byte bContentEncryptionKey[] = contentEncryptionKey.getKey();
            EncryptedContentInfo encryptedContentInfo = parser.generateEncryptedContentInfo(PKCSObjectIdentifiers.data, contentEncryptAlg, sourceData, contentEncryptionKey);
            X509Cert recipientCert = new X509Cert(recipientCertPath);
            SubjectPublicKeyInfo spki = recipientCert.getSubjectPublicKeyInfo();
            SPKIParser spkiParser = new SPKIParser();
            JKey recipientPubKey = spkiParser.getPublicKey(spki);
            IssuerAndSerialNumber recipientIssuerAndSN = getIASN(recipientCert);
            IssuerAndSerialNumber signerIssuerAndSN = getIASN(sigCert);
            AlgorithmIdentifier keyEncryptionAlg = new AlgorithmIdentifier(PKCSObjectIdentifiers.rsaEncryption);
            RecipientInfo recipientInfo = parser.generateRecipientInfo(recipientIssuerAndSN, keyEncryptionAlg, bContentEncryptionKey, recipientPubKey);
            DERObjectIdentifier signatureAlgOID = PKCSObjectIdentifiers.sha1WithRSAEncryption;
            SignerInfo signerInfo = null;
            if(isExtend)
                signerInfo = parser.generateSignerInfo_extendC(encryptedContentInfo.getEncryptedContent().getOctets(), signerIssuerAndSN, signatureAlgOID, sigPrvKey);
            else
                signerInfo = parser.generateSignerInfo(sourceData, signerIssuerAndSN, signatureAlgOID, PKCSObjectIdentifiers.desCBCEncryption, sigPrvKey, contentEncryptionKey);
            AlgorithmIdentifier digestAlg = new AlgorithmIdentifier(PKCSObjectIdentifiers.sha1);
            SignedAndEnvelopedData sigAndEnvData = parser.generateSigAndEnvelop(recipientInfo, digestAlg, encryptedContentInfo, null, null, signerInfo);
            ContentInfo contentInfo = parser.generateSigAndEnvelopContent(sigAndEnvData);
            ContentInfo contentinfo2 = contentInfo;
            return contentinfo2;
        }
        catch(Exception ex)
        {
            System.out.println(ex.toString());
        }
        ContentInfo contentinfo = null;
        return contentinfo;
    }

    public boolean verifySEEnvelop(Session session, ContentInfo contentInfo, String signCertPath, String pfxPath, char password[], boolean isExtend)
    {
        try
        {
            SigAndEnvelopParser parser = new SigAndEnvelopParser(session);
            SignedAndEnvelopedData sigAndEnvelop = parser.getSigAndEnvelopFromContentInfo(contentInfo);
            X509Cert signCert = new X509Cert(signCertPath);
            PKCS12Parser p12 = new PKCS12Parser();
            p12.load(pfxPath);
            Pfx pfx = p12.getPfx();
            byte sourceData[] = null;
            if(isExtend)
                sourceData = parser.decodeSigAndEnvelop_extendC(sigAndEnvelop, pfx, password, signCert);
            else
                sourceData = parser.decodeSigAndEnvelop(sigAndEnvelop, pfx, password, signCert);
            boolean flag1 = true;
            return flag1;
        }
        catch(Exception ex)
        {
            System.out.println(ex.toString());
        }
        boolean flag = false;
        return flag;
    }

    private IssuerAndSerialNumber getIASN(X509Cert cert)
    {
        try
        {
            BigInteger sn = cert.getSerialNumber();
            X509Name issuer = cert.getIssuer();
            IssuerAndSerialNumber issuerAndSN = new IssuerAndSerialNumber(issuer, sn);
            IssuerAndSerialNumber issuerandserialnumber1 = issuerAndSN;
            return issuerandserialnumber1;
        }
        catch(Exception ex)
        {
            System.out.println(ex.toString());
        }
        IssuerAndSerialNumber issuerandserialnumber = null;
        return issuerandserialnumber;
    }

    public static void main(String args[])
    {
        try
        {
            JCrypto jcrypto = new JCrypto();
            jcrypto.initialize(0, null);
            Session session = jcrypto.openSession(0);
            TestSigAndEnvData test = new TestSigAndEnvData();
            PKCS12Parser p12 = new PKCS12Parser();
            p12.load("c:/lijian.pfx");
            p12.decrypt("1".toCharArray());
            JKey sigKey = p12.getPrivateKey();
            X509Cert certs[] = p12.getCertificates();
            X509Cert sigCert = certs[0];
            ContentInfo contentInfo = test.generateSEEnvelop(session, 1, "c:/1.txt", sigKey, sigCert, "c:/lijian.cer", false);
            boolean f = test.verifySEEnvelop(session, contentInfo, "c:/lijian.cer", "c:/lijian.pfx", "1".toCharArray(), false);
            System.out.println(f);
        }
        catch(Exception ex)
        {
            System.out.println(ex.toString());
        }
    }
}