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 加密解密