jpf.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:   Jpf.java

package jit.util.jitca;

import java.io.*;
import jit.asn1.*;
import jit.asn1.pkcs.RSAPrivateKeyStructure;
import jit.asn1.pkcs.pkcs12.Pfx;
import jit.asn1.x509.X509CertificateStructure;
import jit.asn1.x9.X9ECParameters;
import jit.asn1.x9.X9PrivateKeyInfo;
import jit.asn1parser.Parser;
import jit.asn1parser.pkcs.PKCS12Parser;
import jit.asn1parser.x509.X509Cert;
import jit.crypto.CipherParameters;
import jit.crypto.params.*;
import jit.cryptolib.toolkit.Crypto;
import jit.jcrypto.*;
import jit.jcrypto.soft.JMechanism;
import jit.math.BigInteger;
import jit.util.encoders.Base64;
import jit.util.jitca.ini.EncryptINI;
import jit.util.jitca.ini.ProFile;

// Referenced classes of package jit.util.jitca:
//            Key

public class Jpf
{

    private String fileName;
    private boolean isWrite;
    private ProFile proFile;
    private CipherParameters encryptKey;
    static final String PASSWORD_TOKEN = "Password Token";
    static final String PRIVATE_KEYS = "Private Keys";
    static final String CERTIFICATE_HISTORY = "Certificate History";
    static final String USER_CERTIFICATE = "User Certificate";
    static final String DIGITAL_SIGNATURE = "Digital Signature";
    static final String CA_CERTIFICATES = "CA Certificates";
    static final String PASSWORDCHECKTOKEN = "PASSWORDCHECKTOKEN";
    static final int PARAM_LENGTH = 8;
    static final int ITERATIONS = 1000;
    private Session session;
    private byte pwd[];

    public Jpf(Session session)
    {
        this.session = null;
        pwd = null;
        this.session = session;
        fileName = null;
        isWrite = false;
        proFile = new ProFile();
        encryptKey = null;
    }

    public void open(String _fileName, char _password[])
        throws Exception
    {
        fileName = _fileName;
        pwd = (new String(_password)).getBytes();
        File file = new File(fileName);
        if(!file.exists())
        {
            initKey((new String(_password)).getBytes());
            isWrite = true;
        } else
        {
            proFile.load(fileName);
            if(!checkPassword(pwd))
                throw new Exception("the password is not right.");
        }
    }

    public void open(byte jpfContent[], char _password[])
        throws Exception
    {
        pwd = (new String(_password)).getBytes();
        ByteArrayInputStream bis = new ByteArrayInputStream(jpfContent);
        proFile.load(bis);
        if(!checkPassword(pwd))
            throw new Exception("the password is not right.");
        else
            return;
    }

    private void initKey(byte password[])
        throws Exception
    {
        Mechanism randomM = new JMechanism(0x80000020);
        byte salt[] = session.generateRandom(randomM, 8);
        EncryptINI.setValue(session, proFile, "Password Token", "SaltValue", salt, null);
        ParametersWithIV pbeParam = Crypto.generatePKCS5Parameters(17, password, salt, 1000);
        encryptKey = (KeyParameter)pbeParam.getParameters();
        JKey jencryptKey = Parser.convert2JKey(145, encryptKey);
        EncryptINI.setValue(session, proFile, "Password Token", "!Token", "PASSWORDCHECKTOKEN".getBytes(), jencryptKey);
    }

    private boolean checkPassword(byte password[])
    {
        byte salt[] = Base64.decode(proFile.getValue("Password Token", "SaltValue"));
        try
        {
            ParametersWithIV pbeParam = Crypto.generatePKCS5Parameters(17, password, salt, 1000);
            encryptKey = pbeParam.getParameters();
            JKey jkey = Parser.convert2JKey(145, encryptKey);
            byte de_data[] = EncryptINI.getValue(session, proFile, "Password Token", "!Token", jkey);
            String de_s = new String(de_data);
            if(de_s.equals("PASSWORDCHECKTOKEN"))
            {
                boolean flag1 = true;
                return flag1;
            } else
            {
                boolean flag2 = false;
                return flag2;
            }
        }
        catch(Exception ex)
        {
            System.out.println("checkPassword error:".concat(String.valueOf(String.valueOf(ex.toString()))));
        }
        boolean flag = false;
        return flag;
    }

