登录/ 注册
 找回密码
 立即注册
关闭

CSDN热搜

程序园 精品问答 技术交流 资源下载
返回列表 发新帖
首页 › 业界区 › 安全 ›指纹识别+精准化POC攻击

指纹识别+精准化POC攻击

缑莺韵 4 天前
开发目的

解决漏洞扫描器的痛点
第一就是扫描量太大，对一个站点扫描了大量的无用 POC，浪费时间
指纹识别后还需要根据对应的指纹去进行 payload 扫描，非常的麻烦
开发思路

我们的思路大体分为指纹+POC+扫描
所以思路大概从这几个方面入手
首先就是 POC，我们得寻找一直在更新的 POC，而且是实时更新的，因为自己写的话有点太费时间了
但是这 POC 的决定是根据我们扫描器来的，因为世面上已经有许多不错的扫描器了，目前打算使用的是 nuclei 扫描器
https://github.com/projectdiscovery/nuclei
Nuclei 是一种现代、高性能的漏洞扫描程序，它利用基于 YAML 的简单模板。它使您能够设计自定义漏洞检测场景，以模拟真实世界的条件，从而实现零误报。
目前也在不断维护更新，当然还有 Xray，Goby 等工具也是不错的选择
然后回到指纹识别技术，这个需要大量的指纹样本，但是世面上的各种工具已经可以做得很好了
指纹识别

这里就的学习一下指纹识别的技术
首先我们需要知道收集指纹目前大概有哪些方法
指纹识别方式

特定文件

比如举一个例子，我们通常是如何判断一个框架是 thinkphp 呢？
我们随便找几个 thinkphp 的网站
特征就是它的图标是非常明显的
[img=720,684.6428571428571]https://www.yijinglab.com/guide-img/d9634e2f-3b66-42e7-8279-c0877cdd70e5/7b330944-48ff-46d1-87af-d1dae33ee96f.png[/img]

可以看到图标都是一样的，目前 fofa 和 hunter 已经有这种查找的方法了，一般都是把我们的图标换算为我们的 hash 值
这个就是我们的 favicon.ico 图标
一般网站是通过在路径后加入 favicon.ico 比如http://xxxxxx/favicon.ico
[img=720,904.6706586826348]https://www.yijinglab.com/guide-img/d9634e2f-3b66-42e7-8279-c0877cdd70e5/efd0ad4b-d4b2-4e15-9917-536c82b42ec9.png[/img]

然后就能获取这个图标了，而在 fofa 中可以直接拖动查询了，可以直接算出 hash 值
[img=720,381.2142857142857]https://www.yijinglab.com/guide-img/d9634e2f-3b66-42e7-8279-c0877cdd70e5/a407609b-8850-4430-8ce0-8217c1901eda.png[/img]

比如 thinkphp 的
[img=720,585.6428571428571]https://www.yijinglab.com/guide-img/d9634e2f-3b66-42e7-8279-c0877cdd70e5/d2d6e9a9-bd25-4af3-b404-bfe5cc83c978.png[/img]

然后再次查询
[img=720,446.7857142857143]https://www.yijinglab.com/guide-img/d9634e2f-3b66-42e7-8279-c0877cdd70e5/44b217e8-487a-4273-95ab-ece81ee3e74a.png[/img]

