Python的RSA加密和PBE加密
最近在写接口的时候，遇到了须要使用RSA加密和PBE加密的状况，对方公司提供的DEMO都是JAVA的，我须要用python来实现。
在网上搜了一下，python的RSA加密这块写的仍是比较多的，可是PBE较少。因此我就讲讲我在RSA加密上面遇到的坑，你们权当一乐。PBE加密里面的盐、密钥。java
RSApython
什么是RSA加密呢？算法
其实RSA是一种非对称加密，那什么是非对称加密呢？非对称加密又叫作公开密钥加密，就是说我有一对密钥，分为公钥和私钥。私钥我悄悄的留着，不给别人看。而后把公钥给别人（不管是谁）。当别人用公钥加密了数据以后，这串加密后的数据只有我（拥有私钥的人）用私钥才能解开，其他谁都不能解开。这就是非对称加密。apache
这只是单向的，只是我解开数据 —— 我获取信息。json
那么我怎么向别人传递信息呢？别人怎么保证我传递的信息就是我发出的呢？这时候就须要私钥来加密了，又叫作数字签名。我把数据签名以后数据和未签名的数据一齐发给别人，别人经过公钥来解密加密的数据，而后把解密后的数据和未签名的数据进行对比，相同的话就表明数据来源正确。api
可能说的有点乱，我上次看到一个很是清晰明了的例子，我凭着记忆大体讲出来：安全
老板派员工小明去外地考察商机。网络
小明任务作的很棒，很快就发现了商机。这时候他要想老板汇报，可是网络是不安全的，颇有可能一给老板发情报邮件，邮件就被竞争对手获得了。此次考察也就失败了。app
因而，小明经过事先老板给他的公钥来加密情报。python2.7
这样，老板可以经过私钥来解密获得情报，而竞争对手只能对一堆乱码发呆。
此次情报让老板很满意，老板决定让小明继续深刻考察。
可是这个继续深刻考察的命令在网络中传输是不安全的，竞争对手虽然得不到情报，可是能够经过黑客来篡改命令啊，假如让小明回公司，那么这就不划算了，也浪费了时间。
这时候，老板就用私钥对本身下达的命令进行签名，把签名后的数据和明文的命令一齐发出去，小明收到邮件以后，对签名后的数据和命令用公钥进行验证，若是一致，就表明没有被篡改，能够放心大胆的事实老板的命令。
……………………………………………………分割线………………………………………………
那么我写的接口呢，是这样的。
我司要经过接口获取对方公司的数据，获取数据就要传递参数过去，对方根据参数而后返回相应的数据。
对方公司生成私钥和公钥，我司生成私钥和公钥，双方交换公钥。
一、使用对方公司的公钥对全部的参数进行加密，加密以后进行base64编码。
二、使用我司私钥对加密后的数据进行签名，签名以后进行base64编码。
三、而后把加密后的数据和签名后的数据一齐发送给对方。
坑1：RSA最长只支持117为的数据进行加密，因此须要进行分段加密，并且须要先拼接再进行base64编码，排错以前一直写的是先base64编码再拼接。
坑2：分段加密以后要进行相应的签名，是须要进行MD5转码的。
talk is more， show your code。
Java：
加密：
private static final int MAX_ENCRYPT_BLOCK = 117;
public static final String KEY_ALGORITHM = "RSA"
/** *//**
* <p>
* 公钥加密
* </p>
*
* @param data 源数据
* @param publicKey 公钥(BASE64编码)
* @return
* @throws Exception
*/
public static byte[] encryptByPublicKey(byte[] data, String publicKey)
throws Exception {
byte[] keyBytes = Base64.decode(publicKey);
X509EncodedKeySpec x509KeySpec = new X509EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
Key publicK = keyFactory.generatePublic(x509KeySpec);
// 对数据加密
Cipher cipher = Cipher.getInstance(keyFactory.getAlgorithm());
cipher.init(Cipher.ENCRYPT_MODE, publicK);
int inputLen = data.length;
ByteArrayOutputStream out = new ByteArrayOutputStream();
int offSet = 0;
byte[] cache;
int i = 0;
// 对数据分段加密
while (inputLen - offSet > 0) {
if (inputLen - offSet > MAX_ENCRYPT_BLOCK) {
cache = cipher.doFinal(data, offSet, MAX_ENCRYPT_BLOCK);
} else {
cache = cipher.doFinal(data, offSet, inputLen - offSet);
}
out.write(cache, 0, cache.length);
i++;
offSet = i * MAX_ENCRYPT_BLOCK;
}
byte[] encryptedData = out.toByteArray();
out.close();
return encryptedData;
}
经过这段代码，咱们注意到：
一、分段加密，最后直接将加密好的密文合并（out.write(cache, 0, cache.length);）
二、直接return数据（在另外一端程序里面进行base64）
签名：
public static final String SIGNATURE_ALGORITHM = "MD5withRSA";
/** *//**
* <p>
* 用私钥对信息生成数字签名
* </p>
*
* @param data 已加密数据
* @param privateKey 私钥(BASE64编码)
*
* @return
* @throws Exception
*/
public static String sign(byte[] data, String privateKey) throws Exception {
byte[] keyBytes = Base64.decode(privateKey);
PKCS8EncodedKeySpec pkcs8KeySpec = new PKCS8EncodedKeySpec(keyBytes);
KeyFactory keyFactory = KeyFactory.getInstance(KEY_ALGORITHM);
PrivateKey privateK = keyFactory.generatePrivate(pkcs8KeySpec);
Signature signature = Signature.getInstance(SIGNATURE_ALGORITHM);
signature.initSign(privateK);
signature.update(data);
return Base64.encode(signature.sign());
}
经过这段代码，咱们知道了直接对封装好的密文进行签名，不须要进行分段签名的缘由是加密后的密文长度小于117位。咱们注意到，他的加密方法是：SIGNATURE_ALGORITHM = "MD5withRSA"，因此咱们的python签名也是须要进行MD5的。
那么咱们的python代码：
import base64
from Crypto.Hash import MD5
from Crypto.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5
from Crypto.Signature import PKCS1_v1_5 as Signature_pkcs1_v1_5
from Crypto.PublicKey import RSA
def get_encrypt_data(params):
"""分段加密"""
params = json.dumps(params)
params = params.encode("utf-8")
length = len(params)
default_length = 117
if length < default_length:
return encrypt_data(params)
offset = 0
params_lst = []
while length - offset > 0:
if length - offset > default_length:
params_lst.append(encrypt_data(params[offset:offset+default_length]))
else:
params_lst.append(encrypt_data(params[offset:]))
offset += default_length
res = "".join(params_lst)
return res, base64.b64encode(res)
def encrypt_data(params):
"""使用公钥对数据加密"""
key = public_key
rsakey = RSA.importKey(base64.b64decode(key))
cipher = Cipher_pkcs1_v1_5.new(rsakey)
text = cipher.encrypt(params)
return text
def sign_data(params):
"""对数据签名"""
key = private_key
rsakey = RSA.importKey(base64.b64decode(key))
signer = Signature_pkcs1_v1_5.new(rsakey)
digest = MD5.new(params)
sign = signer.sign(digest)
return base64.b64encode(sign)
对参数进行json化，而后进行utf-8编码，每117位长度遍进行一次加密，最后把加密密文链接起来，进行base64编码。
注意咱们用了digest = MD5.new(params)，代表咱们的签名算法也是MD5。
PBE
PBE算法再Java里面是经过MD5和DES算法构建的，是一种对称加密。也就是说加密解密使用一套密钥来进行的。
咱们来看代码：
Java：
import java.security.spec.AlgorithmParameterSpec;
import java.security.spec.KeySpec;
import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.PBEParameterSpec;
import org.apache.commons.codec.binary.Base64;
public class DesEncrypter {
Cipher ecipher;
Cipher dcipher;
byte[] salt = { (byte) 0xA9, (byte) 0x9B, (byte) 0xC8, (byte) 0x32,
(byte) 0x56, (byte) 0x35, (byte) 0xE3, (byte) 0x03 };
/**
* 构造方法
*
* @param passPhrase
* apikey做为密钥传入
* @throws Exception
*/
public DesEncrypter(String passPhrase) throws Exception {
int iterationCount = 2;
KeySpec keySpec = new PBEKeySpec(passPhrase.toCharArray(), salt,
iterationCount);
SecretKey key = SecretKeyFactory.getInstance("PBEWithMD5AndDES")
.generateSecret(keySpec);
ecipher = Cipher.getInstance(key.getAlgorithm());
dcipher = Cipher.getInstance(key.getAlgorithm());
AlgorithmParameterSpec paramSpec = new PBEParameterSpec(salt,
iterationCount);
ecipher.init(Cipher.ENCRYPT_MODE, key, paramSpec);
dcipher.init(Cipher.DECRYPT_MODE, key, paramSpec);
}
/**
* 加密
*
* @param str
* 要加密的字符串
* @return
* @throws Exception
*/
public String encrypt(String str) throws Exception {
str = new String(str.getBytes(), "UTF-8");
return Base64.encodeBase64String(ecipher.doFinal(str.getBytes()));
}
咱们注意到。有一个盐：对应的python盐为："\xA9\x9B\xC8\x32\x56\x35\xE3\x03"
对应的python2.7代码：
from Crypto.Hash import MD5
from Crypto.Cipher import DES
def get_encrypt_param(params):
"""对参数进行加密封装"""
_salt = "\xA9\x9B\xC8\x32\x56\x35\xE3\x03"
_iterations = 2
data = []
# 依次对字典中的value进行utf-8编码
for i in params:
data.append("{}={}".format(i, params[i].encode("utf-8")))
str_param = "&".join(data)
padding = 8 - len(str_param) % 8
str_param += chr(padding) * padding
hasher = MD5.new()
hasher.update(apikey)
hasher.update(_salt)
result = hasher.digest()
# 进行hash的次数， 由java中的iterationCount决定
for i in range(1, _iterations):
hasher = MD5.new()
hasher.update(result)
result = hasher.digest()
encoder = DES.new(result[:8], DES.MODE_CBC, result[8:16])
encrypted = encoder.encrypt(str_param)
return encrypted.encode("base64")
咱们将传入的参数进行utf-8编码，而后进行hash，最后进行加密。
注意：java代码中的iterationCount是多少，咱们就要进行循环hash多少次。
在python3的代码中，str是不能直接进行hash的，因此要抓换成utf-8进行加密，并且最后的encrypted没有encode方法，只能手动进行Base64编码。
python3 代码以下：
import base64
from Crypto.Hash import MD5
from Crypto.Cipher import DES
def get_encrypt_param(params):
"""对参数进行加密封装"""
# 定义_salt的时候，直接定义成bytes
_salt = b"\xA9\x9B\xC8\x32\x56\x35\xE3\x03"
_iterations = 2
data = []
for i in params:
data.append("{}={}".format(i, params[i]))
str_param = "&".join(data)
padding = 8 - len(str_param) % 8
str_param += chr(padding) * padding
hasher = MD5.new()
# 对apikey进行utf-8编码
hasher.update(apikey.encode())
hasher.update(_salt)
result = hasher.digest()
for i in range(1, _iterations):
hasher = MD5.new()
hasher.update(result)
result = hasher.digest()
encoder = DES.new(result[:8], DES.MODE_CBC, result[8:16])
encrypted = encoder.encrypt(str_param)
# 进行base64编码
return base64.b64encode(encrypted)
可是有一个bug，当参数中有中文的时候，他会 报错：
ValueError: Input strings must be a multiple of 8 in length
通过检查代码发现是没有对参数进行utf-8编码。
可是通过咱们编码以后：
for i in params:
data.append("{}={}".format(i, params[i].encode("utf-8")))
因为python3的机制，编码以后中文便成了bytes，对方解码以后没法识别，因而咱们只有另辟蹊径。
通过一番研究，决定使用另外一个库，pyDes
代码以下：
import pyDes
def get_encrypt_param(params):
"""对参数进行加密封装"""
_salt = b"\xA9\x9B\xC8\x32\x56\x35\xE3\x03"
_iterations = 2
data = []
for i in params:
data.append("{}={}".format(i, params[i]))
str_param = "&".join(data)
hasher = MD5.new()
hasher.update(apikey.encode())
hasher.update(_salt)
result = hasher.digest()
for i in range(1, _iterations):
hasher = MD5.new()
hasher.update(result)
result = hasher.digest()
despy = pyDes.des(result[:8], pyDes.CBC, padmode=pyDes.PAD_PKCS5, IV=result[8:16])
encrypt_data = despy.encrypt(str_param.encode())
return base64.b64encode(encrypt_data）
- 1. MD5加密和RSA加密
- 2. [python] RSA加密
- 3. python RSA 加密
- 4. PBE加密算法
- 5. RSA加密密码错误PBE SecretKeyFactory not available
- 6. java加密之RSA加密
- 7. JAVA RSA加密AES加密
- 8. RSA和MD5加密
- 9. RSA加解密和AES加解密
- 10. RSA 加密解密
- 更多相关文章...
- • Kotlin 数据类与密封类 - Kotlin 教程
- • Eclipse 添加书签 - Eclipse 教程
- • 使用阿里云OSS+CDN部署前端页面与加速静态资源
- • 适用于PHP初学者的学习线路和建议
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. MD5加密和RSA加密
- 2. [python] RSA加密
- 3. python RSA 加密
- 4. PBE加密算法
- 5. RSA加密密码错误PBE SecretKeyFactory not available
- 6. java加密之RSA加密
- 7. JAVA RSA加密AES加密
- 8. RSA和MD5加密
- 9. RSA加解密和AES加解密
- 10. RSA 加密解密