`

Java非对称加密算法RSA

阅读更多

流程分析: 

  1. 甲方构建密钥对儿,将公钥公布给乙方,将私钥保留。
  2. 甲方使用私钥加密数据,然后用私钥对加密后的数据签名,发送给乙方签名以及加密后的数据;乙方使用公钥、签名来验证待解密数据是否有效,如果有效使用公钥对数据解密。
  3. 乙方使用公钥加密数据,向甲方发送经过加密后的数据;甲方获得加密数据,通过私钥解密。
package cn.tzz.java.crypto;

import java.io.IOException;
import java.security.Key;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.HashMap;
import java.util.Map;

import javax.crypto.Cipher;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;
public class RSACryptUtil {

	public static final String KEY_ALGORITHM = "RSA";
	public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
	
	private static final String PUBLIC_KEY = "RSAPublicKey";
	private static final String PRIVATE_KEY = "RSAPrivateKey";
	
	
	public static String encryptBASE64(byte[] key) {  
		return (new BASE64Encoder()).encodeBuffer(key);  
	}
	
	public static byte[] decryptBASE64(String key) throws IOException {  
		return new BASE64Decoder().decodeBuffer(key);
	}
	
	/**初始化密钥*/
	public static Map<String, Object> initKey() {
		KeyPairGenerator keyPairGen;
		Map<String, Object> keyMap = new HashMap<String, Object>(2);
		try {
			keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
			keyPairGen.initialize(1024);
			KeyPair keyPair = keyPairGen.generateKeyPair();
			RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();// 公钥
			RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();// 私钥
			keyMap.put(PUBLIC_KEY, publicKey);
			keyMap.put(PRIVATE_KEY, privateKey);
		} catch (NoSuchAlgorithmException e) {
			e.printStackTrace();
		}
		return keyMap;
	}
	
	/**获取私钥*/
	public static String getPrivateKey(Map<String, Object> keyMap){
		Key key = (Key) keyMap.get(PRIVATE_KEY);
		return encryptBASE64(key.getEncoded());
	}
	
	/**获取公钥*/
	public static String getPublicKey(Map<String, Object> keyMap){
		Key key = (Key) keyMap.get(PUBLIC_KEY);
		return encryptBASE64(key.getEncoded());
	}
	
	/**用公钥解密*/
	public static byte[] decryptByPublicKey(byte[] data, String key) throws Exception {
		byte[] keyBytes = decryptBASE64(key);// 对密钥解密
		// 取得公钥
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key publicKey = keyFactory.generatePublic(x509KeySpec);
		// 对数据解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, publicKey);
		return cipher.doFinal(data);
	}
	
	/**用私钥解密*/
	public static byte[] decryptByPrivateKey(byte[] data, String key) throws Exception {
		byte[] keyBytes = decryptBASE64(key);// 对密钥解密
		// 取得私钥
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
		// 对数据解密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.DECRYPT_MODE, privateKey);
		return cipher.doFinal(data);
	}
	
	/**用公钥加密*/
	public static byte[] encryptByPublicKey(byte[] data, String key) throws Exception {
		byte[] keyBytes = decryptBASE64(key);// 对公钥解密
		// 取得公钥
		X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key publicKey = keyFactory.generatePublic(x509KeySpec);
		// 对数据加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, publicKey);
		return cipher.doFinal(data);
	}
	
	/**用私钥加密*/
	public static byte[] encryptByPrivateKey(byte[] data, String key) throws Exception {
		byte[] keyBytes = decryptBASE64(key);// 对密钥解密
		// 取得私钥
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		Key privateKey = keyFactory.generatePrivate(pkcs8KeySpec);
		// 对数据加密
		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
		cipher.init(Cipher.ENCRYPT_MODE, privateKey);
		return cipher.doFinal(data);
	}
	
	/**
	 * 用私钥对信息生成数字签名
	 * @param data 加密数据
	 * @param privateKey 私钥
	 */
	public static String sign(byte[] data, String privateKey) throws Exception {
		byte[] keyBytes = decryptBASE64(privateKey);// 解密由base64编码的私钥
		// 构造PKCS8EncodedKeySpec对象
		PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
		// KEY_ALGORITHM 指定的加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		// 取私钥匙对象
		PrivateKey priKey = keyFactory.generatePrivate(pkcs8KeySpec);
		// 用私钥对信息生成数字签名
		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		signature.initSign(priKey);
		signature.update(data);
		return encryptBASE64(signature.sign());
	}
	
	/**
	 * 校验数字签名
	 * @param data 加密数据
	 * @param publicKey 公钥
	 * @param sign 数字签名
	 * 
	 * @return 校验成功返回true 失败返回false
	 * 
	 */
	public static boolean verify(byte[] data, String publicKey, String sign) throws Exception {
		byte[] keyBytes = decryptBASE64(publicKey);// 解密由base64编码的公钥
		
		// 构造X509EncodedKeySpec对象
		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
		// KEY_ALGORITHM 指定的加密算法
		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
		// 取公钥匙对象
		PublicKey pubKey = keyFactory.generatePublic(keySpec);
		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
		signature.initVerify(pubKey);
		signature.update(data);
		// 验证签名是否正常
		return signature.verify(decryptBASE64(sign));
	}
	
}

 
测试类:

package cn.tzz.java.crypto;

import java.util.Map;

import org.junit.Test;

public class RSACryptUtilTest {

	private static String publicKey;
	private static String privateKey;
	
	static {
		Map<String, Object> keyMap = RSACryptUtil.initKey();
		publicKey = RSACryptUtil.getPublicKey(keyMap);
		privateKey = RSACryptUtil.getPrivateKey(keyMap);
		System.out.println("公钥: \n\r" + publicKey);
		System.out.println("私钥: \n\r" + privateKey);
	}
	
	@Test
	public void test(){
		try {
			System.out.println("公钥加密---私钥解密");
			String date = "123456";
			byte[] encodedData = RSACryptUtil.encryptByPublicKey(date.getBytes(), publicKey);
			String encodedStr = RSACryptUtil.encryptBASE64(encodedData);
			byte[] decodedData = RSACryptUtil.decryptByPrivateKey(RSACryptUtil.decryptBASE64(encodedStr), privateKey);
			String outputStr = new String(decodedData);
			System.out.println("加密前: " + date + "\n\r" + "加密后: " + encodedStr + "\n\r" + "解密后: " + outputStr);
		} catch (Exception e) {
			e.printStackTrace();
		}
		
	}
	
	@Test
	public void testSign() throws Exception {
		try {
			System.out.println("私钥加密---公钥解密");
			String inputStr = "123456";
			byte[] data = inputStr.getBytes();
			
			byte[] encodedData = RSACryptUtil.encryptByPrivateKey(data, privateKey);
			
			byte[] decodedData = RSACryptUtil.decryptByPublicKey(encodedData, publicKey);
			
			String outputStr = new String(decodedData);
			System.out.println("加密前: " + inputStr + "\n\r" + "解密后: " + outputStr);
			
			System.out.println("私钥签名——公钥验证签名");
			// 产生签名
			String sign = RSACryptUtil.sign(encodedData, privateKey);
			System.out.println("签名:\r" + sign);
			// 验证签名
			boolean status = RSACryptUtil.verify(encodedData, publicKey, sign);
			System.out.println("状态:\r" + status);
		
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

 

 

分享到:
评论

相关推荐

    java 非对称加密算法RSA实现详解

    Java 非对称加密算法RSA实现详解 Java 非对称加密算法RSA实现详解是 Java 语言中的一种常用加密算法,主要用于保护数据的安全性。 RSA 算法是一种基于大数分解的加密算法,它的安全性取决于大数分解的难度。在 Java...

    Rsa.rar_RSA 算法_java 非对称 加密 算法_rsa java

    RSA算法是一种非对称加密算法,它在信息安全领域有着广泛的应用,特别是在数据传输中的安全保护。这个RAR压缩包包含了一个名为“Rsa.java”的源代码文件,可能是用于演示如何在Java环境中实现RSA算法。另一个文件...

    Java加密技术非对称加密算法RSA.doc

    Java加密技术非对称加密算法RSA.doc

    非对称加密算法 数字签名算法

    通过阅读《非对称加密算法 数字签名算法——RSA - 信息安全 - ITeye知识库频道.htm》这篇文章,可以深入理解这些概念,并了解在实际应用中如何使用Java实现这些功能。同时,文件中的`非对称加密算法 数字签名算法...

    java加密算法:Base64加密\数字签名\对称加密算法\非对称加密算法\消息摘要算法

    java关于加密的算法demo代码(Base64加密\数字签名\对称加密算法\非对称加密算法\消息摘要算法) JAVA安全实现三种方式: 1.JDK 2.Commons Codec 3.Bouncy Castle 一。非对称加密算法: 1.DH 2.RSA 3.ELGamal 二。...

    java rsa非对称加密算法3个实例源代码

    java rsa非对称加密算法3个实例源代码

    Java实现文件的RSA和DES加密

    2. 非对称加密算法:非对称加密算法采用加密钥匙(公钥)和解密钥匙(私钥),常用的算法包括 RSA、DSA、ECC 等。 3. 加密算法的选择:在选择加密算法时,需要根据实际情况来确定。如果需要加密大量数据,建议采用...

    非对称加密算法

    非对称加密算法的基础理论主要源于数论和抽象代数,其中最著名的两种算法是RSA和ECC(椭圆曲线加密)。RSA是由Ron Rivest、Adi Shamir和Leonard Adleman在1977年提出的,它基于大整数因子分解的困难性。ECC则依赖于...

    Java公钥加密算法RSA.rar

    RSA,由其发明者Ron Rivest、Adi Shamir和Leonard Adleman的名字首字母组成,是一种非对称加密算法,这意味着它使用一对密钥——公钥和私钥——进行加密和解密。 在Java中实现RSA加密,首先需要通过`java.security....

    非对称加密算法:RSA算法的C++实现与Java实现

    RSA(Rivest-Shamir-Adleman)算法是最早被广泛采用的非对称加密算法之一,其安全性基于大整数因子分解的困难性。本篇将深入探讨RSA算法的理论基础及其在C++和Java两种编程语言中的实现。 RSA算法的基本思想是基于...

    基于JAVA代码非的对称加密RSA的实现及其源代码

    在这篇文档中,我们将深入探讨非对称加密RSA的实现及其源代码,以及如何使用JAVA代码来实现。此外,我们还将介绍RSA加密算法的历史和基本原理,以及RSA加密算法在现代网络安全领域中的应用。通过本文档的学习,您将...

    java实现非对称加密(RSA)(csdn)————程序.pdf

    在Java中,非对称加密算法如RSA是一种广泛使用的安全技术,它允许数据在不安全的环境中进行加密和解密,同时保持数据的机密性。RSA算法基于两个不同的密钥:公钥和私钥。公钥是公开的,任何人都可以获取,用于加密...

    RSA非对称加密的java实现

    * 字符串格式的密钥在未在特殊说明情况下都为BASE64编码格式 * 由于非对称加密速度极其缓慢,一般文件不使用它来... * 非对称加密算法可以用来对对称加密的密钥加密,这样保证密钥的安全也就保证了数据的安全

    java编写的加密解密工具,有对称加密和非对称加密

    Java中常见的非对称加密算法包括RSA(Rivest-Shamir-Adleman)、DSA(Digital Signature Algorithm)和ECC(Elliptic Curve Cryptography)。RSA是一种广泛使用的非对称加密算法,它基于大素数分解的困难性,适用于...

    Java非对称加密源码实例

    在Java中,除了RSA,还有其他非对称加密算法,如DSA、ECC(椭圆曲线加密)。每种算法有其特点和适用场景,例如ECC在提供相同安全级别时,所需的密钥长度更短,因此计算更快,但实现复杂。 总之,Java非对称加密源码...

    Java非对称加密解密(RSA)

    Java作为广泛应用的编程语言,提供了支持非对称加密算法的API,其中包括著名的RSA算法。本篇将深入探讨Java中如何使用RSA进行非对称加密与解密,并结合Bouncy Castle库以增强其功能和安全性。 非对称加密,顾名思义...

    java非对称加密demo(秘钥文件\字符秘钥)

    常见的非对称加密算法有RSA、DSA和ECC等。 1. **生成秘钥文件**: 在Java中,我们可以使用`java.security.KeyPairGenerator`类来生成RSA或DSA等非对称密钥对。首先,需要指定加密算法,然后初始化密钥生成器并生成...

    前后端RSA非对称加密解密(代码示例).rar

    登录时,用户的密码用明文传输...非对称加密算法常用RSA算法,秘钥使用base64编码成字符串,后端使用jdk8的标准API,前端使用jsencrypt.js进行RSA的对应操作。经过测试,本例中的前后端代码的加密解密计算结果是一致的。

Global site tag (gtag.js) - Google Analytics