cryptography是python语言中非常著名的加解密库，在算法层面提供了高层次的抽象，使用起来非常简单、直观，pythonic，同时还保留了各种不同算法的低级别接口，保留灵活性。
我们知道加密一般分为对称加密(Symmetric Key Encryption)和非对称加密(Asymmetric Key Encryption)。，各自对应多种不同的算法，每种算法又有不同的密钥位长要求，另外还涉及到不同的分组加密模式，以及末尾补齐方式。因此需要高层次的抽象，把这些参数封装起来，让我们使用时，不用关心这么多参数，只要知道这么用足够安全就够了。
对称加密又分为分组加密和序列加密，本文只讨论对称分组加密。
主流对称分组加密算法：DES、3DES、AES
主流对称分组加密模式：ECB、CBC、CFB、OFB
主流填充标准：PKCS7、ISO 10126、ANSI X.923、Zero padding
在cryptography库中，对称加密算法的抽象是fernet模块，包括了对数据的加解密以及签名验证功能，以及密钥过期机制。
该模块采用如下定义：
加解密算法为AES，密钥位长128，CBC模式，填充标准PKCS7
签名算法为SHA256的HMAC，密钥位长128位
密钥可以设置过期时间
通过分析JS同等加密，JS如下：
密钥：
var generateKey = function(){
var date = new Date();
var components = [
date.getYear(),
date.getMonth(),
date.getDate(),
date.getHours(),
date.getMinutes(),
date.getSeconds(),
date.getMilliseconds()
];
return((components.join("") + Math.random()).replace(".",""));
}
var ENCRYPTION_KEY = generateKey();
function setHeader(xhr){
xhr.setRequestHeader('adsHeader', ENCRYPTION_KEY);
xhr.setRequestHeader('googleCookie', 'airtel.com');
xhr.setRequestHeader('Content-Type', 'application/json');
}
function doAjaxRequestPostNew(url,callback,params)
{
//console.log(url+" params:"+params);
//params = "channelType=Web&rtn=9958777600&channelName=DevicePortal";
params = queryStringToJSON(params);
//console.log(url+" params:"+params);
//Encryption :
ENCRYPTION_KEY = generateKey();
var ENCRYPTED_REQUEST = CryptoJS.DES.encrypt(params,
CryptoJS.enc.Utf8.parse(ENCRYPTION_KEY),{
mode: CryptoJS.mode.ECB,
padding: CryptoJS.pad.Pkcs7
}).toString();
//console.log(url+" params:"+ENCRYPTED_REQUEST);
url = url.replace("/account/AuthApp/", "/as/app/wl-service/airtel-digital-profile/rest/customer/authapp/v1/").toLowerCase();
$.ajax({
url: url,
type: 'POST',
async: true,
dataType: 'text',
data: ENCRYPTED_REQUEST,
success: function(response, status, xhr) { //function(response) { //
//console.log('response: '+response);
response = (response.split("<SCRIPT"))[0];
//console.log('response: '+response);
//console.log('status: '+status);
//Decryption :
var DEC_KEY = xhr.getResponseHeader('googlecookie');
//console.log('DEC_KEY: '+DEC_KEY);
var DECRYPTED_RESPONSE = JSON.parse(
CryptoJS.DES.decrypt(response.replace('"',''),
CryptoJS.enc.Utf8.parse(DEC_KEY),
{
mode: CryptoJS.mode.ECB,
padding: CryptoJS.pad.Pkcs7
}).toString(CryptoJS.enc.Utf8));
console.log('DECRYPTED_RESPONSE: '+JSON.stringify(DECRYPTED_RESPONSE));
if (typeof(DECRYPTED_RESPONSE.requestkey) != 'undefined'){
requestKey = DECRYPTED_RESPONSE.requestkey;
}
getCallbackFunctionNew(DECRYPTED_RESPONSE.result, callback).call();
},error: function(xhr, status, error){
console.log('Error: '+xhr.responseText);
var objJSON = JSON.parse(xhr.responseText)
getCallbackFunctionNew(objJSON.code, callback).call();
},beforeSend:setHeader
});
}
解析后同等加密：
import base64
import time
import hashlib
import random
from cryptography.hazmat.primitives.ciphers import algorithms
from cryptography.hazmat.primitives.ciphers import Cipher
from cryptography.hazmat.primitives.ciphers import modes
from cryptography.hazmat.backends import default_backend
import requests
from http.cookiejar import MozillaCookieJar
from fake_useragent import UserAgent
主要的加密函数代码：
#解密函数
def des_decrypt(key, content, pad):
ciphertext = base64.b64decode(content)
algorithm = algorithms.TripleDES(key[:8].encode())
cipher = Cipher(algorithm, modes.ECB(), backend=default_backend())
decryptor = cipher.decryptor()
data = decryptor.update(ciphertext)
print(data)
return data.rstrip(pad).decode()
#加密函数一
def sha1_encrypt(content):
return hashlib.sha1(content.encode()).hexdigest()
#加密函数二
def des_encrypt(key, content, pad):
if not isinstance(content, bytes):
content = content.encode()
content += pad * (8 - len(content) % 8)
algorithm = algorithms.TripleDES(key[:8].encode())
cipher = Cipher(algorithm, modes.ECB(), backend=default_backend())
encryptor = cipher.encryptor()
data = encryptor.update(content)
_data = base64.b64encode(data).decode()
return _data
#获取加密的key
def get_adsheader():
localtime = time.localtime(time.time())
t = str(localtime.tm_year - 1900) + str(localtime.tm_mon - 1) + str(localtime.tm_mday) + \
str(localtime.tm_hour) + str(localtime.tm_min) + str(localtime.tm_sec) + str(random.randint(0, 1000))
return (t + str(random.random())).replace('.', '')
其它的加密例子：
使用fernet加解密的例子如下：
>>> import os
>>> from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
>>> from cryptography.hazmat.backends import default_backend
>>> backend = default_backend()
>>> key = os.urandom(32)
>>> iv = os.urandom(16)
>>> cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=backend)
>>> encryptor = cipher.encryptor()
>>> ct = encryptor.update(b"a secret message") + encryptor.finalize()
>>> decryptor = cipher.decryptor()
>>> decryptor.update(ct) + decryptor.finalize()
'a secret message'
可见加密时除了指定算法和模式，以及生成随机的key之外，CBC模式还需要生成一个随机的初始向量iv；解密时也要提供iv。
cryptography库的fernet模块封装了对称加密的操作，提供了三个基本操作：
产生对称密钥： generate_key
用对称密钥加密：encrypt
用对称密钥解密：decrypt
generate_key：可见只是产生了一个32位随机数，并用base64编码
@classmethod
def generate_key(cls):
return base64.urlsafe_b64encode(os.urandom(32))
生成32位密钥后，前16位用来计算hmac，后16位用来加解密
self._signing_key = key[:16]
self._encryption_key = key[16:]
self._backend = backend
encrypt：
- 获取current_time，并随机生成16位的CBC初始向量iv
- 指定padding方式为PKCS7
- 把要加密的原始data用padding方式补齐
- 指定用AES算法CBC模式加密
- 加密得到ciphertext
- 把current_time、iv、ciphertext三者合并得到一个basic_parts
basic_parts = (
b"\x80" + struct.pack(">Q", current_time) + iv + ciphertext
)
- 计算basic_parts的hmac值
- 把basic_parts + hmac 做base64计算后返回，这就是我们最终得到的加密数据，里面包含了时间戳、iv、密文、hmac
def encrypt(self, data):
current_time = int(time.time())
iv = os.urandom(16)
return self._encrypt_from_parts(data, current_time, iv)
def _encrypt_from_parts(self, data, current_time, iv):
if not isinstance(data, bytes):
raise TypeError("data must be bytes.")
padder = padding.PKCS7(algorithms.AES.block_size).padder()
padded_data = padder.update(data) + padder.finalize()
encryptor = Cipher(
algorithms.AES(self._encryption_key), modes.CBC(iv), self._backend
).encryptor()
ciphertext = encryptor.update(padded_data) + encryptor.finalize()
basic_parts = (
b"\x80" + struct.pack(">Q", current_time) + iv + ciphertext
)
h = HMAC(self._signing_key, hashes.SHA256(), backend=self._backend)
h.update(basic_parts)
hmac = h.finalize()
return base64.urlsafe_b64encode(basic_parts + hmac)
decrypt：
完全于encrypt相反的操作
- 得到current_time
- base64解码token，得到包含时间戳、iv、密文、hmac的data
- 根据时间戳和ttl，判断密钥是否已经失效
- 计算hmac，并于之前的hmac进行验证，判断密钥有效性
- 获取iv，和密文，并通过密钥解密，得到经过pad的明文
- 通过PKCS7进行unpaid操作，得到去掉补齐的明文
- 返回最终结果
def decrypt(self, token, ttl=None):
if not isinstance(token, bytes):
raise TypeError("token must be bytes.")
current_time = int(time.time())
try:
data = base64.urlsafe_b64decode(token)
except (TypeError, binascii.Error):
raise InvalidToken
if not data or six.indexbytes(data, 0) != 0x80:
raise InvalidToken
try:
timestamp, = struct.unpack(">Q", data[1:9])
except struct.error:
raise InvalidToken
if ttl is not None:
if timestamp + ttl < current_time:
raise InvalidToken
if current_time + _MAX_CLOCK_SKEW < timestamp:
raise InvalidToken
h = HMAC(self._signing_key, hashes.SHA256(), backend=self._backend)
h.update(data[:-32])
try:
h.verify(data[-32:])
except InvalidSignature:
raise InvalidToken
iv = data[9:25]
ciphertext = data[25:-32]
decryptor = Cipher(
algorithms.AES(self._encryption_key), modes.CBC(iv), self._backend
).decryptor()
plaintext_padded = decryptor.update(ciphertext)
try:
plaintext_padded += decryptor.finalize()
except ValueError:
raise InvalidToken
unpadder = padding.PKCS7(algorithms.AES.block_size).unpadder()
unpadded = unpadder.update(plaintext_padded)
try:
unpadded += unpadder.finalize()
except ValueError:
raise InvalidToken
return unpadded