全是 tp 的网站参考https://github.com/TideSec/TideFinger/blob/master/Web%E6%8C%87%E7%BA%B9%E8%AF%86%E5%88%AB%E6%8A%80%E6%9C%AF%E7%A0%94%E7%A9%B6%E4%B8%8E%E4%BC%98%E5%8C%96%E5%AE%9E%E7%8E%B0.md
当然除了我们的 ico 文件，还有其他很多的文件
【----帮助网安学习，以下所有学习资料免费领！加vx：YJ-2021-1，备注 “博客园” 获取！】
　① 网安学习成长路径思维导图
　② 60+网安经典常用工具包
　③ 100+SRC漏洞分析报告
　④ 150+网安攻防实战技术电子书
　⑤ 最权威CISSP 认证考试指南+题库
　⑥ 超1800页CTF实战技巧手册
　⑦ 最新网安大厂面试题合集（含答案）
　⑧ APP客户端安全检测指南（安卓+IOS）
一些网站的特定图片文件、js 文件、CSS 等静态文件，如 favicon.ico、css、logo.ico、js 等文件一般不会修改，通过爬虫对这些文件进行抓取并比对 md5 值，如果和规则库中的 Md5 一致则说明是同一 CMS。这种方式速度比较快，误报率相对低一些，但也不排除有些二次开发的 CMS 会修改这些文件。
[img=720,329.14285714285717]https://www.yijinglab.com/guide-img/d9634e2f-3b66-42e7-8279-c0877cdd70e5/bd38f567-12f6-4471-9ce4-0d7e13a26e93.png[/img]

页面关键字

比如 tp 的错误页面大多数都是
[img=720,496.275]https://www.yijinglab.com/guide-img/d9634e2f-3b66-42e7-8279-c0877cdd70e5/9dc612ef-e2cf-44ff-8fa6-6b9519834f4d.png[/img]

我们 body 就可以包含这个关键字了
或者可以构造错误页面，根据报错信息来判断使用的 CMS 或者中间件信息，比较常见的如 tomcat 和 spring 的报错页面。根据 response header 一般有以下几种识别方式：
请求头关键字

根据网站 response 返回头信息进行关键字匹配，这个一般是 ningx 这种
[img=720,631.925]https://www.yijinglab.com/guide-img/d9634e2f-3b66-42e7-8279-c0877cdd70e5/466830db-0c49-4e80-8561-c9701dcbf45a.png[/img]

能够识别我们的服务器
URL 路径

根据总结wordpress 默认存在 wp-includes 和 wp-admin 目录，织梦默认管理后台为 dede 目录，solr 平台可能使用/solr 目录，weblogic 可能使用 wls-wsat 目录等。
大部分还是根据我们的 body
[img=720,883.8910505836576]https://www.yijinglab.com/guide-img/d9634e2f-3b66-42e7-8279-c0877cdd70e5/51ac6bd7-1985-4d53-ba2f-7d328366f3eb.png[/img]

然后点一个进去
[img=720,803.7673130193906]https://www.yijinglab.com/guide-img/d9634e2f-3b66-42e7-8279-c0877cdd70e5/8508b08c-d36e-4963-b1fc-1352fd7a95bf.png[/img]

可以看到都是我们的 wordPress 的站点
指纹识别方法

有了我们上面的识别技术，那么我们大概是如何来识别一个指纹的呢
首先使用 python 简单举一个实现
首先就是需要一个配置文件，这个配置文件就需要包含我们的大体指纹和验证方法
  1. - name: ThinkPHP
  2. matchers:
  3.  - type: header
  4.    rule: X-Powered-By
  5.    keyword: ThinkPHP
  6. ​
  7.  - type: body
  8.    keyword: "http://www.thinkphp.cn"
  9. ​
  10.  - type: banner
  11.    keyword: thinkphp
  12. ​
  13.  - type: path
  14.    path: /thinkphp/library/think/
  15.    keyword: class
  16. ​
  17.  - type: favicon_hash
  18.    hash: 1165838194
  19. ​
