pkcs10parser.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:   PKCS10Parser.java

package jit.asn1parser.pkcs;

import java.util.Vector;
import jit.asn1.*;
import jit.asn1.pkcs.PKCSObjectIdentifiers;
import jit.asn1.pkcs.pkcs10.CertificationRequest;
import jit.asn1.pkcs.pkcs10.CertificationRequestInfo;
import jit.asn1.x509.*;
import jit.asn1.x9.X9ECParameters;
import jit.asn1parser.Parser;
import jit.crypto.CipherParameters;
import jit.crypto.params.*;
import jit.cryptolib.toolkit.Crypto;
import jit.jcrypto.*;
import jit.jcrypto.soft.JMechanism;
import jit.math.ec.ECCurve;
import jit.math.ec.ECPoint;

public class PKCS10Parser
{

    private Session session;

    public PKCS10Parser(Session session)
    {
        this.session = null;
        this.session = session;
    }

    public CertificationRequestInfo generateCertRequestInfo(X509Name subject, SubjectPublicKeyInfo spki, ASN1Set attributes)
    {
        return new CertificationRequestInfo(subject, spki, attributes);
    }

    public CertificationRequest generateCertRequest(CertificationRequestInfo cri, AlgorithmIdentifier algId, DERBitString signature)
    {
        return new CertificationRequest(cri, algId, signature);
    }

    private DERBitString generateRSASignature(byte data[], JKey prvKey, DERObjectIdentifier sigId)
        throws Exception
    {
        AlgorithmIdentifier digestAlg = null;
        Mechanism digestM = null;
        Mechanism cryptoM = new JMechanism(1);
        if(sigId.equals(PKCSObjectIdentifiers.sha1WithRSAEncryption))
        {
            digestM = new JMechanism(544);
            digestAlg = new AlgorithmIdentifier(PKCSObjectIdentifiers.sha1);
        } else
        if(sigId.equals(PKCSObjectIdentifiers.md2WithRSAEncryption))
        {
            digestM = new JMechanism(512);
            digestAlg = new AlgorithmIdentifier(PKCSObjectIdentifiers.md2);
        } else
        if(sigId.equals(PKCSObjectIdentifiers.md5WithRSAEncryption))
        {
            digestM = new JMechanism(528);
            digestAlg = new AlgorithmIdentifier(PKCSObjectIdentifiers.md5);
        } else
        {
            throw new Exception(String.valueOf(String.valueOf((new StringBuffer("the signatrue algrothem:")).append(sigId.getId()).append(" can't use in RSA signatrue mod."))));
        }
        byte digest_data[] = session.digest(digestM, data);
        DEROctetString derO = new DEROctetString(digest_data);
        DEREncodableVector derV = new DEREncodableVector();
        derV.add(digestAlg);
        derV.add(derO);
        DERSequence derS = new DERSequence(derV);
        byte digestInfo[] = Parser.writeDERObj2Bytes(derS);
        byte signature[] = session.encrypt(cryptoM, prvKey, digestInfo);
        return new DERBitString(signature);
    }

    private DERBitString genrateECCSignatrue(byte data[], JKey prvKey, DERObjectIdentifier sigId)
        throws Exception
    {
        if(!sigId.equals(PKCSObjectIdentifiers.sha1WithECEncryption))
        {
            throw new Exception("The MessageDigest algorithm in ECC Signature must be SHA1.");
        } else
        {
            Mechanism sigM = new JMechanism(1027);
            byte signature[] = session.sign(sigM, prvKey, data);
            signature = Crypto.encodeECDSASignature(signature);
            return new DERBitString(signature);
        }
    }

    public DERBitString generateSignature(byte data[], JKey jPriKey, DERObjectIdentifier sigId)
        throws Exception
    {
        if(jPriKey.getKeyType() == 2)
            return generateRSASignature(data, jPriKey, sigId);
        if(jPriKey.getKeyType() == 1002)
            return genrateECCSignatrue(data, jPriKey, sigId);
        else
            throw new Exception("PKCS10Parser: can't generate signature with keyType:".concat(String.valueOf(String.valueOf(jPriKey.getKeyType()))));
    }

    public SubjectPublicKeyInfo generateSPKI(JKey jPubKey)
        throws Exception
    {
        CipherParameters pubKey = Parser.conver2CipherParam(jPubKey);
        if(pubKey instanceof RSAKeyParameters)
            return generateRSASPKI(pubKey);
        if(pubKey instanceof ECKeyParameters)
            return generateECCSPKI(pubKey);
        else
            throw new Exception("can not generateSPKI with keyType :".concat(String.valueOf(String.valueOf(pubKey.getClass().getName()))));
    }

    private SubjectPublicKeyInfo generateRSASPKI(CipherParameters pubKey)
    {
        AlgorithmIdentifier algId = new AlgorithmIdentifier(PKCSObjectIdentifiers.rsaEncryption);
        RSAKeyParameters rsaPubKey = (RSAKeyParameters)pubKey;
        RSAPublicKeyStructure stru = new RSAPublicKeyStructure(rsaPubKey.getModulus(), rsaPubKey.getExponent());
        return new SubjectPublicKeyInfo(algId, stru);
    }

    private SubjectPublicKeyInfo generateECCSPKI(CipherParameters pubKey)
    {
        ECPublicKeyParameters ecPubKey = (ECPublicKeyParameters)pubKey;
        ECDomainParameters ecdp = ecPubKey.getParameters();
        X9ECParameters x9Params = new X9ECParameters(ecdp.getCurve(), ecdp.getG(), ecdp.getN(), ecdp.getH());
        AlgorithmIdentifier algId = new AlgorithmIdentifier(PKCSObjectIdentifiers.ecEncryption, x9Params);
        SubjectPublicKeyInfo spki = new SubjectPublicKeyInfo(algId, ecPubKey.getQ().getEncoded(true));
        algId = new AlgorithmIdentifier(PKCSObjectIdentifiers.ecEncryption);
        return new SubjectPublicKeyInfo(algId, spki);
    }

