爬虫逆向学习(四)：python与Javascript方式处理常见加解密
常见加解密处理保姆级教程
在线加解密工具
国密SM系列
SM2
JavaScript实现
const sm2 = require('sm-crypto').sm2
const cipherMode = 1
// 获取密钥对
let keypair = sm2.generateKeyPairHex()
let publicKey = keypair.publicKey // 公钥
let privateKey = keypair.privateKey // 私钥
let msgString = "this is the data to be encrypted"
let encryptData = sm2.doEncrypt(msgString, publicKey, cipherMode) // 加密结果
let decryptData = sm2.doDecrypt(encryptData, privateKey, cipherMode) // 解密结果
console.log("encryptData: ", encryptData)
console.log("decryptData: ", decryptData)
python实现
from gmssl import sm2
# 16 进制的公钥和私钥
private_key = '私钥'
public_key = '公钥'
sm2_crypt = sm2.CryptSM2(public_key=public_key, private_key=private_key)
# 待加密数据和加密后数据为 bytes 类型
data = b"this is the data to be encrypted"
enc_data = sm2_crypt.encrypt(data)
dec_data = sm2_crypt.decrypt(enc_data)
print('enc_data: ', enc_data.hex())
print('dec_data: ', dec_data)
SM4
JavaScript实现
var sKey = "JeF38U9wT9wlMfs2";
var sm4 = new JSSM4(sKey);
function SM4_decrypt(text) {
let dedata = sm4.decryptData_ECB(text);
return dedata;
}
function SM4_encrypt(text) {
let endata = sm4.encryptData_ECB(text);
return endata;
}
let str = "我是一段加密文本";
str = SM4_encrypt(str);
console.log("加密结果", str);
str = SM4_decrypt(str);
console.log("解密结果", str);
python实现
import binascii
from gmssl import sm4
class SM4:
"""
国产加密 sm4加解密
"""
def __init__(self):
self.crypt_sm4 = sm4.CryptSM4() # 实例化
def str_to_hexStr(self, hex_str):
"""
字符串转hex
:param hex_str: 字符串
:return: hex
"""
hex_data = hex_str.encode('utf-8')
str_bin = binascii.unhexlify(hex_data)
return str_bin.decode('utf-8')
def encryptSM4(self, encrypt_key, value):
"""
国密sm4加密
:param encrypt_key: sm4加密key
:param value: 待加密的字符串
:return: sm4加密后的十六进制值
"""
crypt_sm4 = self.crypt_sm4
crypt_sm4.set_key(encrypt_key.encode(), sm4.SM4_ENCRYPT) # 设置密钥
date_str = str(value)
encrypt_value = crypt_sm4.crypt_ecb(date_str.encode()) # 开始加密。bytes类型
return encrypt_value.hex() # 返回十六进制值
def decryptSM4(self, decrypt_key, encrypt_value):
"""
国密sm4解密
:param decrypt_key:sm4加密key
:param encrypt_value: 待解密的十六进制值
:return: 原字符串
"""
crypt_sm4 = self.crypt_sm4
crypt_sm4.set_key(decrypt_key.encode(), sm4.SM4_DECRYPT) # 设置密钥
decrypt_value = crypt_sm4.crypt_ecb(bytes.fromhex(encrypt_value)) # 开始解密。十六进制类型
return decrypt_value.decode()
if __name__ == '__main__':
key = "f38fc9b32af486e65d6f93dbc41b9123"
strData = "90897h8789thvht"
SM4 = SM4()
print("原字符：", strData)
encData = SM4.encryptSM4(key, strData) # 加密后的数据，返回bytes类型
print("sm4加密结果：", encData)
decData = SM4.decryptSM4(key, encData)
print("sm4解密结果：", decData) # 解密后的数据
MD5
JavaScript实现
var CryptoJS = require('crypto-js')
function MD5Test() {
var text = "I love python!"
return CryptoJS.MD5(text).toString()
}
console.log(MD5Test())
python实现
import hashlib
def md5_test2():
md5 = hashlib.md5()
md5.update('python'.encode('utf-8'))
print(md5.hexdigest())
if __name__ == '__main__':
md5_test2()
SHA
JavaScript实现
// 引用 crypto-js 加密模块
var CryptoJS = require('crypto-js')
function SHA1Encrypt() {
var text = "I love python!"
return CryptoJS.SHA1(text).toString();
}
console.log(SHA1Encrypt())
python实现
import hashlib
def sha1_test2():
sha1 = hashlib.sha1()
sha1.update('I love python!'.encode('utf-8'))
print(sha1.hexdigest())
if __name__ == '__main__':
sha1_test2()
HMAC
JavaScript实现
var CryptoJS = require('crypto-js')
function HMACEncrypt() {
var text = "I love python!"
var key = "secret" // 密钥文件
return CryptoJS.HmacMD5(text, key).toString();
// return CryptoJS.HmacSHA1(text, key).toString();
// return CryptoJS.HmacSHA256(text, key).toString();
}
console.log(HMACEncrypt())
python实现
import hmac
def hmac_test1():
message = b'I love python!'
key = b'secret'
md5 = hmac.new(key, message, digestmod='MD5')
print(md5.hexdigest())
def hmac_test2():
key = 'secret'.encode('utf8')
sha1 = hmac.new(key, digestmod='sha1')
sha1.update('I love '.encode('utf8'))
sha1.update('Python!'.encode('utf8'))
print(sha1.hexdigest())
if __name__ == '__main__':
hmac_test1() # 9c503a1f852edcc3526ea56976c38edf
hmac_test2() # 2d8449a4292d4bbeed99ce9ea570880d6e19b61a
DES
JavaScript实现
var CryptoJS = require('crypto-js')
function desEncrypt() {
var key = CryptoJS.enc.Utf8.parse(desKey),
iv = CryptoJS.enc.Utf8.parse(desIv),
srcs = CryptoJS.enc.Utf8.parse(text),
// CBC 加密模式，Pkcs7 填充方式
encrypted = CryptoJS.DES.encrypt(srcs, key, {
iv: iv,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.Pkcs7
});
return encrypted.toString();
}
function desDecrypt() {
var key = CryptoJS.enc.Utf8.parse(desKey),
iv = CryptoJS.enc.Utf8.parse(desIv),
srcs = encryptedData,
// CBC 加密模式，Pkcs7 填充方式
decrypted = CryptoJS.DES.decrypt(srcs, key, {
iv: iv,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.Pkcs7
});
return decrypted.toString(CryptoJS.enc.Utf8);
}
var text = "I love Python!" // 待加密对象
var desKey = "6f726c64f2c2057" // 密钥
var desIv = "0123456789ABCDEF" // 初始向量
var encryptedData = desEncrypt()
var decryptedData = desDecrypt()
console.log("加密字符串: ", encryptedData)
console.log("解密字符串: ", decryptedData)
python实现
import binascii
from pyDes import des, CBC, PAD_PKCS5
def des_encrypt(key, text, iv):
k = des(key, CBC, iv, pad=None, padmode=PAD_PKCS5)
en = k.encrypt(text, padmode=PAD_PKCS5)
return binascii.b2a_hex(en)
def des_decrypt(key, text, iv):
k = des(key, CBC, iv, pad=None, padmode=PAD_PKCS5)
de = k.decrypt(binascii.a2b_hex(text), padmode=PAD_PKCS5)
return de
if __name__ == '__main__':
secret_key = '12345678' # 密钥
text = 'hello world' # 加密对象
iv = secret_key # 偏移量
secret_str = des_encrypt(secret_key, text, iv)
print('加密字符串：', secret_str)
clear_str = des_decrypt(secret_key, secret_str, iv)
print('解密字符串：', clear_str)
AES
JavaScript实现
var CryptoJS = require('crypto-js')
function tripleAesEncrypt() {
var key = CryptoJS.enc.Utf8.parse(aesKey),
iv = CryptoJS.enc.Utf8.parse(aesIv),
srcs = CryptoJS.enc.Utf8.parse(text),
// CBC 加密方式，Pkcs7 填充方式
encrypted = CryptoJS.AES.encrypt(srcs, key, {
iv: iv,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.Pkcs7
});
return encrypted.toString();
}
function tripleAesDecrypt() {
var key = CryptoJS.enc.Utf8.parse(aesKey),
iv = CryptoJS.enc.Utf8.parse(aesIv),
srcs = encryptedData,
// CBC 加密方式，Pkcs7 填充方式
decrypted = CryptoJS.AES.decrypt(srcs, key, {
iv: iv,
mode: CryptoJS.mode.CBC,
padding: CryptoJS.pad.Pkcs7
});
return decrypted.toString(CryptoJS.enc.Utf8);
}
var text = "I love Python!" // 待加密对象
var aesKey = "6f726c64f2c2057c" // 密钥，16 倍数
var aesIv = "0123456789ABCDEF" // 偏移量，16 倍数
var encryptedData = tripleAesEncrypt()
var decryptedData = tripleAesDecrypt()
console.log("加密字符串: ", encryptedData)
console.log("解密字符串: ", decryptedData)
python实现
import base64
import hashlib
from Crypto.Cipher import AES
from Crypto.Util.Padding import pad, unpad
class AESCipher(object):
""" 进行 aes 加密 解密 """
def __init__(self, key, model='ECB', iv=''):
self.mode = model
self.key = key.encode('utf-8')
self.iv = iv.encode()
if model == 'ECB':
self.aes = AES.new(self.key, AES.MODE_ECB) # 创建一个aes对象
elif model == 'CBC':
self.aes = AES.new(self.key, AES.MODE_CBC, self.iv)
def add_16(self, par):
# python3字符串是unicode编码，需要 encode才可以转换成字节型数据
par = par.encode('utf-8')
while len(par) % 16 != 0:
par += b'\x00'
return par
def encrypt(self, data):
# pad_pkcs7 = pad(data.encode('utf-8'), AES.block_size, style='pkcs7')
pad_pkcs7 = pad(data.encode('utf-8'), AES.block_size, style='pkcs7')
result = base64.encodebytes(self.aes.encrypt(pad_pkcs7))
encrypted_text = str(result, encoding='utf-8').replace('\n', '')
return encrypted_text
def decrypt(self, data):
base64_decrypted = base64.decodebytes(data.encode('utf-8'))
una_pkcs7 = unpad(self.aes.decrypt(base64_decrypted), AES.block_size, style='pkcs7')
decrypted_text = str(una_pkcs7, encoding='utf-8')
return decrypted_text
RSA
JavaScript实现
var NodeRSA = require('node-rsa');
function rsaEncrypt() {
pubKey = new NodeRSA(publicKey,'pkcs8-public');
var encryptedData = pubKey.encrypt(text, 'base64');
return encryptedData
}
function rsaDecrypt() {
priKey = new NodeRSA(privatekey,'pkcs8-private');
var decryptedData = priKey.decrypt(encryptedData, 'utf8');
return decryptedData
}
var key = new NodeRSA({b: 512}); //生成512位秘钥
var publicKey = key.exportKey('pkcs8-public'); //导出公钥
var privatekey = key.exportKey('pkcs8-private'); //导出私钥
var text = "I love Python!"
var encryptedData = rsaEncrypt()
var decryptedData = rsaDecrypt()
console.log("公钥:\n", publicKey)
console.log("私钥:\n", privatekey)
console.log("加密字符串: ", encryptedData)
console.log("解密字符串: ", decryptedData)
python实现
import rsa
import base64
def rsa_encrypt(pu_key, t):
# 公钥加密
rsas = rsa.encrypt(t.encode("utf-8"), pu_key)
return base64.b64encode(rsas)
def rsa_decrypt(pr_key, t):
# 私钥解密
rsas = rsa.decrypt(base64.b64decode(t), pr_key).decode("utf-8")
return rsas
if __name__ == "__main__":
public_key, private_key = rsa.newkeys(512) # 生成公钥、私钥
print('公钥：', public_key)
print('私钥：', private_key)
text = 'I love Python!' # 加密对象
encrypted_str = rsa_encrypt(public_key, text)
print('加密字符串：', encrypted_str)
decrypted_str = rsa_decrypt(private_key, encrypted_str)
print('解密字符串：', decrypted_str)
通过已有公钥对文本进行加密
def rsa_encrypt(self, public_key, encrypt_text):
# 将Base64编码的公钥解码为RSA公钥
key_data = base64.b64decode(public_key)
key = RSA.importKey(key_data)
# 使用RSA公钥加密明文密码
encryptor = PKCS1_OAEP.new(key)
encryptPassword = encryptor.encrypt(encrypt_text.encode())
# 打印加密后的密文密码
return base64.b64encode(encryptPassword).decode()
本文来自博客园，作者：七夜魔手，转载请注明原文链接：https://www.cnblogs.com/ranbox/p/18461065