    public void save()
        throws Exception
    {
        if(isWrite)
        {
            proFile.storeValue("Private Keys", "KeyCount", "0");
            proFile.createSection("Certificate History");
            proFile.createSection("CA Certificates");
            JKey jkey = Parser.convert2JKey(145, encryptKey);
            EncryptINI.setValue(session, proFile, "Digital Signature", "!DevID", "1".getBytes(), jkey);
            EncryptINI.setValue(session, proFile, "Digital Signature", "!PrvKeyType", "0".getBytes(), jkey);
            proFile.writeToFile(fileName);
        }
    }

    public JKey getSignPrivKey()
        throws Exception
    {
        if(proFile == null)
            throw new Exception("Jpf file has not been opened.");
        JKey jkey = Parser.convert2JKey(145, encryptKey);
        byte data[] = EncryptINI.getValue(session, proFile, "Digital Signature", "!Key", jkey);
        byte der_data[] = Base64.decode(Parser.convertBase64(data));
        Key key = Key.getInstance(Parser.writeBytes2DERObj(der_data));
        if(key.getKeyType().equals(new DERInteger(2)))
        {
            ASN1Sequence seq = Parser.oct2Seq(key.getKey());
            RSAPrivateKeyStructure stru = new RSAPrivateKeyStructure(seq);
            RSAPrivateCrtKeyParameters privKey = new RSAPrivateCrtKeyParameters(stru.getModulus(), stru.getPublicExponent(), stru.getPrivateExponent(), stru.getPrime1(), stru.getPrime2(), stru.getExponent1(), stru.getExponent2(), stru.getCoefficient());
            return Parser.convert2JKey(2, privKey);
        }
        if(key.getKeyType().equals(new DERInteger(512)))
        {
            ASN1Sequence seq = Parser.oct2Seq(key.getKey());
            X9PrivateKeyInfo x9 = new X9PrivateKeyInfo(seq);
            return Parser.convert2JKey(1002, x9.getPrivateKey());
        } else
        {
            throw new Exception("the EncryptionPrivateKey int JPF is neither RSA nor ECC.");
        }
    }

    public void setSignPrivKey(JKey signPriKey)
        throws Exception
    {
        CipherParameters privKey = Parser.conver2CipherParam(signPriKey);
        if(privKey instanceof RSAPrivateCrtKeyParameters)
        {
            RSAPrivateCrtKeyParameters privateKey = (RSAPrivateCrtKeyParameters)privKey;
            byte value[] = convertRSAPrivateKey(privateKey);
            JKey jkey = Parser.convert2JKey(145, encryptKey);
            EncryptINI.setValue(session, proFile, "Digital Signature", "!Key", value, jkey);
        } else
        if(privKey instanceof ECPrivateKeyParameters)
        {
            ECPrivateKeyParameters privateKey = (ECPrivateKeyParameters)privKey;
            JKey jkey = Parser.convert2JKey(145, encryptKey);
            byte value[] = convertECCPrivateKey(privateKey);
            EncryptINI.setValue(session, proFile, "Digital Signature", "!Key", value, jkey);
        } else
        {
            throw new Exception("the SignaturePrivateKey parameter set to JPF is neither RSA nor ECC.");
        }
    }

