crypto.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:   Crypto.java

package jit.cryptolib.toolkit;

import java.io.*;
import jit.asn1.*;
import jit.asn1.x509.AlgorithmIdentifier;
import jit.asn1.x9.*;
import jit.crypto.*;
import jit.crypto.agreement.ECDHBasicAgreement;
import jit.crypto.digests.*;
import jit.crypto.encodings.PKCS1Encoding;
import jit.crypto.engines.*;
import jit.crypto.generators.*;
import jit.crypto.macs.HMac;
import jit.crypto.modes.CBCBlockCipher;
import jit.crypto.modes.PaddedBlockCipher;
import jit.crypto.params.*;
import jit.crypto.signers.ECDSASigner;
import jit.math.BigInteger;
import jit.math.ec.ECCurve;
import jit.security.SecureRandom;

// Referenced classes of package jit.cryptolib.toolkit:
//            Constant

public class Crypto
    implements Constant
{

    public Crypto()
    {
    }

    public static byte[] cipherEncode(int eng, boolean isEncrypt, CipherParameters param, byte data[])
        throws Exception
    {
        BufferedBlockCipher cipher = null;
        switch(eng)
        {
        case 6: // '\006'
            cipher = new PaddedBlockCipher(new DESEngine());
            break;

        case 7: // '\007'
            cipher = new PaddedBlockCipher(new CBCBlockCipher(new DESEngine()));
            break;

        case 10: // '\n'
            cipher = new PaddedBlockCipher(new RC2Engine());
            break;

        case 11: // '\013'
            cipher = new PaddedBlockCipher(new CBCBlockCipher(new RC2Engine()));
            break;

        case 8: // '\b'
            cipher = new PaddedBlockCipher(new DESedeEngine());
            break;

        case 9: // '\t'
            cipher = new PaddedBlockCipher(new CBCBlockCipher(new DESedeEngine()));
            break;

        case 22: // '\026'
            cipher = new PaddedBlockCipher(new AESEngine());
            break;

        case 23: // '\027'
            cipher = new PaddedBlockCipher(new CBCBlockCipher(new AESEngine()));
            break;

        case 24: // '\030'
            cipher = new PaddedBlockCipher(new AESFastEngine());
            break;

        case 25: // '\031'
            cipher = new PaddedBlockCipher(new CBCBlockCipher(new AESFastEngine()));
            break;

        case 26: // '\032'
            cipher = new PaddedBlockCipher(new AESLightEngine());
            break;

        case 27: // '\033'
            cipher = new PaddedBlockCipher(new CBCBlockCipher(new AESLightEngine()));
            break;

        case 28: // '\034'
            cipher = new PaddedBlockCipher(new CAST5Engine());
            break;

        case 29: // '\035'
            cipher = new PaddedBlockCipher(new CBCBlockCipher(new CAST5Engine()));
            break;

        case 30: // '\036'
            cipher = new PaddedBlockCipher(new IDEAEngine());
            break;

        case 31: // '\037'
            cipher = new PaddedBlockCipher(new CBCBlockCipher(new IDEAEngine()));
            break;

        case 12: // '\f'
        case 13: // '\r'
        case 14: // '\016'
        case 15: // '\017'
        case 16: // '\020'
        case 17: // '\021'
        case 18: // '\022'
        case 19: // '\023'
        case 20: // '\024'
        case 21: // '\025'
        default:
            throw new Exception("Not Support Algorithm:".concat(String.valueOf(String.valueOf(eng))));
        }
        cipher.init(isEncrypt, param);
        byte out[] = new byte[cipher.getOutputSize(data.length)];
        int res = cipher.processBytes(data, 0, data.length, out, 0);
        int validLen = -1;
        if(res < out.length)
            validLen = cipher.doFinal(out, res);
        if(isEncrypt)
        {
            return out;
        } else
        {
            byte d[] = new byte[(out.length - cipher.getBlockSize()) + validLen];
            System.arraycopy(out, 0, d, 0, d.length);
            return d;
        }
    }

    public static byte[] RSAEncode(int eng, boolean isEncrypt, CipherParameters param, byte data[])
        throws Exception
    {
        AsymmetricBlockCipher cipher = null;
        if(eng == 12)
            cipher = new PKCS1Encoding(new RSAEngine());
        else
            throw new Exception("Not Support Algorithm:".concat(String.valueOf(String.valueOf(eng))));
        cipher.init(isEncrypt, param);
        byte out[] = new byte[cipher.getOutputBlockSize()];
        out = cipher.processBlock(data, 0, data.length);
        return out;
    }

    public static byte[] messageDigest(int eng, byte data[])
        throws Exception
    {
        Digest digest = null;
        switch(eng)
        {
        case 1: // '\001'
            digest = new SHA1Digest();
            break;

        case 2: // '\002'
            digest = new MD5Digest();
            break;

        case 3: // '\003'
            digest = new MD2Digest();
            break;

        default:
            throw new Exception("Not Support Algorithm:".concat(String.valueOf(String.valueOf(eng))));
        }
        byte out[] = new byte[digest.getDigestSize()];
        digest.update(data, 0, data.length);
        digest.doFinal(out, 0);
        return out;
    }

    public static byte[] generateHMAC(int eng, CipherParameters param, byte data[])
        throws Exception
    {
        Mac mac = null;
        switch(eng)
        {
        case 4: // '\004'
            mac = new HMac(new SHA1Digest());
            break;

        case 5: // '\005'
            mac = new HMac(new MD5Digest());
            break;

        case 40: // '('
            mac = new HMac(new MD2Digest());
            break;

        default:
            throw new Exception("Not Support Algorithm:".concat(String.valueOf(String.valueOf(eng))));
        }
        mac.init(param);
        mac.update(data, 0, data.length);
        byte out[] = new byte[mac.getMacSize()];
        mac.doFinal(out, 0);
        return out;
    }

    public static AsymmetricCipherKeyPair generateRSAKeyPair(BigInteger pubE, SecureRandom sr, int keyStrength, int Certain)
    {
        BigInteger pub;
        if(pubE == null)
            pub = Constant.defaultPubExp;
        else
            pub = pubE;
        SecureRandom sRan;
        if(sr == null)
            sRan = new SecureRandom();
        else
            sRan = sr;
        int keylength;
        if(keyStrength == 0)
            keylength = 1024;
        else
            keylength = keyStrength;
        int certain;
        if(Certain == 0)
            certain = 47;
        else
            certain = Certain;
        RSAKeyGenerationParameters rsaParam = new RSAKeyGenerationParameters(pub, sRan, keylength, certain);
        RSAKeyPairGenerator keyGen = new RSAKeyPairGenerator();
        keyGen.init(rsaParam);
        return keyGen.generateKeyPair();
    }

    public static AsymmetricCipherKeyPair generateECCKeyPair(int keyLength)
    {
        X9ECParameters x9Param = null;
        switch(keyLength)
        {
        case 160: 
            x9Param = X962NamedCurves.getByName("prime160v1");
            break;

        case 192: 
            x9Param = X962NamedCurves.getByName("prime192v1");
            break;

        default:
            return null;
        }
        ECDomainParameters params = new ECDomainParameters(x9Param.getCurve(), x9Param.getG(), x9Param.getN());
        ECKeyGenerationParameters genParam = new ECKeyGenerationParameters(params, new SecureRandom());
        ECKeyPairGenerator pGen = new ECKeyPairGenerator();
        pGen.init(genParam);
        return pGen.generateKeyPair();
    }

    public static byte[] ECIESEncrypt(int engName, CipherParameters pub, byte data[])
        throws Exception
    {
        if(engName != 13)
            throw new Exception("Not support Algorithm:".concat(String.valueOf(String.valueOf(engName))));
        ECKeyParameters ecKey = (ECKeyParameters)pub;
        ECDomainParameters ecdp = ecKey.getParameters();
        int keyLen = ecdp.getN().bitLength();
        if(keyLen == 161)
            keyLen = 160;
        if(keyLen != 160 && keyLen != 192)
        {
            throw new Exception("not support ECC key length:".concat(String.valueOf(String.valueOf(keyLen))));
        } else
        {
            AsymmetricCipherKeyPair keyPair = generateECCKeyPair(keyLen);
            IESEngine eng = new IESEngine(new ECDHBasicAgreement(), new KDF2BytesGenerator(new SHA1Digest()), new HMac(new SHA1Digest()));
            IESParameters p = new IESParameters(null, null, 160);
            eng.init(true, keyPair.getPrivate(), pub, p);
            byte out[] = eng.processBlock(data, 0, data.length);
            X9ECIESStructure x9stru = new X9ECIESStructure();
            x9stru.setQ(((ECPublicKeyParameters)keyPair.getPublic()).getQ());
            x9stru.setEncodedMessageAndMac(out);
            return x9stru.getOutputData();
        }
    }

    public static byte[] ECIESDecrypt(int engName, CipherParameters cipherParam, byte data[])
        throws Exception
    {
        if(engName != 13)
        {
            throw new Exception("Not support Algorithm:".concat(String.valueOf(String.valueOf(engName))));
        } else
        {