import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.util.encoders.Base64;
import org.springframework.util.Base64Utils;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.ShortBufferException;
import java.io.ByteArrayOutputStream;
import java.security.*;
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 java.util.UUID;
import java.util.regex.Pattern; /**
* RSA安全编码组件
*
* @author wbw
* @version 1.0
*/
public class RSAUtils {
/**
* 非对称加密密钥算法
*/
public static final String KEY_ALGORITHM_RSA = "RSA"; private static String RSA_JAVA = "RSA/None/PKCS1Padding"; /**
* 公钥
*/
private static final String RSA_PUBLIC_KEY = "RSAPublicKey"; /**
* 私钥
*/
private static final String RSA_PRIVATE_KEY = "RSAPrivateKey"; /**
* RSA密钥长度
* 默认1024位,
* 密钥长度必须是64的倍数,
* 范围在512至65536位之间。
*/
private static final int KEY_SIZE = ; static{
Security.insertProviderAt(new BouncyCastleProvider(), );
}
/**
* 私钥解密
*
* @param data
* 待解密数据
* @param key
* 私钥
* @return byte[] 解密数据
* @throws Exception
*/
public static byte[] decryptByPrivateKey(byte[] data, byte[] key)
throws Exception { // 取得私钥
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA); // 生成私钥
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec); // 对数据解密
Cipher cipher = Cipher.getInstance(RSA_JAVA); cipher.init(Cipher.DECRYPT_MODE, privateKey); int blockSize = cipher.getBlockSize();
if(blockSize>){
ByteArrayOutputStream bout = new ByteArrayOutputStream();
int j = ;
while (data.length - j * blockSize > ) {
bout.write(cipher.doFinal(data, j * blockSize, blockSize));
j++;
}
return bout.toByteArray();
}
return cipher.doFinal(data);
} /**
* 公钥解密
*
* @param data
* 待解密数据
* @param key
* 公钥
* @return byte[] 解密数据
* @throws Exception
*/
public static byte[] decryptByPublicKey(byte[] data, byte[] key)
throws Exception { // 取得公钥
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA); // 生成公钥
PublicKey publicKey = keyFactory.generatePublic(x509KeySpec); // 对数据解密
Cipher cipher = Cipher.getInstance(RSA_JAVA); cipher.init(Cipher.DECRYPT_MODE, publicKey); return cipher.doFinal(data);
} /**
* 公钥加密
*
* @param data
* 待加密数据
* @param key
* 公钥
* @return byte[] 加密数据
* @throws Exception
*/
public static byte[] encryptByPublicKey(byte[] data, byte[] key)
throws Exception { // 取得公钥
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(key); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA); PublicKey publicKey = keyFactory.generatePublic(x509KeySpec); // 对数据加密
Cipher cipher = Cipher.getInstance(RSA_JAVA); cipher.init(Cipher.ENCRYPT_MODE, publicKey); int blockSize = cipher.getBlockSize();
byte[] raw = getBytes(data, cipher, blockSize);
if (raw != null) {
return raw;
}
return cipher.doFinal(data);
} private static byte[] getBytes(byte[] data, Cipher cipher, int blockSize) throws ShortBufferException, IllegalBlockSizeException, BadPaddingException {
if(blockSize>){
int outputSize = cipher.getOutputSize(data.length);
int leavedSize = data.length % blockSize;
int blocksSize = leavedSize != ? data.length / blockSize +
: data.length / blockSize;
byte[] raw = new byte[outputSize * blocksSize];
int i = ,remainSize=;
while ((remainSize = data.length - i * blockSize) > ) {
int inputLen = remainSize > blockSize?blockSize:remainSize;
cipher.doFinal(data, i * blockSize, inputLen, raw, i * outputSize);
i++;
}
return raw;
}
return null;
} /**
* 私钥加密
*
* @param data
* 待加密数据
* @param key
* 私钥
* @return byte[] 加密数据
* @throws Exception
*/
public static byte[] encryptByPrivateKey(byte[] data, byte[] key)
throws Exception { // 取得私钥
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(key); KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM_RSA); // 生成私钥
PrivateKey privateKey = keyFactory.generatePrivate(pkcs8KeySpec); // 对数据加密
Cipher cipher = Cipher.getInstance(RSA_JAVA); cipher.init(Cipher.ENCRYPT_MODE, privateKey); int blockSize = cipher.getBlockSize();
byte[] raw = getBytes(data, cipher, blockSize);
return cipher.doFinal(data);
} /**
* 取得私钥
*
* @param keyMap
* 密钥Map
* @return key 私钥
* @throws Exception
*/
public static Key getPrivateKey(Map<String, Key> keyMap)
throws Exception {
return keyMap.get(RSA_PRIVATE_KEY);
} /**
* 取得私钥
*
* @param keyMap
* 密钥Map
* @return byte[] 私钥
* @throws Exception
*/
public static byte[] getPrivateKeyByte(Map<String, Key> keyMap)
throws Exception {
return keyMap.get(RSA_PRIVATE_KEY).getEncoded();
} /**
* 取得公钥
*
* @param keyMap
* 密钥Map
* @return key 公钥
* @throws Exception
*/
public static Key getPublicKey(Map<String, Key> keyMap)
throws Exception {
return keyMap.get(RSA_PUBLIC_KEY);
} /**
* 取得公钥
*
* @param keyMap
* 密钥Map
* @return byte[] 公钥
* @throws Exception
*/
public static byte[] getPublicKeyByte(Map<String, Key> keyMap)
throws Exception {
return keyMap.get(RSA_PUBLIC_KEY).getEncoded();
} /**
* 初始化密钥
* @param seed 种子
* @return Map 密钥Map
* @throws Exception
*/
public static Map<String,Key> initKey(byte[] seed)throws Exception{
// 实例化密钥对生成器
KeyPairGenerator keyPairGen = KeyPairGenerator
.getInstance(KEY_ALGORITHM_RSA); // 初始化密钥对生成器
keyPairGen.initialize(KEY_SIZE, new SecureRandom(seed) ); // 生成密钥对
KeyPair keyPair = keyPairGen.generateKeyPair(); // 公钥
RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic(); // 私钥
RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate(); // 封装密钥
Map<String, Key> keyMap = new HashMap<String, Key>(); keyMap.put(RSA_PUBLIC_KEY, publicKey);
keyMap.put(RSA_PRIVATE_KEY, privateKey); return keyMap;
} /**
* 初始化密钥
* @param seed 种子
* @return Map 密钥Map
* @throws Exception
*/
public static Map<String,Key> initKey(String seed)throws Exception{
return initKey(seed.getBytes());
} /**
* 初始化密钥
*
* @return Map 密钥Map
* @throws Exception
*/
public static Map<String, Key> initKey() throws Exception {
return initKey(UUID.randomUUID().toString().getBytes());
} public static PublicKey getPublicRSAKey(String key) throws Exception {
X509EncodedKeySpec x509 = new X509EncodedKeySpec(Base64.decode(key));
KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM_RSA);
return kf.generatePublic(x509);
} public static PrivateKey getPrivateRSAKey(String key) throws Exception {
PKCS8EncodedKeySpec pkgs8 = new PKCS8EncodedKeySpec(Base64.decode(key));
KeyFactory kf = KeyFactory.getInstance(KEY_ALGORITHM_RSA);
return kf.generatePrivate(pkgs8);
} }