    public Vector getCertRequestContent(CertificationRequest certRequest)
        throws Exception
    {
        Mechanism sigM = null;
        Mechanism cryptoM = null;
        Mechanism digestM = null;
        AlgorithmIdentifier algId = certRequest.getSignatureAlgorithm();
        if(algId.getObjectId().equals(PKCSObjectIdentifiers.sha1WithRSAEncryption))
            sigM = new JMechanism(6);
        else
        if(algId.getObjectId().equals(PKCSObjectIdentifiers.md2WithRSAEncryption))
            sigM = new JMechanism(4);
        else
        if(algId.getObjectId().equals(PKCSObjectIdentifiers.md5WithRSAEncryption))
            sigM = new JMechanism(5);
        else
        if(algId.getObjectId().equals(PKCSObjectIdentifiers.sha1WithECEncryption))
            sigM = new JMechanism(1027);
        else
            throw new Exception("getCertRequestContent can't support signature algId:".concat(String.valueOf(String.valueOf(algId.getObjectId().getId()))));
        byte sig[] = certRequest.getSignature().getBytes();
        CertificationRequestInfo certri = certRequest.getCertificationRequestInfo();
        JKey pubKey = null;
        SubjectPublicKeyInfo spki = certri.getSubjectPublicKeyInfo();
        if(spki.getAlgorithmId().getObjectId().equals(PKCSObjectIdentifiers.rsaEncryption))
        {
            cryptoM = new JMechanism(1);
            pubKey = Parser.convert2JKey(1, getRSAPubKey(spki));
        } else
        {
            cryptoM = new JMechanism(1026);
            spki = new SubjectPublicKeyInfo((ASN1Sequence)spki.getPublicKey());
            pubKey = Parser.convert2JKey(1001, getECPubKey(spki));
        }
        boolean f = false;
        byte b_certri[] = Parser.writeDERObj2Bytes(certri.getDERObject());
        String errS = "verify signatrue failture.";
        ASN1Sequence seq = null;
        if(pubKey.getKeyType() == 1)
        {
            byte digestInfo[] = session.decrypt(cryptoM, pubKey, sig);
            seq = (ASN1Sequence)Parser.writeBytes2DERObj(digestInfo);
            AlgorithmIdentifier digestAlg = AlgorithmIdentifier.getInstance(seq.getObjectAt(0));
            DERObjectIdentifier did = digestAlg.getObjectId();
            if(did.equals(PKCSObjectIdentifiers.md2))
                digestM = new JMechanism(512);
            else
            if(did.equals(PKCSObjectIdentifiers.md5))
                digestM = new JMechanism(528);
            else
            if(did.equals(PKCSObjectIdentifiers.sha1))
                digestM = new JMechanism(544);
            else
                throw new Exception("PKCS10Parser:can't support digest algorithm identifier:".concat(String.valueOf(String.valueOf(did.getId()))));
            byte digest[] = ((DEROctetString)seq.getObjectAt(1)).getOctets();
            byte myDigest[] = session.digest(digestM, b_certri);
            f = Crypto.isEqualArray(digest, myDigest);
        } else
        {
            byte signature[] = Crypto.decodeECCSignature(sig);
            sigM = new JMechanism(1027);
            f = session.verifySign(sigM, pubKey, b_certri, signature);
        }
        if(!f)
        {
            throw new Exception(errS);
        } else
        {
            Vector v = new Vector();
            v.add(certri.getSubject());
            v.add(spki);
            v.add(certri.getAttributes());
            return v;
        }
    }

    public JKey getPubKeyFromSPKI(SubjectPublicKeyInfo spki)
        throws Exception
    {
        DERObjectIdentifier oid = spki.getAlgorithmId().getObjectId();
        CipherParameters pubKey = null;
        if(oid.equals(PKCSObjectIdentifiers.rsaEncryption))
        {
            pubKey = getRSAPubKey(spki);
            return Parser.convert2JKey(1, pubKey);
        }
        if(oid.equals(PKCSObjectIdentifiers.ecEncryption))
        {
            pubKey = getECPubKey(spki);
            return Parser.convert2JKey(1001, pubKey);
        } else
        {
            throw new Exception(String.valueOf(String.valueOf((new StringBuffer("not support AlgorithmIdentifier:")).append(oid.getId()).append(" in SubjectPublicKeyInfo."))));
        }
    }

    private CipherParameters getRSAPubKey(SubjectPublicKeyInfo spki)
        throws Exception
    {
        ASN1Sequence seq = (ASN1Sequence)spki.getPublicKey();
        RSAPublicKeyStructure stru = new RSAPublicKeyStructure(seq);
        return new RSAKeyParameters(false, stru.getModulus(), stru.getPublicExponent());
    }

    private CipherParameters getECPubKey(SubjectPublicKeyInfo spki)
    {
        AlgorithmIdentifier algId = spki.getAlgorithmId();
        X9ECParameters x9params = new X9ECParameters((ASN1Sequence)algId.getParameters());
        byte pointData[] = spki.getPublicKeyData().getBytes();
        ECPoint point = x9params.getCurve().decodePoint(pointData);
        ECDomainParameters ecdp = new ECDomainParameters(x9params.getCurve(), x9params.getG(), x9params.getN(), x9params.getH());
        return new ECPublicKeyParameters(point, ecdp);
    }
}