RSA加密、解密、签名、验签的原理及方法 - PC君 - 博客园

标签: | 发表时间:2021-07-18 10:12 | 作者:
出处:https://www.cnblogs.com

一、RSA加密简介

  RSA加密是一种非对称加密。可以在不直接传递密钥的情况下,完成解密。这能够确保信息的安全性,避免了直接传递密钥所造成的被破解的风险。是由一对密钥来进行加解密的过程,分别称为公钥和私钥。两者之间有数学相关,该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性。通常个人保存私钥,公钥是公开的(可能同时多人持有)。

  

二、RSA加密、签名区别

  加密和签名都是为了安全性考虑,但略有不同。常有人问加密和签名是用私钥还是公钥?其实都是对加密和签名的作用有所混淆。简单的说,加密是为了防止信息被泄露,而签名是为了防止信息被篡改。这里举2个例子说明。

第一个场景:战场上,B要给A传递一条消息,内容为某一指令。

RSA的加密过程如下:

(1)A生成一对密钥(公钥和私钥),私钥不公开,A自己保留。公钥为公开的,任何人可以获取。

(2)A传递自己的公钥给B,B用A的公钥对消息进行加密。

(3)A接收到B加密的消息,利用A自己的私钥对消息进行解密。

  在这个过程中,只有2次传递过程,第一次是A传递公钥给B,第二次是B传递加密消息给A,即使都被敌方截获,也没有危险性,因为只有A的私钥才能对消息进行解密,防止了消息内容的泄露。

 

第二个场景:A收到B发的消息后,需要进行回复“收到”。

RSA签名的过程如下:

(1)A生成一对密钥(公钥和私钥),私钥不公开,A自己保留。公钥为公开的,任何人可以获取。

(2)A用自己的私钥对消息加签,形成签名,并将加签的消息和消息本身一起传递给B。

(3)B收到消息后,在获取A的公钥进行验签,如果验签出来的内容与消息本身一致,证明消息是A回复的。

  在这个过程中,只有2次传递过程,第一次是A传递加签的消息和消息本身给B,第二次是B获取A的公钥,即使都被敌方截获,也没有危险性,因为只有A的私钥才能对消息进行签名,即使知道了消息内容,也无法伪造带签名的回复给B,防止了消息内容的篡改。

 

  但是,综合两个场景你会发现,第一个场景虽然被截获的消息没有泄露,但是可以利用截获的公钥,将假指令进行加密,然后传递给A。第二个场景虽然截获的消息不能被篡改,但是消息的内容可以利用公钥验签来获得,并不能防止泄露。所以在实际应用中,要根据情况使用,也可以同时使用加密和签名,比如A和B都有一套自己的公钥和私钥,当A要给B发送消息时,先用B的公钥对消息加密,再对加密的消息使用A的私钥加签名,达到既不泄露也不被篡改,更能保证消息的安全性。

   总结:公钥加密、私钥解密、私钥签名、公钥验签。

 

