AED/DES加密算法

最新推荐文章于 2024-10-18 11:12:30 发布

acmakb

最新推荐文章于 2024-10-18 11:12:30 发布

阅读量668

点赞数 5

分类专栏： # 网络爬虫文章标签： javascript python 爬虫哈希算法

本文链接：https://blog.csdn.net/ak_bingbing/article/details/134276644

版权

网络爬虫专栏收录该内容

20 篇文章 1 订阅

订阅专栏

AED/DES加密算法：

背景描述：

在js逆向的过程中，往往最多的就是浏览器显示的是明文数据而我们通过模拟得到的数据是密文数据，因为我们只模拟的得到相应数据的过程，但是没有模拟对数据解密的过程。

一般来说，相应数据的加密一般有两种算法，对称加密和非对称加密，对称加密就是加密和解密是同一把钥匙，即相同的密钥，而非对称加密只得说加密和解密不是同一把钥匙，即加密使用公钥，解密使用私钥。

对称加密算法：

非对称加密:

但是目前DES已经很少用了，大部分的网站都是使用AES加密方式，AES算法加密强度高。我觉得给大家展示一些AES算法的原理可能比较难懂而且其实意义不是特别大，我们需要的是懂得如何进行逆向，如何模拟拿到数据。

DES：56位密钥，由于密钥太短，被逐渐被弃用。
AES：有128位、192位、256位密钥，现在比较流行。密钥长、可以增加破解的难度和成本。

加密算法必懂的内容：

工作模式：

ECB模式，译为电子密码本模式，每个数据块独立进行加/解密
CBC模式，译为密文分组链接模式先将明文切分成若干小块，然后每个小块与初始块或者上一段的密文段进行逻辑异或运算后，再用密钥进行加密。
CFB模式，译为密文反馈模式
OFB模式，译为输出反馈模式。
CTR模式，译为计数器模式。

其实用的最多的是ECB和CBC模式，其他的用的真心不多。

iv向量：

我的理解就是偏移量，应该是防止重复吧

填充模式：

padding为填充模式，如果加密后密文长度如果达不到指定整数倍（8个字节、16个字节），填充对应字符
- padding的赋值固定为CryptoJS.pad.Pkcs7即可

大家知道这几个就足够了，现在我为大家讲解这两个算法。

DES:

html实现：

<html>
	<script src="https://cdn.bootcss.com/crypto-js/3.1.9-1/crypto-js.js"></script>
    <script type="text/javascript">
		  var aseKey = "12345678"     //定制秘钥，长度必须为：8/16/32...位  自己定制
		  var message = "i am bobo,who are you ?";
		  //加密 DES/AES切换只需要修改 CryptoJS.AES <=> CryptoJS.DES
		  var encrypt = CryptoJS.DES.encrypt(message, CryptoJS.enc.Utf8.parse(aseKey), {
			mode: CryptoJS.mode.ECB,
			padding: CryptoJS.pad.Pkcs7
		  }).toString();

		  alert(encrypt); // 0Gh9NGnwOpgmB525QS0JhVJlsn5Ev9cHbABgypzhGnM
		  //解密
		  var decrypt = CryptoJS.DES.decrypt(encrypt, CryptoJS.enc.Utf8.parse(aseKey), {
			mode: CryptoJS.mode.ECB,
			padding: CryptoJS.pad.Pkcs7
		  }).toString(CryptoJS.enc.Utf8);

		  alert(decrypt); // 我是一个密码
	</script>

</html>

js实现：

// 引用 crypto-js 加密模块
var CryptoJS = require('crypto-js')

