crypto.java

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

            IESEngine eng = new IESEngine(new ECDHBasicAgreement(), new KDF2BytesGenerator(new SHA1Digest()), new HMac(new SHA1Digest()));
            IESParameters p = new IESParameters(null, null, 160);
            ECDomainParameters ecdp = ((ECKeyParameters)cipherParam).getParameters();
            int keyLen = (ecdp.getN().bitLength() / 8) * 8;
            X9ECIESStructure x9stru = new X9ECIESStructure(data, keyLen, 20);
            byte Q[] = x9stru.getQ();
            byte encryptedData[] = x9stru.getEncodedMessageAndMac();
            ECPublicKeyParameters servPubKey = new ECPublicKeyParameters(ecdp.getCurve().decodePoint(Q), ecdp);
            eng.init(false, cipherParam, servPubKey, p);
            byte out[] = eng.processBlock(encryptedData, 0, encryptedData.length);
            return out;
        }
    }

    public static byte[] ECDSASignature(int engName, CipherParameters param, byte hash[])
        throws Exception
    {
        if(engName != 14)
        {
            throw new Exception("Not support Algorithm:".concat(String.valueOf(String.valueOf(engName))));
        } else
        {
            ECDSASigner singer = new ECDSASigner();
            singer.init(true, param);
            BigInteger signedData[] = singer.generateSignature(hash);
            DEREncodableVector v = new DEREncodableVector();
            v.add(new DERInteger(signedData[0]));
            v.add(new DERInteger(signedData[1]));
            DERSequence seq = new DERSequence(v);
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            DEROutputStream dos = new DEROutputStream(bos);
            dos.writeObject(seq.getDERObject());
            return bos.toByteArray();
        }
    }

    public static byte[] encodeECDSASignature(byte signedData[])
        throws Exception
    {
        ByteArrayInputStream bis = new ByteArrayInputStream(signedData);
        DERInputStream dis = new DERInputStream(bis);
        ASN1Sequence seq = (ASN1Sequence)dis.readObject();
        AlgorithmIdentifier algSign = new AlgorithmIdentifier(new DERObjectIdentifier("1.2.840.10045.4.1"), null);
        DEREncodableVector tempv = new DEREncodableVector();
        tempv.add(algSign);
        tempv.add(seq);
        DERSequence seqv = new DERSequence(tempv);
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DEROutputStream dos = new DEROutputStream(bos);
        dos.writeObject(seqv.getDERObject());
        return bos.toByteArray();
    }

    public static byte[] decodeECCSignature(byte signature[])
        throws Exception
    {
        ByteArrayInputStream bis = new ByteArrayInputStream(signature);
        DERInputStream dis = new DERInputStream(bis);
        ASN1Sequence asnSeq = (ASN1Sequence)dis.readObject();
        AlgorithmIdentifier algSign = new AlgorithmIdentifier((ASN1Sequence)asnSeq.getObjectAt(0));
        if(!algSign.getObjectId().equals(new DERObjectIdentifier("1.2.840.10045.4.1")))
        {
            throw new Exception("Algorithm Not Math");
        } else
        {
            asnSeq = (ASN1Sequence)asnSeq.getObjectAt(1);
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            DEROutputStream dos = new DEROutputStream(bos);
            dos.writeObject(asnSeq.getDERObject());
            return bos.toByteArray();
        }
    }

    public static boolean ECDSAVerify(int engName, CipherParameters params, byte hash[], byte signature[])
        throws Exception
    {
        if(engName != 14)
        {
            throw new Exception("Not support Algorithm:".concat(String.valueOf(String.valueOf(engName))));
        } else
        {
            ByteArrayInputStream bis = new ByteArrayInputStream(signature);
            DERInputStream dis = new DERInputStream(bis);
            ASN1Sequence seq = (ASN1Sequence)dis.readObject();
            DERInteger derR = (DERInteger)seq.getObjectAt(0);
            DERInteger derS = (DERInteger)seq.getObjectAt(1);
            BigInteger r = derR.getValue();
            BigInteger s = derS.getValue();
            ECDSASigner signer = new ECDSASigner();
            signer.init(false, params);
            return signer.verifySignature(hash, r, s);
        }
    }

    public static byte[] encodeRSASignature(int mdId, byte digest[])
        throws Exception
    {
        DEROctetString derOct = new DEROctetString(digest);
        AlgorithmIdentifier algSign = null;
        if(mdId == 1)
            algSign = new AlgorithmIdentifier(Constant.sha1, null);
        else
        if(mdId == 3)
            algSign = new AlgorithmIdentifier(Constant.md2, null);
        else
        if(mdId == 2)
            algSign = new AlgorithmIdentifier(Constant.md5, null);
        else
            throw new Exception(String.valueOf(String.valueOf((new StringBuffer("not support MessageDigest Id:")).append(mdId).append(" in RSA signature."))));
        DEREncodableVector tempv = new DEREncodableVector();
        tempv.add(algSign);
        tempv.add(derOct);
        DERSequence seqv = new DERSequence(tempv);
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DEROutputStream dos = new DEROutputStream(bos);
        dos.writeObject(seqv.getDERObject());
        return bos.toByteArray();
    }

    public static boolean RSASignatureVerify(int eng, CipherParameters params, byte hash[], byte signature[])
        throws Exception
    {
        byte sign[] = RSAEncode(eng, false, params, signature);
        if(hash.length != sign.length)
            return false;
        for(int i = 0; i < hash.length; i++)
            if(hash[i] != sign[i])
            {
                System.out.println(i);
                return false;
            }

        return true;
    }

    public static boolean isEqualArray(byte a[], byte b[])
    {
        if(a.length != b.length)
            return false;
        for(int i = 0; i < a.length; i++)
            if(a[i] != b[i])
                return false;

        return true;
    }

    public static CipherParameters generateSymmetricKey(int eng, int keyLen, boolean withIV)
        throws Exception
    {
        DESKeyGenerator gen = null;
        KeyGenerationParameters param = null;
        byte iv[] = null;
        if(withIV)
        {
            iv = new byte[8];
            SecureRandom sRandom = new SecureRandom();
            sRandom.nextBytes(iv);
        }
        int keyLength = keyLen;
        if(eng == 6 || eng == 7)
        {
            gen = new DESKeyGenerator();
            if(keyLength == 0)
                keyLength = 64;
        } else
        if(eng == 8 || eng == 9)
        {
            gen = new DESedeKeyGenerator();
            if(keyLength == 0)
                keyLength = 192;
        } else
        {
            if(eng == 10 || eng == 11)
            {
                if(keyLength == 0)
                    keyLength = 128;
                byte rc2[] = new byte[keyLength / 8];
                byte seed[] = new byte[8];
                SecureRandom sr = new SecureRandom();
                sr.nextBytes(seed);
                sr.setSeed(seed);
                sr.nextBytes(rc2);
                CipherParameters rc2Key = new KeyParameter(rc2);
                if(!withIV)
                    return rc2Key;
                else
                    return new ParametersWithIV(rc2Key, iv);
            }
            if(eng == 22 || eng == 23 || eng == 24 || eng == 25 || eng == 26 || eng == 27)
            {
                if(keyLength == 0)
                    keyLength = 128;
                byte aes[] = new byte[keyLength / 8];
                byte seed[] = new byte[8];
                SecureRandom sr = new SecureRandom();
                sr.nextBytes(seed);
                sr.setSeed(seed);
                sr.nextBytes(aes);
                KeyParameter aesKey = new KeyParameter(aes);
                if(!withIV)
                {
                    return aesKey;
                } else
                {
                    iv = new byte[16];
                    sr.nextBytes(iv);
                    return new ParametersWithIV(aesKey, iv);
                }
            }
            if(eng == 28 || eng == 29 || eng == 30 || eng == 31)
            {
                if(keyLength == 0)
                    keyLength = 64;
                byte cast[] = new byte[keyLength / 8];
                byte seed[] = new byte[8];
                SecureRandom sr = new SecureRandom();
                sr.nextBytes(seed);
                sr.setSeed(seed);
                sr.nextBytes(cast);
                KeyParameter castKey = new KeyParameter(cast);
                if(!withIV)
                    return castKey;
                else
                    return new ParametersWithIV(castKey, iv);
            } else
            {
                throw new Exception("Not support Key Generator:".concat(String.valueOf(String.valueOf(eng))));
            }
        }
        param = new KeyGenerationParameters(new SecureRandom(), keyLength);
        gen.init(param);
        byte key[] = gen.generateKey();
        CipherParameters desKey = new KeyParameter(key);
        if(!withIV)
            return desKey;
        else
            return new ParametersWithIV(desKey, iv);
    }

    public static int generateIterations()
    {
        SecureRandom secRan = new SecureRandom();
        int iterations = 1024 + (secRan.nextInt() & 0x3ff);
        return iterations;
    }

    public static byte[] generateSalt()
    {
        SecureRandom secRan = new SecureRandom();
        byte salt[] = new byte[8];
        secRan.nextBytes(salt);
        return salt;
    }

    public static ParametersWithIV generatePKCS5Parameters(int eng, byte password[], byte salt[], int iterations)
        throws Exception
    {
        PKCS5S1ParametersGenerator pkcs5ParamGen = null;
        switch(eng)
        {
        case 16: // '\020'
            pkcs5ParamGen = new PKCS5S1ParametersGenerator(new MD2Digest());
            break;

        case 15: // '\017'
            pkcs5ParamGen = new PKCS5S1ParametersGenerator(new MD5Digest());
            break;

        case 17: // '\021'
            pkcs5ParamGen = new PKCS5S1ParametersGenerator(new SHA1Digest());
            break;

        default:
            throw new Exception("Not Support MessageDigest Algorithm :".concat(String.valueOf(String.valueOf(eng))));
        }
        pkcs5ParamGen.init(password, salt, iterations);
        return (ParametersWithIV)pkcs5ParamGen.generateDerivedParameters(64, 64);
    }

    public static byte[] PBEEncode(int eng, boolean isEncrypt, ParametersWithIV param, byte data[])
        throws Exception
    {
        if(eng == 18)
            return cipherEncode(7, isEncrypt, param, data);
        if(eng == 19)
            return cipherEncode(11, isEncrypt, param, data);
        else
            throw new Exception("Not support algorithm:".concat(String.valueOf(String.valueOf(eng))));
    }
}