三、RSA加密、签名的方法,代码例子如下:

  1 import java.io.ByteArrayOutputStream;
  2 import java.security.KeyFactory;
  3 import java.security.KeyPair;
  4 import java.security.KeyPairGenerator;
  5 import java.security.PrivateKey;
  6 import java.security.PublicKey;
  7 import java.security.Signature;
  8 import java.security.spec.PKCS8EncodedKeySpec;
  9 import java.security.spec.X509EncodedKeySpec;
 10 import javax.crypto.Cipher;
 11 import org.apache.commons.codec.binary.Base64;
 12 
 13 public class TestRSA {
 14 
 15     /**
 16      * RSA最大加密明文大小
 17      */
 18     private static final int MAX_ENCRYPT_BLOCK = 117;
 19 
 20     /**
 21      * RSA最大解密密文大小
 22      */
 23     private static final int MAX_DECRYPT_BLOCK = 128;
 24 
 25     /**
 26      * 获取密钥对
 27      * 
 28      * @return 密钥对
 29      */
 30     public static KeyPair getKeyPair() throws Exception {
 31         KeyPairGenerator generator = KeyPairGenerator.getInstance("RSA");
 32         generator.initialize(1024);
 33         return generator.generateKeyPair();
 34     }
 35 
 36     /**
 37      * 获取私钥
 38      * 
 39      * @param privateKey 私钥字符串
 40      * @return
 41      */
 42     public static PrivateKey getPrivateKey(String privateKey) throws Exception {
 43         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
 44         byte[] decodedKey = Base64.decodeBase64(privateKey.getBytes());
 45         PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(decodedKey);
 46         return keyFactory.generatePrivate(keySpec);
 47     }
 48 
 49     /**
 50      * 获取公钥
 51      * 
 52      * @param publicKey 公钥字符串
 53      * @return
 54      */
 55     public static PublicKey getPublicKey(String publicKey) throws Exception {
 56         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
 57         byte[] decodedKey = Base64.decodeBase64(publicKey.getBytes());
 58         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(decodedKey);
 59         return keyFactory.generatePublic(keySpec);
 60     }
 61     
 62     /**
 63      * RSA加密
 64      * 
 65      * @param data 待加密数据
 66      * @param publicKey 公钥
 67      * @return
 68      */
 69     public static String encrypt(String data, PublicKey publicKey) throws Exception {
 70         Cipher cipher = Cipher.getInstance("RSA");
 71         cipher.init(Cipher.ENCRYPT_MODE, publicKey);
 72         int inputLen = data.getBytes().length;
 73         ByteArrayOutputStream out = new ByteArrayOutputStream();
 74         int offset = 0;
 75         byte[] cache;
 76         int i = 0;
 77         // 对数据分段加密
 78         while (inputLen - offset > 0) {
 79             if (inputLen - offset > MAX_ENCRYPT_BLOCK) {
 80                 cache = cipher.doFinal(data.getBytes(), offset, MAX_ENCRYPT_BLOCK);
 81             } else {
 82                 cache = cipher.doFinal(data.getBytes(), offset, inputLen - offset);
 83             }
 84             out.write(cache, 0, cache.length);
 85             i++;
 86             offset = i * MAX_ENCRYPT_BLOCK;
 87         }
 88         byte[] encryptedData = out.toByteArray();
 89         out.close();
 90         // 获取加密内容使用base64进行编码,并以UTF-8为标准转化成字符串
 91         // 加密后的字符串
 92         return new String(Base64.encodeBase64String(encryptedData));
 93     }
 94 
 95     /**
 96      * RSA解密
 97      * 
 98      * @param data 待解密数据
 99      * @param privateKey 私钥
100      * @return
101      */
102     public static String decrypt(String data, PrivateKey privateKey) throws Exception {
103         Cipher cipher = Cipher.getInstance("RSA");
104         cipher.init(Cipher.DECRYPT_MODE, privateKey);
105         byte[] dataBytes = Base64.decodeBase64(data);
106         int inputLen = dataBytes.length;
107         ByteArrayOutputStream out = new ByteArrayOutputStream();
108         int offset = 0;
109         byte[] cache;
110         int i = 0;
111         // 对数据分段解密
112         while (inputLen - offset > 0) {
113             if (inputLen - offset > MAX_DECRYPT_BLOCK) {
114                 cache = cipher.doFinal(dataBytes, offset, MAX_DECRYPT_BLOCK);
115             } else {
116                 cache = cipher.doFinal(dataBytes, offset, inputLen - offset);
117             }
118             out.write(cache, 0, cache.length);
119             i++;
120             offset = i * MAX_DECRYPT_BLOCK;
121         }
122         byte[] decryptedData = out.toByteArray();
123         out.close();
124         // 解密后的内容 
125         return new String(decryptedData, "UTF-8");
126     }
127 
128     /**
129      * 签名
130      * 
131      * @param data 待签名数据
132      * @param privateKey 私钥
133      * @return 签名
134      */
135     public static String sign(String data, PrivateKey privateKey) throws Exception {
136         byte[] keyBytes = privateKey.getEncoded();
137         PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(keyBytes);
138         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
139         PrivateKey key = keyFactory.generatePrivate(keySpec);
140         Signature signature = Signature.getInstance("MD5withRSA");
141         signature.initSign(key);
142         signature.update(data.getBytes());
143         return new String(Base64.encodeBase64(signature.sign()));
144     }
145 
146     /**
147      * 验签
148      * 
149      * @param srcData 原始字符串
150      * @param publicKey 公钥
151      * @param sign 签名
152      * @return 是否验签通过
153      */
154     public static boolean verify(String srcData, PublicKey publicKey, String sign) throws Exception {
155         byte[] keyBytes = publicKey.getEncoded();
156         X509EncodedKeySpec keySpec = new X509EncodedKeySpec(keyBytes);
157         KeyFactory keyFactory = KeyFactory.getInstance("RSA");
158         PublicKey key = keyFactory.generatePublic(keySpec);
159         Signature signature = Signature.getInstance("MD5withRSA");
160         signature.initVerify(key);
161         signature.update(srcData.getBytes());
162         return signature.verify(Base64.decodeBase64(sign.getBytes()));
163     }
164 
165     public static void main(String[] args) {
166         try {
167             // 生成密钥对
168             KeyPair keyPair = getKeyPair();
169             String privateKey = new String(Base64.encodeBase64(keyPair.getPrivate().getEncoded()));
170             String publicKey = new String(Base64.encodeBase64(keyPair.getPublic().getEncoded()));
171             System.out.println("私钥:" + privateKey);
172             System.out.println("公钥:" + publicKey);
173             // RSA加密
174             String data = "待加密的文字内容";
175             String encryptData = encrypt(data, getPublicKey(publicKey));
176             System.out.println("加密后内容:" + encryptData);
177             // RSA解密
178             String decryptData = decrypt(encryptData, getPrivateKey(privateKey));
179             System.out.println("解密后内容:" + decryptData);
180             
181             // RSA签名
182             String sign = sign(data, getPrivateKey(privateKey));
183             // RSA验签
184             boolean result = verify(data, getPublicKey(publicKey), sign);
185             System.out.print("验签结果:" + result);
186         } catch (Exception e) {
187             e.printStackTrace();
188             System.out.print("加解密异常");
189         }
190     }
191 }

  PS:RSA加密对明文的长度有所限制,规定需加密的明文最大长度=密钥长度-11(单位是字节,即byte),所以在 加密和解密的过程中需要分块进行。而密钥默认是1024位,即1024位/8位-11=128-11=117字节。所以默认加密前的明文最大长度117字节,解密密文最大长度为128字。那么为啥两者相差11字节呢?是因为RSA加密使用到了填充模式(padding),即内容不足117字节时会自动填满,用到填充模式自然会占用一定的字节,而且这部分字节也是参与加密的。

  密钥长度的设置就是上面例子的第32行。可自行调整,当然非对称加密随着密钥变长,安全性上升的同时性能也会有所下降。