    public X509Cert getSignCert()
        throws Exception
    {
        if(proFile == null)
        {
            throw new Exception("Jpf file has not been opened.");
        } else
        {
            JKey jkey = Parser.convert2JKey(145, encryptKey);
            byte data[] = EncryptINI.getValue(session, proFile, "Digital Signature", "!Certificate", jkey);
            byte der_data[] = Base64.decode(Parser.convertBase64(data));
            return new X509Cert(X509CertificateStructure.getInstance(Parser.writeBytes2DERObj(der_data)));
        }
    }

    public void setSignCert(X509Cert cert)
        throws Exception
    {
        X509CertificateStructure signCert = cert.getCertStructure();
        byte der_data[] = Parser.writeDERObj2Bytes(signCert.getDERObject());
        byte base64_data[] = Base64.encode(der_data);
        JKey jkey = Parser.convert2JKey(145, encryptKey);
        EncryptINI.setValue(session, proFile, "Digital Signature", "!Certificate", base64_data, jkey);
    }

    public JKey getEncryptPrivKey()
        throws Exception
    {
        if(proFile == null)
            throw new Exception("Jpf file has not been opened.");
        JKey jkey = Parser.convert2JKey(145, encryptKey);
        byte data[] = EncryptINI.getValue(session, proFile, "User Certificate", "!Key", jkey);
        byte der_data[] = Base64.decode(Parser.convertBase64(data));
        Key key = Key.getInstance(Parser.writeBytes2DERObj(der_data));
        if(key.getKeyType().equals(new DERInteger(2)))
        {
            ASN1Sequence seq = Parser.oct2Seq(key.getKey());
            RSAPrivateKeyStructure stru = new RSAPrivateKeyStructure(seq);
            RSAPrivateCrtKeyParameters privKey = new RSAPrivateCrtKeyParameters(stru.getModulus(), stru.getPublicExponent(), stru.getPrivateExponent(), stru.getPrime1(), stru.getPrime2(), stru.getExponent1(), stru.getExponent2(), stru.getCoefficient());
            return Parser.convert2JKey(2, privKey);
        }
        if(key.getKeyType().equals(new DERInteger(512)))
        {
            ASN1Sequence seq = Parser.oct2Seq(key.getKey());
            X9PrivateKeyInfo x9 = new X9PrivateKeyInfo(seq);
            return Parser.convert2JKey(1002, x9.getPrivateKey());
        } else
        {
            throw new Exception("the EncryptionPrivateKey int JPF is neither RSA nor ECC.");
        }
    }

    public void setEncryptPrivKey(JKey priKey)
        throws Exception
    {
        CipherParameters privKey = Parser.conver2CipherParam(priKey);
        if(privKey instanceof RSAPrivateCrtKeyParameters)
        {
            RSAPrivateCrtKeyParameters privateKey = (RSAPrivateCrtKeyParameters)privKey;
            byte value[] = convertRSAPrivateKey(privateKey);
            JKey jkey = Parser.convert2JKey(145, encryptKey);
            EncryptINI.setValue(session, proFile, "User Certificate", "!Key", value, jkey);
        } else
        if(privKey instanceof ECPrivateKeyParameters)
        {
            ECPrivateKeyParameters privateKey = (ECPrivateKeyParameters)privKey;
            byte value[] = convertECCPrivateKey(privateKey);
            JKey jkey = Parser.convert2JKey(145, encryptKey);
            EncryptINI.setValue(session, proFile, "User Certificate", "!Key", value, jkey);
        } else
        {
            throw new Exception("the EncryptionPrivateKey parameter set to JPF is neither RSA nor ECC.");
        }
    }

    public X509Cert getEncryptCert()
        throws Exception
    {
        if(proFile == null)
        {
            throw new Exception("Jpf file has not been opened.");
        } else
        {
            JKey jkey = Parser.convert2JKey(145, encryptKey);
            byte data[] = EncryptINI.getValue(session, proFile, "User Certificate", "!Certificate", jkey);
            byte der_data[] = Base64.decode(Parser.convertBase64(data));
            return new X509Cert(X509CertificateStructure.getInstance(Parser.writeBytes2DERObj(der_data)));
        }
    }

