JAVA 非对称加密算法RSA

非对称加密算法 RSA过程：以甲乙双方为例
　　1、初始化密钥构建密钥对,生成公钥、私钥保存到keymap中
　　　　KeyPairGenerator ---> KeyPair --> RSAPublicKey、RSAPrivateKey
　　2、甲方使用私钥加密, 加密后在用私钥对加密数据进行数据签名，然后发送给乙方
　　　　RSACoder.encryptByPrivateKey(data, privateKey);
　　　　RSACoder.sign(encodedData, privateKey);
　　3、乙方则通过公钥验证签名的加密数据，如果验证正确则在通过公钥对加密数据进行解密
　　　　RSACoder.verify(encodedData, publicKey, sign);
　　　　RSACoder.decryptByPublicKey(encodedData, publicKey);
　　 4、乙方在通过公钥加密发送给甲方
　　　　RSACoder.encryptByPublicKey(decodedData, publicKey);
　　5、甲方通过私钥解密该数据
　　　　RSACoder.decryptPrivateKey(encodedData, privateKey);
流程图如下：

java代码实现如下：

package com.bank.utils;

import java.security.MessageDigest;

import javax.crypto.KeyGenerator;

import javax.crypto.Mac;

import javax.crypto.SecretKey;

import javax.crypto.spec.SecretKeySpec;

import sun.misc.BASE64Decoder;

import sun.misc.BASE64Encoder;

public abstract class Coder {

	public static final String KEY_SHA = "SHA";

	public static final String KEY_MD5 = "MD5";

	/**

     * MAC算法可选以下多种算法

     *

     * <pre>

     * HmacMD5

     * HmacSHA1

     * HmacSHA256

     * HmacSHA384

     * HmacSHA512

     * </pre>

     */

	public static final String KEY_MAC = "HmacMD5";

	/**

	 * BASE64解密

	 * @param key

	 * @return

	 * @throws Exception

	 */

	public static byte[] decryptBASE64( String key ) throws Exception{

		return (new BASE64Decoder()).decodeBuffer(key);

	}

	/**

	 * BASE64加密

	 * @param key

	 * @return

	 * @throws Exception

	 */

	public static String encryptBASE64( byte[] key) throws Exception{

		return (new BASE64Encoder()).encodeBuffer(key);

	}

	/**

	 * MD5 加密

	 * @param data

	 * @return

	 * @throws Exception

	 */

	public static byte[] encryptMD5( byte[] data) throws Exception {

		MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);

		md5.update(data);

		return md5.digest();

	}

	/**

	 * SHA 加密

	 * @param data

	 * @return

	 * @throws Exception

	 */

	public static byte[] encryptSHA( byte[] data) throws Exception {

		MessageDigest sha = MessageDigest.getInstance(KEY_SHA);

		sha.update(data);

		return sha.digest();

	}

	/**

     * 初始化HMAC密钥

     *

     * @return

     * @throws Exception

     */

	public static String initMacKey() throws Exception{

		KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);

		SecretKey secretKey = keyGenerator.generateKey();

		return encryptBASE64(secretKey.getEncoded());

	}

	/**

	 * HMAC  加密

	 * @param data

	 * @param key

	 * @return

	 * @throws Exception

	 */

	public static byte[] encryptHMAC( byte[] data, String key) throws Exception{

		SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);

		Mac mac = Mac.getInstance(secretKey.getAlgorithm());

		mac.init(secretKey);

		return mac.doFinal(data);

	}

}

package com.bank.utils;

import java.security.Key;

import java.security.KeyFactory;

import java.security.KeyPair;

import java.security.KeyPairGenerator;

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;

public abstract class RSACoder extends Coder{

	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";

	/**

	 * 用私钥对信息生成数字签名

	 * @param data 加密数据

	 * @param privateKey 私钥

	 * @return

	 * @throws Exception

	 */

	public static String sign(byte[] data, String privateKey) throws Exception {

		//解密由base64编码的私钥

		byte[] keyBytes = decryptBASE64(privateKey);

		PKCS8EncodedKeySpec pkcs8EncodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);

		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