相关 [rsa 加密 解密] 推荐:

JAVA实现RSA加密解密

- - CSDN博客推荐文章
提供加密,解密,生成密钥对等方法. RSA加密原理概述   :. RSA的安全性依赖于大数的分解,公钥和私钥都是两个大素数(大于100的十进制位)的函数. 据猜测,从一个密钥和密文推断出明文的难度等同于分解两个大素数的积   .  1.选择两个大素数 p,q ,计算 n=p*q;   .  2.随机选择加密密钥 e ,要求 e 和 (p-1)*(q-1)互质   .

iOS中使用RSA对数据进行加密解密

- - ITeye博客
RSA算法是一种非对称加密算法,常被用于加密数据传输.如果配合上数字摘要算法, 也可以用于文件签名.. 本文将讨论如何在iOS中使用RSA传输加密数据.. openssl-1.0.1j, openssl需要使用1.x版本, 推荐使用[homebrew](http://brew.sh/)安装.. RSA使用"秘匙对"对数据进行加密解密.在加密解密数据前,需要先生成公钥(public key)和私钥(private key)..

对文件压缩加密/解密解压缩的例子,DES/RSA [转]

- - 行业应用 - ITeye博客
RSA压缩加密/解压缩解密. * 对文件压缩加密/解密解压缩 对象类.   // 如果传入的是目录.    // 创建压缩的子目录.    // 把压缩文件加入rar中.   * 对directory目录下的文件压缩,保存为指定的文件zipFile.   * 解压缩文件zipFile保存在directory目录下.

RSA加密、解密、签名、验签的原理及方法 - PC君 - 博客园

- -
  RSA加密是一种非对称加密. 可以在不直接传递密钥的情况下,完成解密. 这能够确保信息的安全性,避免了直接传递密钥所造成的被破解的风险. 是由一对密钥来进行加解密的过程,分别称为公钥和私钥. 两者之间有数学相关,该加密算法的原理就是对一极大整数做因数分解的困难性来保证安全性. 通常个人保存私钥,公钥是公开的(可能同时多人持有).

使用RSA非对称加密JWT | 燃情岁月

- -
JWT几乎是当前分布式开发中无状态token的最佳选择,被越来越多的开发者接受和使用, JWT是基于加密算法的认证方式,省去了到认证服务器的校验过程,认证效率大大提高. 更详细的关于JWT的介绍可以点击 这里查看. 通常大家在使用JWT的时候都是使用 HmacSHA256加密钥的加密方式,这种方式严格依赖密钥,在分布式开发的过程中,通常是由认证服务器生成 JWT,然后再由资源校验 JWT的有效性,那么这时候资源服务器就也需要密钥了,认证服务和资源服务很可能是不同的团队开发和维护,密钥在这个过程中传递,很有可能泄漏.

RSA非对称加密算法详解_u013073067的博客-CSDN博客_rsa算法

- -
RSA加密算法是最常用的非对称加密算法,由 罗纳德·李维斯特(Ron Rivest)、 阿迪·萨莫尔(Adi Shamir)和 伦纳德·阿德曼(Leonard Adleman)于1977年一起提出,RSA就是他们三人姓氏开头字母拼在一起组成的. 非对称加密算法的特点就是加密秘钥和解密秘钥不同,秘钥分为公钥和私钥,用私钥加密的明文,只能用公钥解密;用公钥加密的明文,只能用私钥解密.

Java 进行 RSA 加解密时不得不考虑到的那些事儿

- - zzm
加密的系统不要具备解密的功能,否则 RSA 可能不太合适. 加密的系统和解密的系统分开部署,加密的系统不应该同时具备解密的功能,这样即使黑客攻破了加密系统,他拿到的也只是一堆无法破解的密文数据. 否则的话,你就要考虑你的场景是否有必要用 RSA 了. 可以通过修改生成密钥的长度来调整密文长度. 生成密文的长度等于密钥长度.

RSA算法原理(二)

- - 阮一峰的网络日志
上一次,我介绍了一些 数论知识. 有了这些知识,我们就可以看懂 RSA算法. 这是目前地球上最重要的加密算法. 我们通过一个例子,来理解RSA算法. 假设 爱丽丝要与鲍勃进行加密通信,她该怎么生成公钥和私钥呢. 第一步,随机选择两个不相等的质数p和q. (实际应用中,这两个质数越大,就越难破解.

RSA算法原理(一)

- - 阮一峰的网络日志
如果你问我,哪一种 算法最重要. 我可能会回答 "公钥加密算法". 因为它是计算机通信安全的基石,保证了加密数据不会被破解. 你可以想象一下,信用卡交易被破解的后果. 进入正题之前,我先简单介绍一下,什么是"公钥加密算法". 1976年以前,所有的加密方法都是同一种模式:.   (1)甲方选择某一种加密规则,对信息进行加密;.

RSA的SecureID token数据被偷了?

- ripwu - 张志强的网络日志
博客 » 记事本 » 密码学 ». WSJ报道:RSA承认其数据被偷,4000万SecureID token需要被更新. 中国银行银行密钥用的就是RSA生产,就是下图这玩意儿,手里有这玩意儿的同学们要小心了(当然,如果你的账户里的钱没有6位数以上,也不用太担心,毕竟网银的安全性不全依赖于这个设备):.