Improper Neutralization of Special Elements used in an SQL Command

#!/usr/bin/env python3
# Mergen QMS CVE-2023-5806 version triage helper
# Outputs: VULNERABLE / PATCHED / UNKNOWN
# Exit codes: 0=determined, 2=unknown, 3=usage/runtime error

import argparse
import os
import re
import ssl
import sys
import urllib.request
from urllib.parse import urljoin

FIX_VERSION = (1, 2)
TIMEOUT = 8
MAX_READ = 1024 * 1024  # 1 MB per file/response

VERSION_PATTERNS = [
    re.compile(r'(?i)\bversion\b[^0-9]{0,16}v?([0-9]+(?:\.[0-9]+){1,3})'),
    re.compile(r'(?i)\bv?([0-9]+\.[0-9]+(?:\.[0-9]+)?)\b'),
]

CANDIDATE_FILES = {
    'version', 'version.txt', 'about', 'about.txt', 'readme', 'readme.txt',
    'changelog', 'manifest.json', 'package.json', 'composer.json',
    'appsettings.json', 'config.php', 'config.json', 'web.config'
}

URL_PATHS = ['/', '/login', '/about', '/version', '/api/version']


def parse_version_tuple(s):
    parts = s.strip().lower().lstrip('v').split('.')
    nums = []
    for p in parts:
        m = re.match(r'^(\d+)', p)
        if not m:
            return None
        nums.append(int(m.group(1)))
    while len(nums) < 3:
        nums.append(0)
    return tuple(nums[:3])


def compare_versions(found, fixed=FIX_VERSION + (0,)):
    if found is None:
        return None
    if found < fixed:
        return -1
    if found > fixed:
        return 1
    return 0


def extract_versions(text):
    results = []
    for pat in VERSION_PATTERNS:
        for m in pat.finditer(text):
            vt = parse_version_tuple(m.group(1))
            if vt:
                results.append((m.group(1), vt))
    return results


def fetch_url(url):
    ctx = ssl.create_default_context()
    req = urllib.request.Request(url, headers={'User-Agent': 'mergen-qms-check/1.0'})
    with urllib.request.urlopen(req, timeout=TIMEOUT, context=ctx) as resp:
        raw = resp.read(MAX_READ)
        headers = '\n'.join(f'{k}: {v}' for k, v in resp.headers.items())
        body = raw.decode('utf-8', errors='ignore')
        return headers + '\n' + body


def inspect_url(base_url):
    hits = []
    for path in URL_PATHS:
        target = urljoin(base_url.rstrip('/') + '/', path.lstrip('/'))
        try:
            text = fetch_url(target)
            versions = extract_versions(text)
            for original, vt in versions:
                hits.append((f'url:{target}', original, vt))
        except Exception:
            continue
    return hits


def inspect_root(root):
    hits = []
    for dirpath, _, filenames in os.walk(root):
        for name in filenames:
            lower = name.lower()
            if lower in CANDIDATE_FILES or 'version' in lower or 'about' in lower:
                full = os.path.join(dirpath, name)
                try:
                    if os.path.getsize(full) > MAX_READ:
                        continue
                    with open(full, 'r', encoding='utf-8', errors='ignore') as f:
                        text = f.read(MAX_READ)
                    versions = extract_versions(text)
                    for original, vt in versions:
                        hits.append((f'file:{full}', original, vt))
                except Exception:
                    continue
    return hits


def choose_best_hit(hits):
    if not hits:
        return None
    # Prefer explicit version labels, then shortest path/source string
    def score(hit):
        source, original, vt = hit
        explicit = 0 if 'version' in source.lower() else 1
        return (explicit, len(source))
    return sorted(hits, key=score)[0]


def main():
    ap = argparse.ArgumentParser(description='Check Mergen QMS version exposure for CVE-2023-5806')
    ap.add_argument('--url', help='Base URL of the Mergen QMS application, e.g. https://qms.example.com')
    ap.add_argument('--root', help='Local application root to inspect, e.g. /opt/mergen')
    args = ap.parse_args()

    if not args.url and not args.root:
        print('UNKNOWN - provide --url or --root')
        sys.exit(2)

    hits = []
    if args.url:
        hits.extend(inspect_url(args.url))
    if args.root:
        if not os.path.isdir(args.root):
            print(f'UNKNOWN - root path not found: {args.root}')
            sys.exit(2)
        hits.extend(inspect_root(args.root))

    best = choose_best_hit(hits)
    if not best:
        print('UNKNOWN - could not determine Mergen QMS version from reachable content or local files')
        sys.exit(2)

    source, original, vt = best
    cmp_result = compare_versions(vt)
    normalized = '.'.join(map(str, vt))

    if cmp_result == -1:
        print(f'VULNERABLE - discovered version {original} ({normalized}) from {source}; fixed boundary is v1.2')
        sys.exit(0)
    elif cmp_result in (0, 1):
        print(f'PATCHED - discovered version {original} ({normalized}) from {source}; meets/exceeds v1.2 for CVE-2023-5806')
        sys.exit(0)
    else:
        print('UNKNOWN - unable to compare discovered version')
        sys.exit(2)


if __name__ == '__main__':
    try:
        main()
    except KeyboardInterrupt:
        print('UNKNOWN - interrupted')
        sys.exit(2)
    except Exception as e:
        print(f'UNKNOWN - runtime error: {e}')
        sys.exit(3)