    public void setEncryptCert(X509Cert cert)
        throws Exception
    {
        X509CertificateStructure encryptCert = cert.getCertStructure();
        byte der_data[] = Parser.writeDERObj2Bytes(encryptCert.getDERObject());
        byte base64_data[] = Base64.encode(der_data);
        JKey jkey = Parser.convert2JKey(145, encryptKey);
        EncryptINI.setValue(session, proFile, "User Certificate", "!Certificate", base64_data, jkey);
    }

    private byte[] convertRSAPrivateKey(RSAPrivateCrtKeyParameters privateKey)
        throws Exception
    {
        DEREncodableVector derV = new DEREncodableVector();
        derV.add(new DERInteger(0));
        derV.add(new DERInteger(privateKey.getModulus()));
        derV.add(new DERInteger(privateKey.getPublicExponent()));
        derV.add(new DERInteger(privateKey.getExponent()));
        derV.add(new DERInteger(privateKey.getP()));
        derV.add(new DERInteger(privateKey.getQ()));
        derV.add(new DERInteger(privateKey.getDP()));
        derV.add(new DERInteger(privateKey.getDQ()));
        derV.add(new DERInteger(privateKey.getQInv()));
        DERSequence seq = new DERSequence(derV);
        byte data[] = Parser.writeDERObj2Bytes(seq);
        DEROctetString oct = new DEROctetString(data);
        Key key = new Key(new DERInteger(2), oct);
        byte k[] = Parser.writeDERObj2Bytes(key.getDERObject());
        return Base64.encode(k);
    }

    private byte[] convertECCPrivateKey(ECPrivateKeyParameters privateKey)
        throws Exception
    {
        DEROctetString d = new DEROctetString(privateKey.getD().toByteArray());
        ECDomainParameters ecdp = privateKey.getParameters();
        X9ECParameters x9Params = new X9ECParameters(ecdp.getCurve(), ecdp.getG(), ecdp.getN(), ecdp.getH());
        X9PrivateKeyInfo x9 = new X9PrivateKeyInfo(d, x9Params);
        byte data[] = Parser.writeDERObj2Bytes(x9.getDERObject());
        DEROctetString oct = new DEROctetString(data);
        Key key = new Key(new DERInteger(512), oct);
        byte k[] = Parser.writeDERObj2Bytes(key.getDERObject());
        return Base64.encode(k);
    }

    public Pfx getSignPfx(char password[])
        throws Exception
    {
        if(proFile == null)
            throw new Exception("Jpf file has not been opened.");
        JKey signKey = getSignPrivKey();
        X509Cert signCert = getSignCert();
        PKCS12Parser p12 = new PKCS12Parser();
        if(password == null)
            password = (new String(pwd)).toCharArray();
        Pfx signPfx = p12.generatePfx(signKey, signCert, password);
        return signPfx;
    }

    public Pfx getEncryptPfx(char password[])
        throws Exception
    {
        if(proFile == null)
            throw new Exception("Jpf file has not been opened.");
        JKey enKey = getEncryptPrivKey();
        X509Cert enCert = getEncryptCert();
        PKCS12Parser p12 = new PKCS12Parser();
        if(password == null)
            password = (new String(pwd)).toCharArray();
        Pfx enPfx = p12.generatePfx(enKey, enCert, password);
        return enPfx;
    }

    static 
    {
        PASSWORD_TOKEN = "Password Token";
        PRIVATE_KEYS = "Private Keys";
        CERTIFICATE_HISTORY = "Certificate History";
        USER_CERTIFICATE = "User Certificate";
        DIGITAL_SIGNATURE = "Digital Signature";
        CA_CERTIFICATES = "CA Certificates";
        PASSWORDCHECKTOKEN = "PASSWORDCHECKTOKEN";
        PARAM_LENGTH = 8;
        ITERATIONS = 1000;
    }
}