调用

class RSAUtilsTest {
private static String PUBLIC_KEY = "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCAHzDQssuIce0x5thZdTbS1N/iJtkpluE5X3sU0nvRIUAmkqVi9zCuJrRizpOCSGatkX21gQjwJRb7Fz/H38HuyeSv6myLHBbQU866eU3nJPpuQcYiWQMbcWv+y2Y9y0oOqjEZwv+ERj0mLYGO+SHftYwJ3T6yyeHXd3VcMBKkiQIDAQAB";
private static String PRIVATE_KEY= "MIICWwIBAAKBgQCAHzDQssuIce0x5thZdTbS1N/iJtkpluE5X3sU0nvRIUAmkqVi9zCuJrRizpOCSGatkX21gQjwJRb7Fz/H38HuyeSv6myLHBbQU866eU3nJPpuQcYiWQMbcWv+y2Y9y0oOqjEZwv+ERj0mLYGO+SHftYwJ3T6yyeHXd3VcMBKkiQIDAQABAoGAGk/Ng56kY/IZpzzkQ4Lp7mRfUh9uS7c7q7+rFDyhxvIQLZvCMU/YhHtYYk5QRto9k/mkGmlUf5TuYkSFCbQvLGGpc7WKOvEuoHzXcHAc1peQa5+7WKDjhs8R9W6T5g4cYnqknTWNh1nfVbM9GOBdDLFxBJgJVh/r2fvhpB1WL4ECQQCQf2yrKiiHJsEIuO67iVRy54HcEnZvV0nYVnhFNWfDLtMIm/6I7G6n0MZHGWCIs77EPAhiMtg9IioE3I0Q/neZAkEA4vzQE6VcG12MoYkmudgmpnO3YjPdST9Ui1sEhrxvqXNru+ykfwx3kWZt42yv5471FytVSPJwXwX63fnfNp7qcQJAbRaWLr68LBR45SHgsdpi1ACtTDzwBuzKRjY5xF4mQPenwLcsOajtfWojVuf0th+lJLcByUkDcVvKhzMOmMbT+QJAPc9GAfOHb1Q8FUi5qOW5MJ5WE4G4Algid4gjZWUuqt/pOFUqPgZxEMDpr4JLLCz7hIGiSajq/JUuSP/fzonboQJAbWcNpngj5xddtGn/PVE1Zv9iwJmfD+/9Y9nQ+0AO/FFK6ruFEjikefkrB8byBcGy6fU7ax7AjqsF5HdsE1BfaA=="; public static String rsaPublicEncryptAndPrivateKeyDecrypt(String rawText) { byte[] privateKey = Base64Utils.decodeFromString(PRIVATE_KEY);
byte[] publicKey = Base64Utils.decodeFromString(PUBLIC_KEY);
try {
System.out.println("原数据为:"+rawText);
byte[] encryptByPublicKey = RSAUtils.encryptByPublicKey(rawText.getBytes(),
publicKey);
String encryptByPublicKeyString = Base64Utils.encodeToString(encryptByPublicKey);
System.out.println("公钥加密后的数据为:"+encryptByPublicKeyString);
byte[] decryptByPrivateKey = RSAUtils.decryptByPrivateKey(
Base64Utils.decodeFromString(encryptByPublicKeyString),
privateKey);
String result=new String(decryptByPrivateKey);
System.out.println("私钥解密后的数据为:"+result);
return result;
} catch (Exception e) {
System.out.println(e);
} return null;
} public static void main(String[] args) {
System.out.println(rsaPublicEncryptAndPrivateKeyDecrypt("Hello world!"));
}
}

