`
crazier9527
  • 浏览: 1008782 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

Java加密技术（七）

    博客分类：
  • Java
JavaSecurity算法junitSUN 
阅读更多
ECC
ECC-Elliptic Curves Cryptography，椭圆曲线密码编码学，是目前已知的公钥体制中，对每比特所提供加密强度最高的一种体制。在软件注册保护方面起到很大的作用，一般的序列号通常由该算法产生。
    当我开始整理《Java加密技术（二）》的时候，我就已经在开始研究ECC了，但是关于Java实现ECC算法的资料实在是太少了，无论是国内还是国外的资料，无论是官方还是非官方的解释，最终只有一种答案——ECC算法在jdk1.5后加入支持，目前仅仅只能完成密钥的生成与解析，对于通过密钥对数据进行处理的java实现仅在javacard项目中使用。 这已经是另一个领域了，完全跳出了J2SE的范畴，我就不再继续追根溯源了。
    尽管如此，我照旧提供相应的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.   
  2. import static org.junit.Assert.*;   
  3.   
  4. import java.math.BigInteger;   
  5. import java.security.spec.ECFieldF2m;   
  6. import java.security.spec.ECParameterSpec;   
  7. import java.security.spec.ECPoint;   
  8. import java.security.spec.ECPrivateKeySpec;   
  9. import java.security.spec.ECPublicKeySpec;   
  10. import java.security.spec.EllipticCurve;   
  11. import java.util.Map;   
  12.   
  13. import org.junit.Test;   
  14.   
  15. /**  
  16.  *   
  17.  * @author 梁栋  
  18.  * @version 1.0  
  19.  * @since 1.0  
  20.  */  
  21. public class ECCCoderTest {   
  22.   
  23.     @Test  
  24.     public void test() throws Exception {   
  25.         String inputStr = "abc";   
  26.         byte[] data = inputStr.getBytes();   
  27.   
  28.         Map<String, Object> keyMap = ECCCoder.initKey();   
  29.   
  30.         String publicKey = ECCCoder.getPublicKey(keyMap);   
  31.         String privateKey = ECCCoder.getPrivateKey(keyMap);   
  32.         System.err.println("公钥: \n" + publicKey);   
  33.         System.err.println("私钥： \n" + privateKey);   
  34.   
  35.         byte[] encodedData = ECCCoder.encrypt(data, publicKey);   
  36.   
  37.         byte[] decodedData = ECCCoder.decrypt(encodedData, privateKey);   
  38.   
  39.         String outputStr = new String(decodedData);   
  40.         System.err.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);   
  41.         assertEquals(inputStr, outputStr);   
  42.     }   
  43. }  
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
分享到：
| Java加密技术（六）
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Java加密技术

    Java加密技术

    java加密技术详解

    ### Java加密技术详解：以MD5为例 在Java中，加密技术是确保数据安全和完整性的关键工具之一。本文将深入探讨Java中的加密技术，特别是MD5加密算法，通过实例和代码片段，帮助读者理解其工作原理及如何在实际项目中...

    基于JAVA的加密算法（包括10种加密技术）

    Java加密技术（一） 关键字: java 加密基础, base64, md5, mac, sha, 单向加密 。。。。。。。。。。。。。。

    java加密技术大全

    Java加密技术是保护数据安全的重要工具，广泛应用于网络通信、数据存储、数字签名等领域。本资源包涵盖了Java中常见的加密算法和技术，包括基础的哈希算法、对称加密、非对称加密以及证书签名和SSL/TLS协议。下面将...

    java加密技术 （网页版）

    Java加密技术是软件开发中一个重要的安全领域，主要用于保护数据的隐私性和完整性。在这个网页版的资源中，可能涵盖了各种加密算法的Java实现，以及它们之间的比较。让我们深入探讨一下这些知识点。 首先，我们来看...

    运用加密技术保护java源代码

    因此，运用加密技术保护Java源代码成为了一项重要的课题。 ### Java源代码加密的重要性 Java源代码加密主要涉及两个层面：一是源代码本身的安全，二是编译后的字节码（.class文件）的安全。对于源代码，加密可以...

    JAVA加密技术.docx

    在Java编程中，加密技术是确保信息安全的关键组成部分。本文将探讨几种常见的加密算法，包括单向加密和对称及非对称加密算法。首先，我们来看基础的单向加密算法，如BASE64、MD5、SHA和HMAC。 **BASE64** 是一种...

    java加密技术研究

    java加密技术研究

    Java加密技术(一)

    总之，Java加密技术提供了丰富的工具和算法，可以帮助开发者构建安全的应用程序。然而，随着技术的发展，加密算法的安全性也需要不断更新，以抵御新的攻击手段。在设计系统时，应考虑最新的安全标准和最佳实践，确保...

    java加密技术

    Java加密技术是Java编程语言中用于保障数据安全的一系列加密方法和技术，它包括了单向加密算法、对称加密算法、非对称加密算法以及加密算法的高级应用如数字签名和数字证书等。本文将详细介绍这些加密技术，并结合...

    Java加密技术(四)

    总结来说，Java加密技术第四部分主要介绍了ECC加密技术的概念、其在Java中的有限支持，以及如何通过Java代码实现ECC的加密和解密操作。尽管Java的标准实现并不直接支持ECC的加密/解密，但可以通过扩展和利用非公开...

    Java加密技术全集

    Java加密技术是信息安全领域的重要组成部分，它用于保护数据的隐私性和完整性。在这个“Java加密技术全集”中，我们将会探讨MD5、SHA和BASE64等常见的加密算法及其在Java中的实现。 MD5（Message-Digest Algorithm ...

    Java加密技术(三)

    Java加密技术(三),相当有用的加密技术(三)，值得学习参考！希望对你有点帮助！

    Java加密技术 pdf版

    Java加密技术 pdf版 加密解密，曾经是我一个毕业设计的重要组件。在工作了多年以后回想当时那个加密、解密算法，实在是太单纯了。 言归正传，这里我们主要描述Java已经实现的一些加密解密算法，最后介绍数字证书

    Java加密技术（技巧与实例） pdf.rar

    Java加密技术是软件开发中一个至关重要的领域，特别是在保护数据安全、验证信息完整性和实现安全通信方面。本书“Java加密技术（技巧与实例）”深入浅出地探讨了这一主题，为开发者提供了丰富的实践指导。以下是一些...

    Java加密技术MD5/BASE64等加密技术

    Java加密技术是软件开发中的重要组成部分，特别是在保护数据安全、用户隐私以及确保网络通信的完整性方面。本资源主要关注两种常见的加密算法：MD5（Message-Digest Algorithm 5）和BASE64编码，它们在Java中有着...

Magicbox
Global site tag (gtag.js) - Google Analytics