复制代码
然后就是我们的后端处理逻辑了
  1. import yaml
  2. import requests
  3. import socket
  4. import base64
  5. import mmh3
  6. ​
  7. def get_http_response(url, path=""):
  8.    try:
  9.        full_url = url.rstrip("/") + path
  10.        return requests.get(full_url, timeout=5)
  11.    except:
  12.        return None
  13. ​
  14. def get_tcp_banner(ip, port=80):
  15.    try:
  16.        with socket.create_connection((ip, port), timeout=5) as s:
  17.            banner = s.recv(1024).decode(errors="ignore")
  18.            return banner
  19.    except:
  20.        return ""
  21. ​
  22. def get_favicon_hash(url):
  23.    try:
  24.        res = requests.get(url.rstrip("/") + "/favicon.ico", timeout=5)
  25.        favicon = base64.encodebytes(res.content)
  26.        return mmh3.hash(favicon.decode('utf-8'))
  27.    except:
  28.        return None
  29. ​
  30. def load_fingerprints(path="fingerprints.yaml"):
  31.    with open(path, "r", encoding="utf-8") as f:
  32.        return yaml.safe_load(f)
  33. ​
  34. def match_fingerprint(url, ip=None):
  35.    fingerprints = load_fingerprints()
  36.    results = []
  37. ​
  38.    res = get_http_response(url)
  39.    banner = get_tcp_banner(ip or url.replace("http://", "").replace("https://", ""), 80)
  40.    favicon_hash = get_favicon_hash(url)
  41. ​
  42.    for fp in fingerprints:
  43.        matched = False
  44.        for matcher in fp["matchers"]:
  45.            if matcher["type"] == "header" and res:
  46.                if matcher["rule"] in res.headers and matcher["keyword"].lower() in res.headers[matcher["rule"]].lower():
  47.                    matched = True
  48.            elif matcher["type"] == "body" and res:
  49.                if matcher["keyword"].lower() in res.text.lower():
  50.                    matched = True
  51.            elif matcher["type"] == "banner":
  52.                if matcher["keyword"].lower() in banner.lower():
  53.                    matched = True
  54.            elif matcher["type"] == "path":
  55.                res2 = get_http_response(url, matcher["path"])
  56.                if res2 and matcher["keyword"].lower() in res2.text.lower():
  57.                    matched = True
  58.            elif matcher["type"] == "favicon_hash":
  59.                if favicon_hash == matcher["hash"]:
  60.                    matched = True
  61.        if matched:
  62.            results.append(fp["name"])
  63.    return results
  64. ​
  65. # 示例使用
  66. if __name__ == "__main__":
  67.    target_url = "http://101.200.50.94:8009/"
  68.    result = match_fingerprint(target_url)
  69.    print("识别结果：", result)
  70. ​
复制代码
大体逻辑就是这样了
首先就是 yaml 文件为我们的判断依据，对应不同的判断方法我们都有对应的后端处理
一个是对 body 的处理，一个是对 hash 文件的处理
[img=720,795.2142857142857]https://www.yijinglab.com/guide-img/d9634e2f-3b66-42e7-8279-c0877cdd70e5/ef7e6cb6-44e7-40fd-b03d-6591b8d01137.png[/img]

然后再根据规则去匹配
匹配成功输出结果
当然这只是一个简单的逻辑,如果需要实现更高高效快捷第一就是指纹库，第二就是代码运行的速率，提高线程
最终识别代码