输出

原数据为:Hello world!
公钥加密后的数据为:fymr5G4ZWIy3ek9xJ+KAtNAKHVOjX9qPgPDF9wSofGaPsOuRMTz3LvvmpA8CCYJT/Y3TzXEQPWQjUwhcqH/AkDorf78oe1zbXE3m47Unua7yhsGNZdCE14j5JfXB5t6JZ3VOBycLMXgCw6Ol3m3lkaaa6xxAuH5sMN0haseERs8=
私钥解密后的数据为:Hello world!

RSAUtils非对称加密的更多相关文章

  1. RSA非对称加密简析-java

    1 非对称加密算法 1.1 概述 1976年,美国学者Dime和Henman为解决信息公开传送和密钥管理问题,提出一种新的密钥交换协议,允许在不安全的媒体上的通讯双方交换信息,安全地达成一致的密钥,这 ...

  2. RSA 非对称加密【转】

    演示代码:https://pan.baidu.com/s/10rfSUUDEEHvCDEYH0oEVCw Base64工具类,可以让rsa编码的乱码变成一串字符序列 1 package com.uti ...

  3. 使用 RSA 非对称加密保证数据不被篡改 java 例子代码

    原理: 对原始数据 生成有序的json 字符串,然后取 摘要,然后 对摘要 进项 分对称加密.( 不对原数据加密是应为 原数据太大,加解密速度太慢,非对称加密都不 挺慢的.在摘要函数具有雪崩效应 ,原 ...

  4. JAVA 非对称加密工具

    import java.io.File; import java.io.FileInputStream; import java.math.BigInteger; import java.securi ...

  5. Java 实现 RSA 非对称加密

    非对称加密算法:用两个密钥(公钥/私钥)对数据进行加密和解密. 一.原理 非对称加密算法实现机密信息交换的基本过程是: 1)甲方生成一对密钥并将其中的一把作为公用密钥向其它方公开; 2)得到该公用密钥 ...

  6. RSA非对称加密(java实例代码)

    使用RSA对WebService传递的信息加密解密的基本思想是:服务器端提供一个WebService方法String getServerPublicKey(),客户端可以以此得到服务器端的公钥,然后使 ...

  7. RSA非对称加密,使用OpenSSL生成证书,iOS加密,java解密

    最近换了一份工作,工作了大概一个多月了吧.差不多得有两个月没有更新博客了吧.在新公司自己写了一个iOS的比较通用的可以架构一个中型应用的不算是框架的一个结构,并已经投入使用.哈哈 说说文章标题的相关的 ...

  8. 个人理解c#对称加密 非对称加密 散列算法的应用场景

    c#类库默认实现了一系列加密算法在System.Security.Cryptography; 命名空间下 对称加密 通过同一密匙进行加密和解密.往往应用在内部数据传输情况下.比如公司a程序 和B程序 ...

  9. 介绍DSA数字签名,非对称加密的另一种实现

    接下来我们介绍DSA数字签名,非对称加密的另一种实现. DSA DSA-Digital Signature Algorithm 是Schnorr和ElGamal签名算法的变种,被美国NIST作为DSS ...

