距离上一次写博客感觉已经很长时间了，先吐槽一下，这个月以来，公司一直在加班，又是发版、上线，又是新项目太紧，具体的就不多说了。今天来说说非对称加密真的是太重要了，我们的日常生活中，都离不开非对称加密。
概念
在说 rsa 之前，首先聊聊什么是非对称加密。在讲对称加密的时候，就曾经说过，对称加密算法在加密和解密时使用的是同一个秘钥，加解密双方必须使用同一个密钥才能进行正常的沟通。而非对称加密则不然，非对称加密算法需要两个密钥来进行加密和解密，分别是公钥和私钥。
需要注意的一点，这个公钥和私钥必须是一对的，如果用公钥对数据进行加密，那么只有使用对应的私钥才能解密，反之亦然。由于加密和解密使用的是两个不同的密钥，因此，这种算法叫做非对称加密算法。
工作过程
如下图，甲乙之间使用非对称加密的方式传输数据。
在非对称加密中使用的主要算法有：rsa、elgamal、背包算法、rabin、d-h、ecc（椭圆曲线加密算法）等。今天主要是介绍 rsa ，至于其他的算法，后续会选择几个进行介绍。
rsa
其实，在早在 1978 年的时候，rsa就已经出现了，它是第一个既能用于数据加密也能用于数字签名的算法。它易于理解和操作，也很流行。其原理就如上面的工作过程所述。
rsa 算法基于一个十分简单的数论事实：将两个大素数相乘十分容易，但是想要对其乘积进行因式分解却极其困难，因此可以将乘积公开作为加密密钥。
代码实现
下面来看一下具体的代码实现。
我要评论
import com.google.common.collect.maps;
import sun.misc.base64decoder;
import sun.misc.base64encoder;
import javax.crypto.cipher;
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.map;
/**
* created by xiang.li on 2015/3/3.
* rsa 加解密工具类
*/
public class rsa {
/**
* 定义加密方式
*/
private final static string key_rsa = "rsa";
/**
* 定义签名算法
*/
private final static string key_rsa_signature = "md5withrsa";
/**
* 定义公钥算法
*/
private final static string key_rsa_publickey = "rsapublickey";
/**
* 定义私钥算法
*/
private final static string key_rsa_privatekey = "rsaprivatekey";
/**
* 初始化密钥
* @return
*/
public static map<string, object> init() {
map<string, object> map = null;
try {
keypairgenerator generator = keypairgenerator.getinstance(key_rsa);
generator.initialize(1024);
keypair keypair = generator.generatekeypair();
// 公钥
rsapublickey publickey = (rsapublickey) keypair.getpublic();
// 私钥
rsaprivatekey privatekey = (rsaprivatekey) keypair.getprivate();
// 将密钥封装为map
map = maps.newhashmap();
map.put(key_rsa_publickey, publickey);
map.put(key_rsa_privatekey, privatekey);
} catch (nosuchalgorithmexception e) {
e.printstacktrace();
}
return map;
}
/**
* 用私钥对信息生成数字签名
* @param data 加密数据
* @param privatekey 私钥
* @return
*/
public static string sign(byte[] data, string privatekey) {
string str = "";
try {
// 解密由base64编码的私钥
byte[] bytes = decryptbase64(privatekey);
// 构造pkcs8encodedkeyspec对象
pkcs8encodedkeyspec pkcs = new pkcs8encodedkeyspec(bytes);
// 指定的加密算法
keyfactory factory = keyfactory.getinstance(key_rsa);
// 取私钥对象
privatekey key = factory.generateprivate(pkcs);
// 用私钥对信息生成数字签名
signature signature = signature.getinstance(key_rsa_signature);
signature.initsign(key);
signature.update(data);
str = encryptbase64(signature.sign());
} catch (exception e) {
e.printstacktrace();
}
return str;
}
/**
* 校验数字签名
* @param data 加密数据
* @param publickey 公钥
* @param sign 数字签名
* @return 校验成功返回true，失败返回false
*/
public static boolean verify(byte[] data, string publickey, string sign) {
boolean flag = false;
try {
// 解密由base64编码的公钥
byte[] bytes = decryptbase64(publickey);
// 构造x509encodedkeyspec对象
x509encodedkeyspec keyspec = new x509encodedkeyspec(bytes);
// 指定的加密算法
keyfactory factory = keyfactory.getinstance(key_rsa);
// 取公钥对象
publickey key = factory.generatepublic(keyspec);
// 用公钥验证数字签名
signature signature = signature.getinstance(key_rsa_signature);
signature.initverify(key);
signature.update(data);
flag = signature.verify(decryptbase64(sign));
} catch (exception e) {
e.printstacktrace();
}
return flag;
}
/**
* 私钥解密
* @param data 加密数据
* @param key 私钥
* @return
*/
public static byte[] decryptbyprivatekey(byte[] data, string key) {
byte[] result = null;
try {
// 对私钥解密
byte[] bytes = decryptbase64(key);
// 取得私钥
pkcs8encodedkeyspec keyspec = new pkcs8encodedkeyspec(bytes);
keyfactory factory = keyfactory.getinstance(key_rsa);
privatekey privatekey = factory.generateprivate(keyspec);
// 对数据解密
cipher cipher = cipher.getinstance(factory.getalgorithm());
cipher.init(cipher.decrypt_mode, privatekey);
result = cipher.dofinal(data);
} catch (exception e) {
e.printstacktrace();
}
return result;
}
/**
* 私钥解密
* @param data 加密数据
* @param key 公钥
* @return
*/
public static byte[] decryptbypublickey(byte[] data, string key) {
byte[] result = null;
try {
// 对公钥解密
byte[] bytes = decryptbase64(key);
// 取得公钥
x509encodedkeyspec keyspec = new x509encodedkeyspec(bytes);
keyfactory factory = keyfactory.getinstance(key_rsa);
publickey publickey = factory.generatepublic(keyspec);
// 对数据解密
cipher cipher = cipher.getinstance(factory.getalgorithm());
cipher.init(cipher.decrypt_mode, publickey);
result = cipher.dofinal(data);
} catch (exception e) {
e.printstacktrace();
}
return result;
}
/**
* 公钥加密
* @param data 待加密数据
* @param key 公钥
* @return
*/
public static byte[] encryptbypublickey(byte[] data, string key) {
byte[] result = null;
try {
byte[] bytes = decryptbase64(key);
// 取得公钥
x509encodedkeyspec keyspec = new x509encodedkeyspec(bytes);
keyfactory factory = keyfactory.getinstance(key_rsa);
publickey publickey = factory.generatepublic(keyspec);
// 对数据加密
cipher cipher = cipher.getinstance(factory.getalgorithm());
cipher.init(cipher.encrypt_mode, publickey);
result = cipher.dofinal(data);
} catch (exception e) {
e.printstacktrace();
}
return result;
}
/**
* 私钥加密
* @param data 待加密数据
* @param key 私钥
* @return
*/
public static byte[] encryptbyprivatekey(byte[] data, string key) {
byte[] result = null;
try {
byte[] bytes = decryptbase64(key);
// 取得私钥
pkcs8encodedkeyspec keyspec = new pkcs8encodedkeyspec(bytes);
keyfactory factory = keyfactory.getinstance(key_rsa);
privatekey privatekey = factory.generateprivate(keyspec);
// 对数据加密
cipher cipher = cipher.getinstance(factory.getalgorithm());
cipher.init(cipher.encrypt_mode, privatekey);
result = cipher.dofinal(data);
} catch (exception e) {
e.printstacktrace();
}
return result;
}
/**
* 获取公钥
* @param map
* @return
*/
public static string getpublickey(map<string, object> map) {
string str = "";
try {
key key = (key) map.get(key_rsa_publickey);
str = encryptbase64(key.getencoded());
} catch (exception e) {
e.printstacktrace();
}
return str;
}
/**
* 获取私钥
* @param map
* @return
*/
public static string getprivatekey(map<string, object> map) {
string str = "";
try {
key key = (key) map.get(key_rsa_privatekey);
str = encryptbase64(key.getencoded());
} catch (exception e) {
e.printstacktrace();
}
return str;
}
/**
* 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);
}
/**
* 测试方法
* @param args
*/
public static void main(string[] args) {
string privatekey = "";
string publickey = "";
// 生成公钥私钥
map<string, object> map = init();
publickey = getpublickey(map);
privatekey = getprivatekey(map);
system.out.println("公钥: \n\r" + publickey);
system.out.println("私钥： \n\r" + privatekey);
system.out.println("公钥加密--------私钥解密");
string word = "你好，世界！";
byte[] encword = encryptbypublickey(word.getbytes(), publickey);
string decword = new string(decryptbyprivatekey(encword, privatekey));
system.out.println("加密前: " + word + "\n\r" + "解密后: " + decword);
system.out.println("私钥加密--------公钥解密");
string english = "hello, world!";
byte[] encenglish = encryptbyprivatekey(english.getbytes(), privatekey);
string decenglish = new string(decryptbypublickey(encenglish, publickey));
system.out.println("加密前: " + english + "\n\r" + "解密后: " + decenglish);
system.out.println("私钥签名——公钥验证签名");
// 产生签名
string sign = sign(encenglish, privatekey);
system.out.println("签名:\r" + sign);
// 验证签名
boolean status = verify(encenglish, publickey, sign);
system.out.println("状态:\r" + status);
}
}
加解密结果
结束语
其实，看似很复杂的过程，用一句话就可以描述：使用公钥加密、私钥解密，完成了乙方到甲方的一次数据传递，通过私钥加密、公钥解密，同时通过私钥签名、公钥验证签名，完成了一次甲方到乙方的数据传递与验证，两次数据传递完成一整套的数据交互。
非对称加密算法的出现，就是为了解决只有一把密钥的加解密，只要这一把密钥丢失或者被公开，那么加密数据就很容易被攻击。同时，也正是由于非对称加密算法的出现，才有了后面的数字签名、数字证书等等。
好了，今天就到这吧，下一篇继续非对称加密，至于哪一种，到时候就知道了，这里先保密
如对本文有疑问， 点击进行留言回复！！
现在微服务这么火，你还不了解吗？阿里P8推荐的微服务学习指南
论文笔记：SlowFast Networks for Video Recognition
网友评论