首先就是指纹库的获取，这个的话我们就不直接获取了，使用的是%20EHole%20的指纹库

我们大概看看部分代码

{
"fingerprint":%20[{
 %20  "cms": "seeyon",
 %20  "method": "keyword",
 %20  "location": "body",
 %20  "keyword":%20["/seeyon/USER-DATA/IMAGES/LOGIN/login.gif"]
}, {
    "cms": "seeyon",
    "method": "keyword",
    "location": "body",
    "keyword": ["/seeyon/common/"]
}, {
    "cms": "Spring env",
    "method": "keyword",
    "location": "body",
    "keyword": ["servletContextInitParams"]
}, {
    "cms": "微三云管理系统",
    "method": "keyword",
    "location": "body",
    "keyword": ["WSY_logo","管理系统 MANAGEMENT SYSTEM"]
}, {
    "cms": "Spring env",
    "method": "keyword",
    "location": "body",
    "keyword": ["logback"]
}, {
    "cms": "Weblogic",
    "method": "keyword",
    "location": "body",
    "keyword": ["Error 404--Not Found"]
}, {
    "cms": "Weblogic",
    "method": "keyword",
    "location": "body",
    "keyword": ["Error 403--"]
}

{
    "cms": "Atlassian – JIRA",
    "method": "faviconhash",
    "location": "body",
    "keyword": ["981867722"]
}, {
    "cms": "OpenStack",
    "method": "faviconhash",
    "location": "body",
    "keyword": ["-923088984"]
}, {
    "cms": "Aplikasi",
    "method": "faviconhash",
    "location": "body",
    "keyword": ["494866796"]
}, {
    "cms": "Ubiquiti Aircube",
    "method": "faviconhash",
    "location": "body",
    "keyword": ["1249285083"]
}

简单看了一下逻辑可以发现和我们的指定方法应该差不多，逻辑就是首先根据 method 去选择方法，一个是 keyword 方法，一个是 faviconhash 方法，是一个大的判断，然乎下面就是根据具体的比如 body，title 等去识别了

代码如下

import json
import requests
import hashlib
import base64
from bs4 import BeautifulSoup
from urllib.parse import urljoin
from concurrent.futures import ThreadPoolExecutor, as_completed
import argparse

# 加载指纹
def load_fingerprints(file='finger.json'):
    with open(file, 'r', encoding='utf-8') as f:
        data = json.load(f)
        if"fingerprint" in data:
            return data["fingerprint"]
        raise ValueError("指纹文件格式不正确，应包含 'fingerprint' 字段。")

# 获取 HTTP 响应
def get_http_response(url):
    try:
        headers = {
            "User-Agent": "Mozilla/5.0"
        }
        return requests.get(url, headers=headers, timeout=8, verify=False)
    except:
        return None

# 计算 favicon hash
def get_favicon_hash(url):
    try:
        favicon_url = urljoin(url, '/favicon.ico')
        res = requests.get(favicon_url, timeout=5, verify=False)
        if res.status_code == 200:
            m = hashlib.md5()
            b64 = base64.b64encode(res.content)
            m.update(b64)
            returnint(m.hexdigest(), 16)
    except:
        return None

# 匹配单条指纹
def match_one(fpr, res, fav_hash):
    method = fpr["method"]
    loc = fpr.get("location", "body").lower()
    kws = fpr["keyword"]

    if method == 'keyword':
        text_body = res.text or""
        text_head = "\n".join(f"{k}: {v}"for k, v in res.headers.items())

        # 处理 title 和 header 等
        if loc == 'header':
            spaces = [text_head, text_body]
        elif loc == 'title':
            soup = BeautifulSoup(text_body, "html.parser")
            title = soup.title.stringif soup.title and soup.title.stringelse""
            spaces = [title, text_body]
        elif loc == 'body':
            spaces = [text_body]
        else:
            spaces = [text_body]

        for space in spaces:
            for kw in kws:
                if kw.lower() in space.lower():
                    return True

    if method == 'faviconhash'and fav_hash is not None:
        for kw in kws:
            try:
                if fav_hash == int(kw):
                    return True
            except:
                continue

    return False

# 识别单个 URL 指纹
def match_fingerprint(url, fps=None):
    fps = fps orload_fingerprints()
    res = get_http_response(url)
    fav_hash = get_favicon_hash(url)

    matched = []
    for fpr in fps:
        if'cms' not in fpr or'method' not in fpr or'keyword' not in fpr:
            continue
        ifmatch_one(fpr, res, fav_hash):
            matched.append(fpr['cms'])

    print(f"[✓] {url} 指纹识别结果：{list(set(matched))}")
    return {url: list(set(matched))}

# 多线程执行
def run_multithread(urls, threads):
    fps = load_fingerprints()
    results = []
    with ThreadPoolExecutor(max_workers=threads) as executor:
        future_to_url = {executor.submit(match_fingerprint, url, fps): url for url in urls}
        for future in as_completed(future_to_url):
            results.append(future.result())
    return results

# 主程序入口
def main():
    parser = argparse.ArgumentParser(description="指纹识别脚本 - 支持多线程")
    group = parser.add_mutually_exclusive_group(required=True)
    group.add_argument("-u", "--url", help="单个目标 URL")
    group.add_argument("-f", "--file", help="包含多个 URL 的文件")
    parser.add_argument("-t", "--threads", type=int, default=10, help="线程数（默认10）")
    args = parser.parse_args()

    if args.url:
        match_fingerprint(args.url)

    elif args.file:
        with open(args.file, 'r', encoding='utf-8') as f:
            urls = [line.strip() for line in f if line.strip()]
        results = run_multithread(urls, args.threads)

if __name__ == '__main__':
    main()

加入了支持多线程和支持多目标的思路

结合漏洞扫描

我们光目标识别后，还需要实现精准化打击，正好 Nuclei 引擎支持根据 tag 去寻找我们的目标，完美了

实现思路就是首先寻找我们的 tag，然后在漏洞库里面查询，把有 tag 的和没有 tag 的分别分开放好，然后根据有 tag 的去精准化识别运行，完成最后的精准化 POC 攻击

初步的代码如下

import json
import os
import threading
import time
import base64
import hashlib
import requests
import argparse
from bs4 import BeautifulSoup
from urllib.parse import urljoin
from concurrent.futures import ThreadPoolExecutor, as_completed
from queue import Queue

requests.packages.urllib3.disable_warnings()

# ---------- 指纹识别部分 ----------

def load_fingerprints(file='finger.json'):
    with open(file, 'r', encoding='utf-8') as f:
        data = json.load(f)
        return data["fingerprint"]

def get_http_response(url):
    try:
        headers = {"User-Agent": "Mozilla/5.0"}
        return requests.get(url, headers=headers, timeout=8, verify=False)
    except:
        return None

def get_favicon_hash(url):
    try:
        favicon_url = urljoin(url, '/favicon.ico')
        res = requests.get(favicon_url, timeout=5, verify=False)
        if res.status_code == 200:
            m = hashlib.md5()
            b64 = base64.b64encode(res.content)
            m.update(b64)
            returnint(m.hexdigest(), 16)
    except:
        return None

def match_one(fpr, res, fav_hash):
    method = fpr["method"]
    loc = fpr.get("location", "body").lower()
    kws = fpr["keyword"]

    if method == 'keyword':
        text_body = res.text or""
        text_head = "\n".join(f"{k}: {v}"for k, v in res.headers.items())
        if loc == 'header':
            spaces = [text_head]
        elif loc == 'title':
            soup = BeautifulSoup(text_body, "html.parser")
            title = soup.title.stringif soup.title and soup.title.stringelse""
            spaces = [title]
        else:
            spaces = [text_body]

        for space in spaces:
            for kw in kws:
                if kw.lower() in space.lower():
                    return True

    elif method == 'faviconhash'and fav_hash is not None:
        for kw in kws:
            try:
                if fav_hash == int(kw):
                    return True
            except:
                continue

    return False

def match_fingerprint(url, fps):
    res = get_http_response(url)
    fav_hash = get_favicon_hash(url)
    matched = []

    for fpr in fps:
        if'cms' not in fpr or'method' not in fpr or'keyword' not in fpr:
            continue
        ifmatch_one(fpr, res, fav_hash):
            matched.append(fpr['cms'])

    print(f"[✓] {url} 指纹识别结果：{list(set(matched))}")
    return {"url": url, "cms": list(set(matched))[0] if matched else""}

def run_fingerprint_scan(urls, threads, output='res.json'):
    fps = load_fingerprints()
    results = []

    with ThreadPoolExecutor(max_workers=threads) as executor:
        future_to_url = {executor.submit(match_fingerprint, url, fps): url for url in urls}
        for future in as_completed(future_to_url):
            results.append(future.result())

    with open(output, 'w', encoding='utf-8') as f:
        json.dump(results, f, ensure_ascii=False, indent=2)

# ---------- Nuclei 扫描部分 ----------

class AutoNuclei:
    def __init__(self, res_file='res.json', tag_file='C:\\Users\\86135\\nuclei-templates\\TEMPLATES-STATS.json', thread_count=5):
        self.res_file = res_file
        self.tag_file = tag_file
        self.havetag_file = 'havetag.txt'
        self.notag_file = 'notag.txt'
        self.result_dir = 'result'
        self.thread_count = thread_count

        self.cms_targets = {}         # {cms: [url1, url2]}
        self.nuclei_tags = set()
        self.tagged_targets = {}      # {tag: [url1, url2]}
        self.untagged_targets = []

        self.task_queue = Queue()
        self.load_res_json()
        self.load_tags()
        self.classify_targets()
        self.save_targets()
        self.start_scan_threads()

    def load_res_json(self):
        with open(self.res_file, 'r', encoding='utf-8') as f:
            data = json.load(f)
        for entry in data:
            cms = entry.get("cms", "").lower()
            url = entry.get("url")
            if cms and url:
                self.cms_targets.setdefault(cms, []).append(url)

    def load_tags(self):
        with open(self.tag_file, 'r', encoding='utf-8') as f:
            tags_data = json.load(f)
        for item in tags_data.get("tags", []):
            if item["name"]:
                self.nuclei_tags.add(item["name"].lower())

    def classify_targets(self):
        for cms, urls in self.cms_targets.items():
            if cms in self.nuclei_tags:
                self.tagged_targets.setdefault(cms, []).extend(urls)
            else:
                self.untagged_targets.extend(urls)

    def save_targets(self):
        with open(self.havetag_file, 'w', encoding='utf-8') as f:
            for tag, urls in self.tagged_targets.items():
                for url in urls:
                    f.write(f"{tag}||{url}\n")

        with open(self.notag_file, 'w', encoding='utf-8') as f:
            for url in self.untagged_targets:
                f.write(url + '\n')

        if not os.path.exists(self.result_dir):
            os.makedirs(self.result_dir)

    def scan_worker(self):
        while not self.task_queue.empty():
            try:
                tag, url = self.task_queue.get(timeout=1)
                target_file = f"temp_{int(time.time() * 1000)}.txt"
                with open(target_file, 'w', encoding='utf-8') as f:
                    f.write(url)

                output_file = os.path.join(self.result_dir, f"{tag}_{int(time.time())}.txt")
                cmd = f"F:\\gj\\Vulnerability_Scanning\\nuclei\\nuclei.exe -l {target_file} -tags {tag} -o {output_file} -stats"
                print(f"[+] 扫描任务启动: {url} -> {tag}")
                os.system(cmd)
                os.remove(target_file)
            except Exceptionas e:
                print(f"[!] 线程错误: {e}")

    def start_scan_threads(self):
        for tag, urls in self.tagged_targets.items():
            for url in urls:
                self.task_queue.put((tag, url))
        threads = []
        for _ in range(self.thread_count):
            t = threading.Thread(target=self.scan_worker)
            t.start()
            threads.append(t)
        for t in threads:
            t.join()
        print("[✓] 所有扫描任务完成！")

# ---------- 主程序入口 ----------

def main():
    parser = argparse.ArgumentParser(description="指纹识别 + Nuclei自动化工具")
    group = parser.add_mutually_exclusive_group(required=True)
    group.add_argument("-u", "--url", help="目标 URL")
    group.add_argument("-f", "--file", help="URL列表文件")
    parser.add_argument("--fp-threads", type=int, default=10, help="指纹识别线程数")
    parser.add_argument("--scan-threads", type=int, default=5, help="Nuclei 扫描线程数")
    args = parser.parse_args()

    urls = []
    if args.url:
        urls = [args.url]
    elif args.file:
        with open(args.file, 'r', encoding='utf-8') as f:
            urls = [line.strip() for line in f if line.strip()]

    print("[*] 正在执行指纹识别...")
    run_fingerprint_scan(urls, threads=args.fp_threads, output='res.json')

    print("[*] 指纹识别完成，开始 Nuclei 扫描...")
    AutoNuclei(
        res_file='res.json',
        tag_file=os.path.join(os.environ['USERPROFILE'], 'nuclei-templates', 'TEMPLATES-STATS.json'),
        thread_count=args.scan_threads
    )

if __name__ == '__main__':
    main()

学习网安实战技术课程，戳“阅读原文”

免责声明：

本文所载程序、技术方法仅面向合法合规的安全研究与教学场景，旨在提升网络安全防护能力，具有明确的技术研究属性。

任何单位或个人未经授权，将本文内容用于攻击、破坏等非法用途的，由此引发的全部法律责任、民事赔偿及连带责任，均由行为人独立承担，本站不承担任何连带责任。

本站内容均为技术交流与知识分享目的发布，若存在版权侵权或其他异议，请通过邮件联系处理，具体联系方式可点击页面上方的联系我。

本文转载自：蚁景网安 《指纹识别+精准化 POC 攻击》