		//取私钥对象

		PrivateKey pKey = keyFactory.generatePrivate(pkcs8EncodedKeySpec);

		//用私钥生成数字签名

		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

		signature.initSign(pKey);

		signature.update(data);

		return encryptBASE64(signature.sign());

	}

	/**

	 * 校验数字签名

	 * @param data 加密数据

	 * @param publicKey 公钥

	 * @param sign 数字签名

	 * @return

	 * @throws Exception

	 */

	public static boolean verify(byte[] data, String publicKey, String sign) throws Exception{

		//解密有base64编码的公钥

		byte[] keyBytes = decryptBASE64(publicKey);

		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

		//取公钥对象

		PublicKey pKey = keyFactory.generatePublic(keySpec);

		Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);

		signature.initVerify(pKey);

		signature.update(data);

		//验证签名是否正常

		return signature.verify(decryptBASE64(sign));

	}

	/**

	 * 解密

	 * 	用私钥解密

	 * @param data 加密数据

	 * @param key

	 * @return

	 * @throws Exception

	 */

	public static byte[] decryptPrivateKey(byte[] data, String key) throws Exception{

		byte[] keyBytes = decryptBASE64(key);

		//取得私钥

		PKCS8EncodedKeySpec encodedKeySpec = new PKCS8EncodedKeySpec(keyBytes);

		KeyFactory factory = KeyFactory.getInstance(KEY_ALGORITHM);

		Key pKey = factory.generatePrivate(encodedKeySpec);

		//对数据解密

		Cipher cipher = Cipher.getInstance(factory.getAlgorithm());

		cipher.init(Cipher.DECRYPT_MODE, pKey);

		return cipher.doFinal(data);

	}

	/**

	 * 用公钥解密

	 * @param data

	 * @param key

	 * @return

	 * @throws Exception

	 */

	public static byte[] decryptByPublicKey( byte[] data, String key) throws Exception{

		//解密

		byte[] keyBytes = decryptBASE64(key);

		//取得公钥

		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

		Key pKey = keyFactory.generatePublic(keySpec);

		//对数据解密

		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

		cipher.init(Cipher.DECRYPT_MODE, pKey);

		return cipher.doFinal(data);

	}

	/**

	 * 用公钥加密

	 * @param data

	 * @param key

	 * @return

	 * @throws Exception

	 */

	public static byte[] encryptByPublicKey( byte[] data, String key) throws Exception{

		byte[] keyBytes = decryptBASE64(key);

		X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);

		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

		Key pKey = keyFactory.generatePublic(keySpec);

		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

		cipher.init(Cipher.ENCRYPT_MODE, pKey);

		return cipher.doFinal(data);

	}

	/**

	 * 用私钥加密

	 * @param data

	 * @param key

	 * @return

	 * @throws Exception

	 */

	public static byte[] encryptByPrivateKey(byte[] data, String key) throws Exception{

		byte[] keyBytes = decryptBASE64(key);

		PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);

		KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);

		Key privateKey = keyFactory.generatePrivate(keySpec);

		Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());

		cipher.init(Cipher.ENCRYPT_MODE, privateKey);

		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{

		KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KEY_ALGORITHM);

		keyPairGenerator.initialize(1024);

		KeyPair keyPair = keyPairGenerator.generateKeyPair();

		//公钥

		RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();

		//私钥

		RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

		Map<String, Object> keyMap = new HashMap<String, Object>(2);

		keyMap.put(PRIVATE_KEY, privateKey);

		keyMap.put(PUBLIC_KEY, publicKey);

		return keyMap;

	}

}

package com.bank.test;

import java.util.Map;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

import com.bank.utils.RSACoder;

public class RSACoderTest {

	private String publicKey;

	private String privateKey;

