ECC加密算法 java

ECC 
ECC-Elliptic Curves Cryptography，椭圆曲线密码编码学，是目前已知的公钥体制中，对每比特所提供加密强度最高的一种体制。在软件注册保护方面起到很大的作用，一般的序列号通常由该算法产生。 
    当我开始整理《Java加密技术（二）》的时候，我就已经在开始研究ECC了，但是关于Java实现ECC算法的资料实在是太少了，无论是国内还是国外的 资料，无论是官方还是非官方的解释，最终只有一种答案——ECC算法在jdk1.5后加入支持，目前仅仅只能完成密钥的生成与解析。 如果想要获得ECC算法实现，需要调用硬件完成加密/解密（ECC算法相当耗费资源，如果单纯使用CPU进行加密/解密，效率低下），涉及到Java Card领域，PKCS#11。 其实，PKCS#11配置很简单，但缺乏硬件设备，无法尝试！ 

    尽管如此，我照旧提供相应的Java实现代码，以供大家参考。 

通过java代码实现如下：Coder类见

import  java.math.BigInteger;
import  java.security.Key;
import  java.security.KeyFactory;
import  java.security.interfaces.ECPrivateKey;
import  java.security.interfaces.ECPublicKey;
import  java.security.spec.ECFieldF2m;
import  java.security.spec.ECParameterSpec;
import  java.security.spec.ECPoint;
import  java.security.spec.ECPrivateKeySpec;
import  java.security.spec.ECPublicKeySpec;
import  java.security.spec.EllipticCurve;
import  java.security.spec.PKCS8EncodedKeySpec;
import  java.security.spec.X509EncodedKeySpec;
import  java.util.HashMap;
import  java.util.Map;

import  javax.crypto.Cipher;
import  javax.crypto.NullCipher;

import  sun.security.ec.ECKeyFactory;
import  sun.security.ec.ECPrivateKeyImpl;
import  sun.security.ec.ECPublicKeyImpl;