随机推荐

  1. 向对象(OO)程序设计

    http://www.uml.org.cn/mxdx/201208232.asp 前言 本文主要介绍面向对象(OO)程序设计,以维基百科的解释: 面向对象程序设计(英语:Object-oriented ...

  2. CDATA嵌套问题

    在CDATA内部的所有内容都会被解析器忽略.一个 CDATA 部件以"<![CDATA[" 标记开始,以"]]>"标记结束.但是CDATA是不能够嵌 ...

  3. requests对象

    属性 0.HttpRequest.scheme 表示请求方案的字符串(通常为http或https) 1.HttpRequest.body 一个字符串,代表请求报文的主体.在处理非 HTTP 形式的报文 ...

  4. 4.3.1 ThreadLoacl简单使用

    我们都知道  SimpleDateFormat 这个类是线程 不安全的,那么我下面的程序执行就会遇到问题 public class ParseDateDemo { private static fin ...

  5. [GO]使用select实现超时

    package main import ( "fmt" "time" ) func main() { ch := make(chan int) quit := ...

  6. UVa 1608 Non-boring sequences (分治)

    题意:给你一个长度为n序列,如果这个任意连续子序列的中都有至少出现一次的元素,那么就称这个序列是不无聊的,判断这个序列是不是无聊的. 析:首先如果整个序列中有一个只出过一次的元素,假设是第 p 个,那 ...

  7. linux 不在sudoers文件中、普通用户获得sudo权限

    现在要让jack用户获得sudo使用权 切换到超级用户root $su root 查看/etc/sudoers权限,可以看到当前权限为440 $ ls -all /etc/sudoers -r--r- ...

  8. 理解Javascript的Prototype

    在Javascript中创建对象主要分为三种方式 1. var catA = {name: "Fluffy", color: "White", age: 0}; ...

  9. Ubuntu下常见的问题记录与处理

    经常使用Ubuntu系统,总会遇到各种问题,找到了解决方法,记录在此吧!常言好记性不好烂笔头~ 以下是目前遇到的一些问题,不分先后记录,后面遇到新的问题并找到解决方法也会更新记录的~ 一.共享文件(使 ...

  10. Linux CentOS 7 安装confluence 5.8.10

    一..需要下载的安装包如下 1.atlassian-confluence-5.8.10-x64.bin #confluence安装包 2.confluence5.x-crack.zip #conflu ...