Java加密技术（七）——非对称加密算法最高级ECC

时间  2019-11-13
标签 java 加密 技术 非对称 算法 最高级 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类见 Java加密技术（一）
Java代码 复制代码  收藏代码
  1. import java.math.BigInteger;  
  2. import java.security.Key;  
  3. import java.security.KeyFactory;  
  4. import java.security.interfaces.ECPrivateKey;  
  5. import java.security.interfaces.ECPublicKey;  
  6. import java.security.spec.ECFieldF2m;  
  7. import java.security.spec.ECParameterSpec;  
  8. import java.security.spec.ECPoint;  
  9. import java.security.spec.ECPrivateKeySpec;  
  10. import java.security.spec.ECPublicKeySpec;  
  11. import java.security.spec.EllipticCurve;  
  12. import java.security.spec.PKCS8EncodedKeySpec;  
  13. import java.security.spec.X509EncodedKeySpec;  
  14. import java.util.HashMap;  
  15. import java.util.Map;  
  16.   
  17. import javax.crypto.Cipher;  
  18. import javax.crypto.NullCipher;  
  19.   
  20. import sun.security.ec.ECKeyFactory;  
  21. import sun.security.ec.ECPrivateKeyImpl;  
  22. import sun.security.ec.ECPublicKeyImpl;  
  23.   
  24. /** 
  25.  * ECC安全编码组件 
  26.  *  
  27.  * @author 梁栋 
  28.  * @version 1.0 
  29.  * @since 1.0 
  30.  */  
  31. public abstract class ECCCoder extends Coder {  
  32.   
  33.     public static final String ALGORITHM = "EC";  
  34.     private static final String PUBLIC_KEY = "ECCPublicKey";  
  35.     private static final String PRIVATE_KEY = "ECCPrivateKey";  
  36.   
  37.     /** 
  38.      * 解密<br> 
  39.      * 用私钥解密 
  40.      *  
  41.      * @param data 
  42.      * @param key 
  43.      * @return 
  44.      * @throws Exception 
  45.      */  
  46.     public static byte[] decrypt(byte[] data, String key) throws Exception {  
  47.         // 对密钥解密  
  48.         byte[] keyBytes = decryptBASE64(key);  
  49.   
  50.         // 取得私钥  
  51.         PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);  
  52.         KeyFactory keyFactory = ECKeyFactory.INSTANCE;  
  53.   
  54.         ECPrivateKey priKey = (ECPrivateKey) keyFactory  
  55.                 .generatePrivate(pkcs8KeySpec);  
  56.   
  57.         ECPrivateKeySpec ecPrivateKeySpec = new ECPrivateKeySpec(priKey.getS(),  
  58.                 priKey.getParams());  
  59.   
  60.         // 对数据解密  
  61.         // TODO Chipher不支持EC算法 未能实现  
  62.         Cipher cipher = new NullCipher();  
  63.         // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());  
  64.         cipher.init(Cipher.DECRYPT_MODE, priKey, ecPrivateKeySpec.getParams());  
  65.   
  66.         return cipher.doFinal(data);  
  67.     }  
  68.   
  69.     /** 
  70.      * 加密<br> 
  71.      * 用公钥加密 
  72.      *  
  73.      * @param data 
  74.      * @param privateKey 
  75.      * @return 
  76.      * @throws Exception 
  77.      */  
  78.     public static byte[] encrypt(byte[] data, String privateKey)  
  79.             throws Exception {  
  80.         // 对公钥解密  
  81.         byte[] keyBytes = decryptBASE64(privateKey);  
  82.   
  83.         // 取得公钥  
  84.         X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);  
  85.         KeyFactory keyFactory = ECKeyFactory.INSTANCE;  
  86.   
  87.         ECPublicKey pubKey = (ECPublicKey) keyFactory  
  88.                 .generatePublic(x509KeySpec);  
  89.   
  90.         ECPublicKeySpec ecPublicKeySpec = new ECPublicKeySpec(pubKey.getW(),  
  91.                 pubKey.getParams());  
  92.   
  93.         // 对数据加密  
  94.         // TODO Chipher不支持EC算法 未能实现  
  95.         Cipher cipher = new NullCipher();  
  96.         // Cipher.getInstance(ALGORITHM, keyFactory.getProvider());  
  97.         cipher.init(Cipher.ENCRYPT_MODE, pubKey, ecPublicKeySpec.getParams());  
  98.   
  99.         return cipher.doFinal(data);  
  100.     }  
  101.   
  102.     /** 
  103.      * 取得私钥 
  104.      *  
  105.      * @param keyMap 
  106.      * @return 
  107.      * @throws Exception 
  108.      */  
  109.     public static String getPrivateKey(Map<String, Object> keyMap)  
  110.             throws Exception {  
  111.         Key key = (Key) keyMap.get(PRIVATE_KEY);  
  112.   
  113.         return encryptBASE64(key.getEncoded());  
  114.     }  
  115.   
  116.     /** 
  117.      * 取得公钥 
  118.      *  
  119.      * @param keyMap 
  120.      * @return 
  121.      * @throws Exception 
  122.      */  
  123.     public static String getPublicKey(Map<String, Object> keyMap)  
  124.             throws Exception {  
  125.         Key key = (Key) keyMap.get(PUBLIC_KEY);  
  126.   
  127.         return encryptBASE64(key.getEncoded());  
  128.     }  
  129.   
  130.     /** 
  131.      * 初始化密钥 
  132.      *  
  133.      * @return 
  134.      * @throws Exception 
  135.      */  
  136.     public static Map<String, Object> initKey() throws Exception {  
  137.         BigInteger x1 = new BigInteger(  
  138.                 "2fe13c0537bbc11acaa07d793de4e6d5e5c94eee8", 16);  
  139.         BigInteger x2 = new BigInteger(  
  140.                 "289070fb05d38ff58321f2e800536d538ccdaa3d9", 16);  
  141.   
  142.         ECPoint g = new ECPoint(x1, x2);  
  143.   
  144.         // the order of generator  
  145.         BigInteger n = new BigInteger(  
  146.                 "5846006549323611672814741753598448348329118574063", 10);  
  147.         // the cofactor  
  148.         int h = 2;  
  149.         int m = 163;  
  150.         int[] ks = { 7, 6, 3 };  
  151.         ECFieldF2m ecField = new ECFieldF2m(m, ks);  
  152.         // y^2+xy=x^3+x^2+1  
  153.         BigInteger a = new BigInteger("1", 2);  
  154.         BigInteger b = new BigInteger("1", 2);  
  155.   
  156.         EllipticCurve ellipticCurve = new EllipticCurve(ecField, a, b);  
  157.   
  158.         ECParameterSpec ecParameterSpec = new ECParameterSpec(ellipticCurve, g,  
  159.                 n, h);  
  160.         // 公钥  
  161.         ECPublicKey publicKey = new ECPublicKeyImpl(g, ecParameterSpec);  
  162.   
  163.         BigInteger s = new BigInteger(  
  164.                 "1234006549323611672814741753598448348329118574063", 10);  
  165.         // 私钥  
  166.         ECPrivateKey privateKey = new ECPrivateKeyImpl(s, ecParameterSpec);  
  167.   
  168.         Map<String, Object> keyMap = new HashMap<String, Object>(2);  
  169.   
  170.         keyMap.put(PUBLIC_KEY, publicKey);  
  171.         keyMap.put(PRIVATE_KEY, privateKey);  
  172.   
  173.         return keyMap;  
  174.     }  
  175.   
  176. }   
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";

	/**
	 * 解密<br>
	 * 用私钥解密
	 * 
	 * @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);
	}

	/**
	 * 加密<br>
	 * 用公钥加密
	 * 
	 * @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<String, Object> keyMap)
			throws Exception {
		Key key = (Key) keyMap.get(PRIVATE_KEY);

		return encryptBASE64(key.getEncoded());
	}

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

		return encryptBASE64(key.getEncoded());
	}

	/**
	 * 初始化密钥
	 * 
	 * @return
	 * @throws Exception
	 */
	public static Map<String, Object> 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<String, Object> keyMap = new HashMap<String, Object>(2);

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

		return keyMap;
	}

}


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