	/*

	 * 非对称加密算法   RSA过程 ： 以甲乙双方为例

	 * 		1、初始化密钥 构建密钥对,生成公钥、私钥保存到keymap中

	 * 				KeyPairGenerator --->	KeyPair		-->		RSAPublicKey、RSAPrivateKey

	 * 		2、甲方使用私钥加密, 加密后在用私钥对加密数据进行数据签名，然后发送给乙方

	 * 				RSACoder.encryptByPrivateKey(data, privateKey);

	 * 				RSACoder.sign(encodedData, privateKey);

	 * 		3、乙方则通过公钥验证签名的加密数据，如果验证正确则在通过公钥对加密数据进行解密

	 * 				RSACoder.verify(encodedData, publicKey, sign);

	 * 				RSACoder.decryptByPublicKey(encodedData, publicKey);

	 *

	 * 		4、乙方在通过公钥加密发送给甲方

	 * 				RSACoder.encryptByPublicKey(decodedData, publicKey);

	 * 		5、甲方通过私钥解密该数据

	 * 				RSACoder.decryptPrivateKey(encodedData, privateKey);

	 */

	@Before

	public void setUp() throws Exception {

		Map<String , Object> keyMap = RSACoder.initKey();

		publicKey = RSACoder.getPublicKey(keyMap);

		privateKey = RSACoder.getPrivateKey(keyMap);

		System.out.println("公钥：\n" + publicKey);

		System.out.println("私钥：\n" + privateKey);

	}

	@Test

	public void test() throws Exception{

		String inputStr = "abc";

		byte[] data = inputStr.getBytes();//每次的得到的字节数组是不一样的。

		//第二步 私钥加密

		byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);

		//私钥进行数据签名

		String sign = RSACoder.sign(encodedData, privateKey);

		//第三步 公钥验证数字签名

		boolean flag = RSACoder.verify(encodedData, publicKey, sign);

		System.out.println("flag:" + flag);

		//用公钥对数据解密

		byte[] decodedData = RSACoder.decryptByPublicKey(encodedData, publicKey);

		System.out.println("data:" + data + "加密数据：" + encodedData + "    解密数据：" + decodedData);

		System.out.println("加密前数据-：" + new String(data) + "     解密后数据： " + new String(decodedData));

		//第四步使用公钥加密数据

		encodedData = RSACoder.encryptByPublicKey(decodedData, publicKey);

		//第五步 使用私钥解密数据

		decodedData = RSACoder.decryptPrivateKey(encodedData, privateKey);

		System.out.println("data:" + data + "加密数据：" + encodedData + "    解密数据：" + decodedData);

		System.out.println("加密前数据：" + inputStr + "     解密后数据： " + new String(decodedData));

	}

	@Test

	public void test1() throws Exception{

		System.out.println("私钥加密-----公钥解密");

		String inputStr = "abc";

		byte[] data = inputStr.getBytes();

		System.out.println("data:" + data);

		byte[] encodedData = RSACoder.encryptByPrivateKey(data, privateKey);

		byte[] decodedData = RSACoder.decryptByPublicKey(encodedData, publicKey);

		String outputStr = new String( decodedData );

		System.out.println("加密前：" + inputStr +"\n 解密后：" + outputStr);

		Assert.assertEquals(inputStr, outputStr);

		System.out.println("私钥签名---公钥验证签名");

		//产生签名

		String sign = RSACoder.sign(encodedData, privateKey);

		System.out.println("签名：\r" + sign);

		//验证签名

		boolean flag = RSACoder.verify(encodedData, publicKey, sign);

		System.out.println("状态：\r" + flag);

		Assert.assertTrue(flag);

	}

}

JAVA 非对称加密算法RSA的更多相关文章