首先就是指纹库的获取，这个的话我们就不直接获取了，使用的是 EHole 的指纹库
我们大概看看部分代码
  1. {
  2. "fingerprint": [{
  3.     "cms": "seeyon",
  4.     "method": "keyword",
  5.     "location": "body",
  6.     "keyword": ["/seeyon/USER-DATA/IMAGES/LOGIN/login.gif"]
  7. }, {
  8.     "cms": "seeyon",
  9.     "method": "keyword",
  10.     "location": "body",
  11.     "keyword": ["/seeyon/common/"]
  12. }, {
  13.     "cms": "Spring env",
  14.     "method": "keyword",
  15.     "location": "body",
  16.     "keyword": ["servletContextInitParams"]
  17. }, {
  18.     "cms": "微三云管理系统",
  19.     "method": "keyword",
  20.     "location": "body",
  21.     "keyword": ["WSY_logo","管理系统 MANAGEMENT SYSTEM"]
  22. }, {
  23.     "cms": "Spring env",
  24.     "method": "keyword",
  25.     "location": "body",
  26.     "keyword": ["logback"]
  27. }, {
  28.     "cms": "Weblogic",
  29.     "method": "keyword",
  30.     "location": "body",
  31.     "keyword": ["Error 404--Not Found"]
  32. }, {
  33.     "cms": "Weblogic",
  34.     "method": "keyword",
  35.     "location": "body",
  36.     "keyword": ["Error 403--"]
  37. }
  38. ​
  39. ​
  40. {
  41.     "cms": "Atlassian – JIRA",
  42.     "method": "faviconhash",
  43.     "location": "body",
  44.     "keyword": ["981867722"]
  45. }, {
  46.     "cms": "OpenStack",
  47.     "method": "faviconhash",
  48.     "location": "body",
  49.     "keyword": ["-923088984"]
  50. }, {
  51.     "cms": "Aplikasi",
  52.     "method": "faviconhash",
  53.     "location": "body",
  54.     "keyword": ["494866796"]
  55. }, {
  56.     "cms": "Ubiquiti Aircube",
  57.     "method": "faviconhash",
  58.     "location": "body",
  59.     "keyword": ["1249285083"]
  60. }
复制代码
简单看了一下逻辑可以发现和我们的指定方法应该差不多，逻辑就是首先根据 method 去选择方法，一个是 keyword 方法，一个是 faviconhash 方法，是一个大的判断，然乎下面就是根据具体的比如 body，title 等去识别了
代码如下
  1. import json
  2. import requests
  3. import hashlib
  4. import base64
  5. from bs4 import BeautifulSoup
  6. from urllib.parse import urljoin
  7. from concurrent.futures import ThreadPoolExecutor, as_completed
  8. import argparse
  9. ​
  10. # 加载指纹
  11. def load_fingerprints(file='finger.json'):
  12.    with open(file, 'r', encoding='utf-8') as f:
  13.        data = json.load(f)
  14.        if "fingerprint" in data:
  15.            return data["fingerprint"]
  16.        raise ValueError("指纹文件格式不正确，应包含 'fingerprint' 字段。")
  17. ​
  18. # 获取 HTTP 响应
  19. def get_http_response(url):
  20.    try:
  21.        headers = {
  22.            "User-Agent": "Mozilla/5.0"
  23.        }
  24.        return requests.get(url, headers=headers, timeout=8, verify=False)
  25.    except:
  26.        return None
  27. ​
  28. # 计算 favicon hash
  29. def get_favicon_hash(url):
  30.    try:
  31.        favicon_url = urljoin(url, '/favicon.ico')
  32.        res = requests.get(favicon_url, timeout=5, verify=False)
  33.        if res.status_code == 200:
  34.            m = hashlib.md5()
  35.            b64 = base64.b64encode(res.content)
  36.            m.update(b64)
  37.            return int(m.hexdigest(), 16)
  38.    except:
  39.        return None
  40. ​
  41. # 匹配单条指纹
  42. def match_one(fpr, res, fav_hash):
  43.    method = fpr["method"]
  44.    loc = fpr.get("location", "body").lower()
  45.    kws = fpr["keyword"]
  46. ​
  47.    if method == 'keyword':
  48.        text_body = res.text or ""
  49.        text_head = "\n".join(f"{k}: {v}" for k, v in res.headers.items())
  50. ​
  51.        # 处理 title 和 header 等
  52.        if loc == 'header':
  53.            spaces = [text_head, text_body]
  54.        elif loc == 'title':
  55.            soup = BeautifulSoup(text_body, "html.parser")
  56.            title = soup.title.string if soup.title and soup.title.string else ""
  57.            spaces = [title, text_body]
  58.        elif loc == 'body':
  59.            spaces = [text_body]
  60.        else:
  61.            spaces = [text_body]
  62. ​
  63.        for space in spaces:
  64.            for kw in kws:
  65.                if kw.lower() in space.lower():
  66.                    return True
  67. ​
  68.    if method == 'faviconhash' and fav_hash is not None:
  69.        for kw in kws:
  70.            try:
  71.                if fav_hash == int(kw):
  72.                    return True
  73.            except:
  74.                continue
  75. ​
  76.    return False
  77. ​
  78. # 识别单个 URL 指纹
  79. def match_fingerprint(url, fps=None):
  80.    fps = fps or load_fingerprints()
  81.    res = get_http_response(url)
  82.    fav_hash = get_favicon_hash(url)
  83. ​
  84.    matched = []
  85.    for fpr in fps:
  86.        if 'cms' not in fpr or 'method' not in fpr or 'keyword' not in fpr:
  87.            continue
  88.        if match_one(fpr, res, fav_hash):
  89.            matched.append(fpr['cms'])
  90. ​
  91.    print(f"[✓] {url} 指纹识别结果：{list(set(matched))}")
  92.    return {url: list(set(matched))}
  93. ​
  94. # 多线程执行
  95. def run_multithread(urls, threads):
  96.    fps = load_fingerprints()
  97.    results = []
  98.    with ThreadPoolExecutor(max_workers=threads) as executor:
  99.        future_to_url = {executor.submit(match_fingerprint, url, fps): url for url in urls}
  100.        for future in as_completed(future_to_url):
  101.            results.append(future.result())
  102.    return results
  103. ​
  104. # 主程序入口
  105. def main():
  106.    parser = argparse.ArgumentParser(description="指纹识别脚本 - 支持多线程")
  107.    group = parser.add_mutually_exclusive_group(required=True)
  108.    group.add_argument("-u", "--url", help="单个目标 URL")
  109.    group.add_argument("-f", "--file", help="包含多个 URL 的文件")
  110.    parser.add_argument("-t", "--threads", type=int, default=10, help="线程数（默认10）")
  111.    args = parser.parse_args()
  112. ​
  113.    if args.url:
  114.        match_fingerprint(args.url)
  115. ​
  116.    elif args.file:
  117.        with open(args.file, 'r', encoding='utf-8') as f:
  118.            urls = [line.strip() for line in f if line.strip()]
  119.        results = run_multithread(urls, args.threads)
  120. ​
  121. if __name__ == '__main__':
  122.    main()
  123. ​
复制代码
加入了支持多线程和支持多目标的思路
结合漏洞扫描

我们光目标识别后，还需要实现精准化打击，正好 Nuclei 引擎支持根据 tag 去寻找我们的目标，完美了
实现思路就是首先寻找我们的 tag，然后在漏洞库里面查询，把有 tag 的和没有 tag 的分别分开放好，然后根据有 tag 的去精准化识别运行，完成最后的精准化 POC 攻击
初步的代码如下
  1. import json
  2. import os
  3. import threading
  4. import time
  5. import base64
  6. import hashlib
  7. import requests
  8. import argparse
  9. from bs4 import BeautifulSoup
  10. from urllib.parse import urljoin
  11. from concurrent.futures import ThreadPoolExecutor, as_completed
  12. from queue import Queue
  13. ​
  14. requests.packages.urllib3.disable_warnings()
  15. ​
  16. # ---------- 指纹识别部分 ----------
  17. ​
  18. def load_fingerprints(file='finger.json'):
  19.    with open(file, 'r', encoding='utf-8') as f:
  20.        data = json.load(f)
  21.        return data["fingerprint"]
  22. ​
  23. def get_http_response(url):
  24.    try:
  25.        headers = {"User-Agent": "Mozilla/5.0"}
  26.        return requests.get(url, headers=headers, timeout=8, verify=False)
  27.    except:
  28.        return None
  29. ​
  30. def get_favicon_hash(url):
  31.    try:
  32.        favicon_url = urljoin(url, '/favicon.ico')
  33.        res = requests.get(favicon_url, timeout=5, verify=False)
  34.        if res.status_code == 200:
  35.            m = hashlib.md5()
  36.            b64 = base64.b64encode(res.content)
  37.            m.update(b64)
  38.            return int(m.hexdigest(), 16)
  39.    except:
  40.        return None
  41. ​
  42. def match_one(fpr, res, fav_hash):
  43.    method = fpr["method"]
  44.    loc = fpr.get("location", "body").lower()
  45.    kws = fpr["keyword"]
  46. ​
  47.    if method == 'keyword':
  48.        text_body = res.text or ""
  49.        text_head = "\n".join(f"{k}: {v}" for k, v in res.headers.items())
  50.        if loc == 'header':
  51.            spaces = [text_head]
  52.        elif loc == 'title':
  53.            soup = BeautifulSoup(text_body, "html.parser")
  54.            title = soup.title.string if soup.title and soup.title.string else ""
  55.            spaces = [title]
  56.        else:
  57.            spaces = [text_body]
  58. ​
  59.        for space in spaces:
  60.            for kw in kws:
  61.                if kw.lower() in space.lower():
  62.                    return True
  63. ​
  64.    elif method == 'faviconhash' and fav_hash is not None:
  65.        for kw in kws:
  66.            try:
  67.                if fav_hash == int(kw):
  68.                    return True
  69.            except:
  70.                continue
  71. ​
  72.    return False
  73. ​
  74. def match_fingerprint(url, fps):
  75.    res = get_http_response(url)
  76.    fav_hash = get_favicon_hash(url)
  77.    matched = []
  78. ​
  79.    for fpr in fps:
  80.        if 'cms' not in fpr or 'method' not in fpr or 'keyword' not in fpr:
  81.            continue
  82.        if match_one(fpr, res, fav_hash):
  83.            matched.append(fpr['cms'])
  84. ​
  85.    print(f"[✓] {url} 指纹识别结果：{list(set(matched))}")
  86.    return {"url": url, "cms": list(set(matched))[0] if matched else ""}
  87. ​
  88. def run_fingerprint_scan(urls, threads, output='res.json'):
  89.    fps = load_fingerprints()
  90.    results = []
  91. ​
  92.    with ThreadPoolExecutor(max_workers=threads) as executor:
  93.        future_to_url = {executor.submit(match_fingerprint, url, fps): url for url in urls}
  94.        for future in as_completed(future_to_url):
  95.            results.append(future.result())
  96. ​
  97.    with open(output, 'w', encoding='utf-8') as f:
  98.        json.dump(results, f, ensure_ascii=False, indent=2)
  99. ​
  100. # ---------- Nuclei 扫描部分 ----------
  101. ​
  102. class AutoNuclei:
  103.    def __init__(self, res_file='res.json', tag_file='C:\\Users\\86135\\nuclei-templates\\TEMPLATES-STATS.json', thread_count=5):
  104.        self.res_file = res_file
  105.        self.tag_file = tag_file
  106.        self.havetag_file = 'havetag.txt'
  107.        self.notag_file = 'notag.txt'
  108.        self.result_dir = 'result'
  109.        self.thread_count = thread_count
  110. ​
  111.        self.cms_targets = {}         # {cms: [url1, url2]}
  112.        self.nuclei_tags = set()
  113.        self.tagged_targets = {}      # {tag: [url1, url2]}
  114.        self.untagged_targets = []
  115. ​
  116.        self.task_queue = Queue()
  117.        self.load_res_json()
  118.        self.load_tags()
  119.        self.classify_targets()
  120.        self.save_targets()
  121.        self.start_scan_threads()
  122. ​
  123.    def load_res_json(self):
  124.        with open(self.res_file, 'r', encoding='utf-8') as f:
  125.            data = json.load(f)
  126.        for entry in data:
  127.            cms = entry.get("cms", "").lower()
  128.            url = entry.get("url")
  129.            if cms and url:
  130.                self.cms_targets.setdefault(cms, []).append(url)
  131. ​
  132.    def load_tags(self):
  133.        with open(self.tag_file, 'r', encoding='utf-8') as f:
  134.            tags_data = json.load(f)
  135.        for item in tags_data.get("tags", []):
  136.            if item["name"]:
  137.                self.nuclei_tags.add(item["name"].lower())
  138. ​
  139.    def classify_targets(self):
  140.        for cms, urls in self.cms_targets.items():
  141.            if cms in self.nuclei_tags:
  142.                self.tagged_targets.setdefault(cms, []).extend(urls)
  143.            else:
  144.                self.untagged_targets.extend(urls)
  145. ​
  146.    def save_targets(self):
  147.        with open(self.havetag_file, 'w', encoding='utf-8') as f:
  148.            for tag, urls in self.tagged_targets.items():
  149.                for url in urls:
  150.                    f.write(f"{tag}||{url}\n")
  151. ​
  152.        with open(self.notag_file, 'w', encoding='utf-8') as f:
  153.            for url in self.untagged_targets:
  154.                f.write(url + '\n')
  155. ​
  156.        if not os.path.exists(self.result_dir):
  157.            os.makedirs(self.result_dir)
  158. ​
  159.    def scan_worker(self):
  160.        while not self.task_queue.empty():
  161.            try:
  162.                tag, url = self.task_queue.get(timeout=1)
  163.                target_file = f"temp_{int(time.time() * 1000)}.txt"
  164.                with open(target_file, 'w', encoding='utf-8') as f:
  165.                    f.write(url)
  166. ​
  167.                output_file = os.path.join(self.result_dir, f"{tag}_{int(time.time())}.txt")
  168.                cmd = f"F:\\gj\\Vulnerability_Scanning\\nuclei\\nuclei.exe -l {target_file} -tags {tag} -o {output_file} -stats"
  169.                print(f"[+] 扫描任务启动: {url} -> {tag}")
  170.                os.system(cmd)
  171.                os.remove(target_file)
  172.            except Exception as e:
  173.                print(f"[!] 线程错误: {e}")
  174. ​
  175.    def start_scan_threads(self):
  176.        for tag, urls in self.tagged_targets.items():
  177.            for url in urls:
  178.                self.task_queue.put((tag, url))
  179.        threads = []
  180.        for _ in range(self.thread_count):
  181.            t = threading.Thread(target=self.scan_worker)
  182.            t.start()
  183.            threads.append(t)
  184.        for t in threads:
  185.            t.join()
  186.        print("[✓] 所有扫描任务完成！")
  187. ​
  188. # ---------- 主程序入口 ----------
  189. ​
  190. def main():
  191.    parser = argparse.ArgumentParser(description="指纹识别 + Nuclei自动化工具")
  192.    group = parser.add_mutually_exclusive_group(required=True)
  193.    group.add_argument("-u", "--url", help="目标 URL")
  194.    group.add_argument("-f", "--file", help="URL列表文件")
  195.    parser.add_argument("--fp-threads", type=int, default=10, help="指纹识别线程数")
  196.    parser.add_argument("--scan-threads", type=int, default=5, help="Nuclei 扫描线程数")
  197.    args = parser.parse_args()
  198. ​
  199.    urls = []
  200.    if args.url:
  201.        urls = [args.url]
  202.    elif args.file:
  203.        with open(args.file, 'r', encoding='utf-8') as f:
  204.            urls = [line.strip() for line in f if line.strip()]
  205. ​
  206.    print("[*] 正在执行指纹识别...")
  207.    run_fingerprint_scan(urls, threads=args.fp_threads, output='res.json')
  208. ​
  209.    print("[*] 指纹识别完成，开始 Nuclei 扫描...")
  210.    AutoNuclei(
  211.        res_file='res.json',
  212.        tag_file=os.path.join(os.environ['USERPROFILE'], 'nuclei-templates', 'TEMPLATES-STATS.json'),
  213.        thread_count=args.scan_threads
  214.    )
  215. ​
  216. if __name__ == '__main__':
  217.    main()
复制代码
更多网安技能的在线实操练习，请点击这里>>
  

来源：程序园用户自行投稿发布，如果侵权，请联系站长删除
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

使用道具 举报
相关推荐
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册
发帖
缑莺韵
4 天前

0

粉丝关注

6

主题发布

板块介绍填写区域，请于后台编辑
微信扫一扫