function desEncrypt(desKey, Iv, text) {
    var key = CryptoJS.enc.Utf8.parse(desKey),
        iv = CryptoJS.enc.Utf8.parse(Iv),
        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(Key, Iv, text) {
    var key = CryptoJS.enc.Utf8.parse(Key),
        iv = CryptoJS.enc.Utf8.parse(Iv),
        srcs = text,
        // 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 you!"       // 待加密对象
var desKey = "6f726c64f2c2057"    // 密钥
var Iv = "0123456789abcdef"    // iv

var enData = desEncrypt(desKey, Iv, text)
var deData = desDecrypt(desKey, Iv,enData)

console.log("加密: ", enData)
console.log("解密: ", deData)

python：

import binascii
# 加密模式 CBC，填充方式 PAD_PKCS5
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 666'   # 加密对象
    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：

html实现

<html>
	<script src="https://cdn.bootcss.com/crypto-js/3.1.9-1/crypto-js.js"></script>
    <script type="text/javascript">
		  var aseKey = "12345678"     //定制秘钥，长度必须为：8/16/32...位  自己定制
		  var message = "i am bobo,who are you ?";
		  var encrypt = CryptoJS.AES.encrypt(message, CryptoJS.enc.Utf8.parse(aseKey), {
			mode: CryptoJS.mode.ECB,
			padding: CryptoJS.pad.Pkcs7
		  }).toString();
		  alert(encrypt);
		  //解密
		  var decrypt = CryptoJS.AES.decrypt(encrypt, CryptoJS.enc.Utf8.parse(aseKey), {
			mode: CryptoJS.mode.ECB,
			padding: CryptoJS.pad.Pkcs7
		  }).toString(CryptoJS.enc.Utf8);
		  alert(decrypt); // 我是一个密码
	</script>

</html>

js实现：

// 引入CryptoJS库
const CryptoJS = require("crypto-js");

// 定义密钥和待加密的字符串
let key = CryptoJS.enc.Utf8.parse("1234567890abcdef"); // 密钥需要进行字节数转换
//let key = "1234567890abcdef";
let plaintext = "123456";

//工作模式
//CBC ECB
cfg= {
  mode: CryptoJS.mode.ECB, 
  padding: CryptoJS.pad.Pkcs7, // 使用Pkcs7填充
}
// 使用aaaaes算法进行加密
let  encrypted = CryptoJS.AES.encrypt(plaintext, key,cfg).toString();
console.log("加密后的密文：", encrypted);
// 解密密文
const decrypted = CryptoJS.AES.decrypt(encrypted, key, cfg).toString(CryptoJS.enc.Utf8);
console.log("解密后的明文：", decrypted);

// 引用 crypto-js 加密模块
var CryptoJS = require('crypto-js')

function AesEncrypt(Key,Iv,text) {
    var key = CryptoJS.enc.Utf8.parse(Key),
        iv = CryptoJS.enc.Utf8.parse(Iv),
        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 AesDecrypt(Key,Iv,text) {
    var key = CryptoJS.enc.Utf8.parse(Key),
        iv = CryptoJS.enc.Utf8.parse(Iv),
        srcs = text,
        // 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 you"       // 待加密对象
var aesKey = "6f726c64f2c2057c"   // 密钥，16 倍数
var aesIv = "0123456789ABCDEF"    // 偏移量，16 倍数

var encryptedData = AesEncrypt(aesKey,aesIv,text)
var decryptedData = AesDecrypt(aesKey,aesIv,encryptedData)

console.log("加密", encryptedData)
console.log("解密", decryptedData)

python实现:

import base64
from Crypto.Cipher import AES

'''
AES对称加密算法
'''
# 需要补位，str不是16的倍数那就补足为16的倍数
def add_to_16(value):
    while len(value) % 16 != 0:
        value += '\0'
    return str.encode(value)  # 返回bytes


# 加密方法
def encrypt(key, text):
    aes = AES.new(add_to_16(key), AES.MODE_ECB)  # 初始化加密器
    encrypt_aes = aes.encrypt(add_to_16(text))  # 先进行aes加密
    encrypted_text = str(base64.encodebytes(encrypt_aes), encoding='utf-8')  # 执行加密并转码返回bytes
    return encrypted_text


# 解密方法
def decrypt(key, text):
    aes = AES.new(add_to_16(key), AES.MODE_ECB)  # 初始化加密器
    base64_decrypted = base64.decodebytes(text.encode(encoding='utf-8'))  # 优先逆向解密base64成bytes
    decrypted_text = str(aes.decrypt(base64_decrypted), encoding='utf-8').replace('\0', '')  # 执行解密密并转码返回str
    return decrypted_text