Java进阶(七)Java加密技术之非对称加密算法RSA
Java加密技术(四)--非对称加密算法RSA 非对称加密算法--RSA 基本概念非对称加密算法是一种密钥的保密方法. 非对称加密算法需要两个密钥:公开密钥(publickey)和私有密钥(priv ...
Java加密技术（四）非对称加密算法RSA
RSA 这样的算法1978年就出现了.它是第一个既能用于数据加密也能用于数字签名的算法.它易于理解和操作.也非常流行.算法的名字以发明者的名字命名:Ron Rivest, AdiShamir ...
非对称加密算法-RSA算法
一.概述 1.RSA是基于大数因子分解难题.目前各种主流计算机语言都支持RSA算法的实现 2.java6支持RSA算法 3.RSA算法可以用于数据加密和数字签名 4.RSA算法相对于DES/AES等对 ...
非对称加密算法RSA使用注意事项
原文:非对称加密算法RSA使用注意事项第一个问题,也是最重要的一个——RSA无法对超过117字节的数据进行加密!切记!其实也勿需要求对更大数据的加密,虽然网上已经有相关解决方案,比如BigInteg ...
非对称加密算法RSA 学习
非对称加密算法RSA 学习 RSA加密算法是一种非对称加密算法.RSA是1977年由罗纳德·李维斯特(Ron Rivest).阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Ad ...
非对称加密算法-RSA
注意:本节内容主要参考自<Java加密与解密的艺术(第2版)>第8章“高等加密算法--非对称加密算法” 12.1.RSA(最经典的非对称加密算法) 特点: 使用一套密钥即可完成加解密(与D ...
第十二章非对称加密算法-RSA
注意:本节内容主要参考自<Java加密与解密的艺术(第2版)>第8章“高等加密算法--非对称加密算法” 12.1.RSA(最经典的非对称加密算法) 特点: 使用一套密钥即可完成加解密(与D ...
非对称加密算法RSA
RSA公钥加密算法是1977年由罗纳德·李维斯特(Ron Rivest).阿迪·萨莫尔(Adi Shamir)和伦纳德·阿德曼(Leonard Adleman)一起提出的.1987年首次公布,当时他们 ...
信息加密之非对称加密算法RSA
前面为大家已经总结了,基于密钥交换的DH算法,现在就为大家再介绍一种基于因子分解的RSA算法,这种加密算法有两种实现形式:1.公钥加密,私钥解密:2.私钥加密,公钥解密.下面就为大家分析一下实现代码, ...

随机推荐

Combobox的使用，日期选择器
using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; usin ...
给MySQL字段添加索引的操作
1.添加PRIMARY KEY(主键索引): ALTER TABLE `table_name` ADD PRIMARY KEY ( `column` ) 2.添加UNIQUE(唯一索引) : ALTE ...
[Leetcode] 1.Two Sum（unordered_map）
1.首先想到的方法就是两个for循环全部遍历,代码如下,可通过,但效率太低 class Solution { public: vector<int> twoSum(vector<in ...
C++基础知识（二）
八. 继承:让某个类的对象获得另一个类的对象的特性.通过继承可实现代码重用,即从已存在的类派生出的一个新类将自动具有原来那个类的特性. 类的继承还具有:(1)单向性:A类为B类的基类(父类),则派生类 ...
hdu 1392 Surround the Trees (凸包)
Surround the Trees Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Other ...
BZOJ1502：[NOI2005]月下柠檬树——题解
https://www.lydsy.com/JudgeOnline/problem.php?id=1502 https://www.luogu.org/problemnew/show/P4207 李哲 ...
HDOJ(HDU).1015 Safecracker (DFS)
HDOJ(HDU).1015 Safecracker [从零开始DFS(2)] 从零开始DFS HDOJ.1342 Lotto [从零开始DFS(0)] - DFS思想与框架/双重DFS HDOJ.1 ...
wildcard ，notdir ，patsubst ，obj=$(dir:%.c=%.o)
Makefile中wildcard的介绍在Makefile规则中,通配符会被自动展开.但在变量的定义和函数引用时,通配符将失效.这种情况下如果需要通配符有效,就需要使用函数“wildcard”,它的 ...
剑桥offer（21~30）
21.题目描述输入一个字符串,按字典序打印出该字符串中字符的所有排列.例如输入字符串abc,则打印出由字符a,b,c所能排列出来的所有字符串abc,acb,bac,bca,cab和cba. 还不 ...
noip模拟赛但有用
题目描述给定一个 n ∗ m 个矩阵,矩阵中每个数都是 [1, 12] 内的整数.你可以执行下列两个操作任意多次: • 指定一行,将该行所有数字 +1. • 指定一列,将该列所有数字 +1. 如果执 ...

JAVA 非对称加密算法RSA

JAVA 非对称加密算法RSA的更多相关文章

随机推荐

热门专题