照旧提供一个测试类：
Java代码 复制代码  收藏代码
  1. import static org.junit.Assert.*;  
  2.   
  3. import java.math.BigInteger;  
  4. import java.security.spec.ECFieldF2m;  
  5. import java.security.spec.ECParameterSpec;  
  6. import java.security.spec.ECPoint;  
  7. import java.security.spec.ECPrivateKeySpec;  
  8. import java.security.spec.ECPublicKeySpec;  
  9. import java.security.spec.EllipticCurve;  
  10. import java.util.Map;  
  11.   
  12. import org.junit.Test;  
  13.   
  14. /** 
  15.  *  
  16.  * @author 梁栋 
  17.  * @version 1.0 
  18.  * @since 1.0 
  19.  */  
  20. public class ECCCoderTest {  
  21.   
  22.     @Test  
  23.     public void test() throws Exception {  
  24.         String inputStr = "abc";  
  25.         byte[] data = inputStr.getBytes();  
  26.   
  27.         Map<String, Object> keyMap = ECCCoder.initKey();  
  28.   
  29.         String publicKey = ECCCoder.getPublicKey(keyMap);  
  30.         String privateKey = ECCCoder.getPrivateKey(keyMap);  
  31.         System.err.println("公钥: \n" + publicKey);  
  32.         System.err.println("私钥： \n" + privateKey);  
  33.   
  34.         byte[] encodedData = ECCCoder.encrypt(data, publicKey);  
  35.   
  36.         byte[] decodedData = ECCCoder.decrypt(encodedData, privateKey);  
  37.   
  38.         String outputStr = new String(decodedData);  
  39.         System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);  
  40.         assertEquals(inputStr, outputStr);  
  41.     }  
  42. }   
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<String, Object> 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);
	}
}


控制台输出：
Console代码 复制代码  收藏代码
  1. 公钥:   
  2. MEAwEAYHKoZIzj0CAQYFK4EEAAEDLAAEAv4TwFN7vBGsqgfXk95ObV5clO7oAokHD7BdOP9YMh8u  
  3. gAU21TjM2qPZ  
  4.   
  5. 私钥：   
  6. MDICAQAwEAYHKoZIzj0CAQYFK4EEAAEEGzAZAgEBBBTYJsR3BN7TFw7JHcAHFkwNmfil7w==  
  7.   
  8. 加密前: abc  
  9.   
  10. 解密后: abc 
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程