/**
 * ECC安全编码组件
 *
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
public  abstract  class  ECCCoder  extends  Coder {

    public  static  final  String ALGORITHM =  "EC" ;
    private  static  final  String PUBLIC_KEY =  "ECCPublicKey" ;
    private  static  final  String PRIVATE_KEY =  "ECCPrivateKey" ;

    /**
     * 解密
     * 用私钥解密
     *
     * @param data
     * @param key
     * @return
     * @throws Exception
     */
    public  static  byte [] decrypt( byte [] data, String key)  throws  Exception {
        // 对密钥解密
        byte [] keyBytes = decryptBASE64(key);

        // 取得私钥
        PKCS8EncodedKeySpec pkcs8KeySpec =  new  PKCS8EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = ECKeyFactory.INSTANCE;

        ECPrivateKey priKey = (ECPrivateKey) keyFactory
                .generatePrivate(pkcs8KeySpec);

        ECPrivateKeySpec ecPrivateKeySpec =  new  ECPrivateKeySpec(priKey.getS(),
                priKey.getParams());

        // 对数据解密
        // TODO Chipher不支持EC算法 未能实现
        Cipher cipher =  new  NullCipher();
        // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());
        cipher.init(Cipher.DECRYPT_MODE, priKey, ecPrivateKeySpec.getParams());

        return  cipher.doFinal(data);
    }

    /**
     * 加密
     * 用公钥加密
     *
     * @param data
     * @param privateKey
     * @return
     * @throws Exception
     */
    public  static  byte [] encrypt( byte [] data, String privateKey)
            throws  Exception {
        // 对公钥解密
        byte [] keyBytes = decryptBASE64(privateKey);

        // 取得公钥
        X509EncodedKeySpec x509KeySpec =  new  X509EncodedKeySpec(keyBytes);
        KeyFactory keyFactory = ECKeyFactory.INSTANCE;

        ECPublicKey pubKey = (ECPublicKey) keyFactory
                .generatePublic(x509KeySpec);

        ECPublicKeySpec ecPublicKeySpec =  new  ECPublicKeySpec(pubKey.getW(),
                pubKey.getParams());

        // 对数据加密
        // TODO Chipher不支持EC算法 未能实现
        Cipher cipher =  new  NullCipher();
        // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());
        cipher.init(Cipher.ENCRYPT_MODE, pubKey, ecPublicKeySpec.getParams());

        return  cipher.doFinal(data);
    }

    /**
     * 取得私钥
     *
     * @param keyMap
     * @return
     * @throws Exception
     */
    public  static  String getPrivateKey(Map keyMap)
            throws  Exception {
        Key key = (Key) keyMap.get(PRIVATE_KEY);

        return  encryptBASE64(key.getEncoded());
    }

    /**
     * 取得公钥
     *
     * @param keyMap
     * @return
     * @throws Exception
     */
    public  static  String getPublicKey(Map keyMap)
            throws  Exception {
        Key key = (Key) keyMap.get(PUBLIC_KEY);

        return  encryptBASE64(key.getEncoded());
    }

    /**
     * 初始化密钥
     *
     * @return
     * @throws Exception
     */
    public  static  Map initKey()  throws  Exception {
        BigInteger x1 =  new  BigInteger(
                "2fe13c0537bbc11acaa07d793de4e6d5e5c94eee8" ,  16 );
        BigInteger x2 =  new  BigInteger(
                "289070fb05d38ff58321f2e800536d538ccdaa3d9" ,  16 );

        ECPoint g =  new  ECPoint(x1, x2);

        // the order of generator
        BigInteger n =  new  BigInteger(
                "5846006549323611672814741753598448348329118574063" ,  10 );
        // the cofactor
        int  h =  2 ;
        int  m =  163 ;
        int [] ks = {  7 ,  6 ,  3  };
        ECFieldF2m ecField =  new  ECFieldF2m(m, ks);
        // y^2+xy=x^3+x^2+1
        BigInteger a =  new  BigInteger( "1" ,  2 );
        BigInteger b =  new  BigInteger( "1" ,  2 );

        EllipticCurve ellipticCurve =  new  EllipticCurve(ecField, a, b);

        ECParameterSpec ecParameterSpec =  new  ECParameterSpec(ellipticCurve, g,
                n, h);
        // 公钥
        ECPublicKey publicKey =  new  ECPublicKeyImpl(g, ecParameterSpec);

        BigInteger s =  new  BigInteger(
                "1234006549323611672814741753598448348329118574063" ,  10 );
        // 私钥
        ECPrivateKey privateKey =  new  ECPrivateKeyImpl(s, ecParameterSpec);

        Map keyMap =  new  HashMap( 2 );

        keyMap.put(PUBLIC_KEY, publicKey);
        keyMap.put(PRIVATE_KEY, privateKey);

        return  keyMap;
    }

}

    请注意上述代码中的TODO内容，再次提醒注意，Chipher不支持EC算法 ，以上代码仅供参考。Chipher、Signature、KeyPairGenerator、KeyAgreement、SecretKey均不支持EC算法。为了确保程序能够正常执行，我们使用了NullCipher类，验证程序。

照旧提供一个测试类：

import  static  org.junit.Assert.*;

import  java.math.BigInteger;
import  java.security.spec.ECFieldF2m;
import  java.security.spec.ECParameterSpec;
import  java.security.spec.ECPoint;
import  java.security.spec.ECPrivateKeySpec;
import  java.security.spec.ECPublicKeySpec;
import  java.security.spec.EllipticCurve;
import  java.util.Map;

import  org.junit.Test;

/**
 *
 * @author 梁栋
 * @version 1.0
 * @since 1.0
 */
public  class  ECCCoderTest {

    @Test
    public  void  test()  throws  Exception {
        String inputStr =  "abc" ;
        byte [] data = inputStr.getBytes();

        Map keyMap = ECCCoder.initKey();

        String publicKey = ECCCoder.getPublicKey(keyMap);
        String privateKey = ECCCoder.getPrivateKey(keyMap);
        System.err.println( "公钥: \n"  + publicKey);
        System.err.println( "私钥： \n"  + privateKey);

        byte [] encodedData = ECCCoder.encrypt(data, publicKey);

        byte [] decodedData = ECCCoder.decrypt(encodedData, privateKey);

        String outputStr =  new  String(decodedData);
        System.err.println( "加密前: "  + inputStr +  "\n\r"  +  "解密后: "  + outputStr);
        assertEquals(inputStr, outputStr);
    }
}

控制台输出：

公钥: 
MEAwEAYHKoZIzj0CAQYFK4EEAAEDLAAEAv4TwFN7vBGsqgfXk95ObV5clO7oAokHD7BdOP9YMh8u
gAU21TjM2qPZ

私钥： 
MDICAQAwEAYHKoZIzj0CAQYFK4EEAAEEGzAZAgEBBBTYJsR3BN7TFw7JHcAHFkwNmfil7w==

加密前: abc

解密后: abc

    本篇的主要内容为Java证书体系的实现。