flutter_http_monitor.py

#!/usr/bin/env python3
"""
flutter_http_monitor.py — auto-locate BoringSSL SSL_read / SSL_write in a stripped
libflutter.so (arm64) and generate a ready-to-run Frida monitor script.

Works across Flutter versions: instead of hardcoded offsets it fingerprints the
functions structurally, anchored on engine strings that are stable across builds:
  - "secure_socket_filter.cc"  (Dart's TLS filter, which BL-calls SSL_read/SSL_write)
  - the shared OPENSSL_PUT_ERROR helper + the (field-load / line-imm / return -1) shape
Direction (read vs write) is disambiguated by how the Dart caller treats the result
(SSL_read result is clamped >=0; SSL_write result is tested for negative-as-error).

Usage:
  python3 flutter_http_monitor.py libflutter.so
  python3 flutter_http_monitor.py app.apk                 # pulls lib/arm64-v8a/libflutter.so
  python3 flutter_http_monitor.py libflutter.so -o monitor.js
  python3 flutter_http_monitor.py libflutter.so --print-only

Deps:  pip install capstone pyelftools
"""

import argparse, base64, bisect, io, os, re, sys, zipfile
from collections import Counter

try:
    from elftools.elf.elffile import ELFFile
    from capstone import Cs, CS_ARCH_ARM64, CS_MODE_ARM
except ImportError:
    sys.exit("Missing deps. Run:  pip install capstone pyelftools")

ANCHOR_FILTER = b"secure_socket_filter.cc"

# The Frida monitor template is embedded (base64) so this tool is a single
# portable file. Override with --template to use an external .js instead.
# To refresh after editing the .js:  python3 flutter_http_monitor.py --embed flutter-http-monitor.js
EMBEDDED_TEMPLATE_B64 = "/*
 * flutter-http-monitor
 * Decrypted HTTP traffic monitor for Flutter apps (BoringSSL hook in libflutter.so).
 *
 * Features: reassembles TLS chunks, de-chunks Transfer-Encoding, inflates gzip,
 * pretty-prints JSON, and a Burp-style SCOPE so you only watch the hosts you care about.
 *
 * Offsets below are for ONE specific libflutter.so build. For any other build,
 * regenerate them with flutter_ssl_finder.py (it patches these two constants):
 *   SSL_write   request   (buffer valid on ENTER, len = arg2)
 *   SSL_read    response  (buffer valid on LEAVE, len = retval)
 * If a build ever shows requests/responses swapped, swap the two constants.
 *
 * Usage:
 *   frida -U -f <package> -l flutter-http-monitor.js
 *
 * Live scope control (type these in the Frida REPL while it runs):
 *   addScope('api.example.com')            // add one or more hosts (wildcards ok: '*.example.com')
 *   addScope('a.com', 'b.com')             // add several at once
 *   removeScope('a.com')                   // remove a host
 *   clearScope()                           // empty the scope (then everything shows)
 *   listScope()                            // print current scope
 *   scopeOnly(true|false)                  // true = only in-scope hosts print (default), false = show all
 */

'use strict';

const SSL_WRITE_OFF = 0x73c10c;
const SSL_READ_OFF  = 0x73b900;
const FLUSH_IDLE_MS = 300;
const PRETTY_JSON    = true;
const HEXDUMP_BINARY = true;
const USE_COLOR      = true;  // set false if your terminal shows raw escape codes

const C = {
  reset: '\x1b[0m', dim: '\x1b[90m', bold: '\x1b[1m',
  cyan: '\x1b[36m', green: '\x1b[32m', yellow: '\x1b[33m', red: '\x1b[31m',
};
function col(c, s) { return USE_COLOR ? c + s + C.reset : s; }

// ===================== SCOPE (Burp-style) =====================
// Add the hosts you want to monitor here, or manage live from the REPL with
// addScope('your.host'). Leave empty to show ALL hosts (default).
var SCOPE = [];
// When true, only in-scope hosts print. When SCOPE is empty, everything prints.
var SCOPE_ONLY = true;

function _norm(h) { return (h || '').toLowerCase().trim(); }
function hostMatches(host) {
  if (SCOPE.length === 0) return true;          // empty scope => everything in scope
  host = _norm(host);
  if (!host) return false;                       // unknown host while scope is set => out
  const bare = host.split(':')[0];               // strip :port
  for (const raw of SCOPE) {
    const p = _norm(raw);
    if (p.indexOf('*') >= 0) {
      const re = new RegExp('^' + p.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') + '$');
      if (re.test(host) || re.test(bare)) return true;
    } else if (host.indexOf(p) >= 0) {
      return true;                               // substring match (handles host:port)
    }
  }
  return false;
}
function shouldShow(host) { return !SCOPE_ONLY || SCOPE.length === 0 || hostMatches(host); }

// ---- live controls (callable from the Frida REPL) ----
function listScope() { console.log('[scope] ' + (SCOPE.length ? SCOPE.join(', ') : '(empty — all hosts shown)') + '   scopeOnly=' + SCOPE_ONLY); return SCOPE.slice(); }
function addScope() {
  const items = Array.prototype.concat.apply([], Array.from(arguments)); // flatten args/arrays
  for (const h of items) { const v = _norm(h); if (v && SCOPE.indexOf(v) < 0) SCOPE.push(v); }
  return listScope();
}
function removeScope(h) { const v = _norm(h); const i = SCOPE.indexOf(v); if (i >= 0) SCOPE.splice(i, 1); return listScope(); }
function clearScope() { SCOPE.length = 0; return listScope(); }
function scopeOnly(b) { SCOPE_ONLY = !!b; return listScope(); }
// programmatic access too: frida ... -e "rpc.exports.addscope('x')"
rpc.exports = {
  addscope: function () { return addScope.apply(null, arguments); },
  removescope: removeScope, clearscope: clearScope, listscope: listScope, scopeonly: scopeOnly,
};

// ===================== byte helpers =====================
function utf8(bytes) {
  let out = '', i = 0; const n = bytes.length;
  while (i < n) {
    const b = bytes[i];
    if (b < 0x80) { out += String.fromCharCode(b); i++; }
    else if (b >= 0xc0 && b < 0xe0 && i + 1 < n) { out += String.fromCharCode(((b & 0x1f) << 6) | (bytes[i + 1] & 0x3f)); i += 2; }
    else if (b >= 0xe0 && b < 0xf0 && i + 2 < n) { out += String.fromCharCode(((b & 0x0f) << 12) | ((bytes[i + 1] & 0x3f) << 6) | (bytes[i + 2] & 0x3f)); i += 3; }
    else if (b >= 0xf0 && i + 3 < n) { const cp = ((b & 0x07) << 18) | ((bytes[i + 1] & 0x3f) << 12) | ((bytes[i + 2] & 0x3f) << 6) | (bytes[i + 3] & 0x3f); const c = cp - 0x10000; out += String.fromCharCode(0xd800 + (c >> 10), 0xdc00 + (c & 0x3ff)); i += 4; }
    else { out += '.'; i++; }
  }
  return out;
}
function concat(chunks) { let t = 0; for (const c of chunks) t += c.length; const o = new Uint8Array(t); let p = 0; for (const c of chunks) { o.set(c, p); p += c.length; } return o; }
function findSeq(b, seq, start) { outer: for (let i = start; i <= b.length - seq.length; i++) { for (let j = 0; j < seq.length; j++) if (b[i + j] !== seq[j]) continue outer; return i; } return -1; }
const CRLF = [13, 10], CRLF2 = [13, 10, 13, 10];
function isGzip(b) { return b.length >= 2 && b[0] === 0x1f && b[1] === 0x8b; }

// ===================== tiny-inflate (MIT) + gunzip =====================
function Tree() { this.table = new Uint16Array(16); this.trans = new Uint16Array(288); }
function IData(s, d) { this.s = s; this.i = 0; this.t = 0; this.bitcount = 0; this.dest = d; this.destLen = 0; this.ltree = new Tree(); this.dtree = new Tree(); }
var _sl = new Tree(), _sd = new Tree();
var _lbits = new Uint8Array(30), _lbase = new Uint16Array(30), _dbits = new Uint8Array(30), _dbase = new Uint16Array(30);
var _clc = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
var _ct = new Tree(), _len = new Uint8Array(320), _offs = new Uint16Array(16);
function _bbb(bits, base, delta, first) { var i, s; for (i = 0; i < delta; ++i) bits[i] = 0; for (i = 0; i < 30 - delta; ++i) bits[i + delta] = i / delta | 0; for (s = first, i = 0; i < 30; ++i) { base[i] = s; s += 1 << bits[i]; } }
function _bft(lt, dt) { var i; for (i = 0; i < 7; ++i) lt.table[i] = 0; lt.table[7] = 24; lt.table[8] = 152; lt.table[9] = 112; for (i = 0; i < 24; ++i) lt.trans[i] = 256 + i; for (i = 0; i < 144; ++i) lt.trans[24 + i] = i; for (i = 0; i < 8; ++i) lt.trans[24 + 144 + i] = 280 + i; for (i = 0; i < 112; ++i) lt.trans[24 + 144 + 8 + i] = 144 + i; for (i = 0; i < 5; ++i) dt.table[i] = 0; dt.table[5] = 32; for (i = 0; i < 32; ++i) dt.trans[i] = i; }
function _bt(t, l, off, num) { var i, s; for (i = 0; i < 16; ++i) t.table[i] = 0; for (i = 0; i < num; ++i) t.table[l[off + i]]++; t.table[0] = 0; for (s = 0, i = 0; i < 16; ++i) { _offs[i] = s; s += t.table[i]; } for (i = 0; i < num; ++i) { if (l[off + i]) t.trans[_offs[l[off + i]]++] = i; } }
function _gb(d) { if (!d.bitcount--) { d.t = d.s[d.i++]; d.bitcount = 7; } var b = d.t & 1; d.t >>>= 1; return b; }
function _rb(d, num, base) { if (!num) return base; while (d.bitcount < 24) { d.t |= d.s[d.i++] << d.bitcount; d.bitcount += 8; } var v = d.t & (0xffff >>> (16 - num)); d.t >>>= num; d.bitcount -= num; return v + base; }
function _dsy(d, t) { while (d.bitcount < 24) { d.t |= d.s[d.i++] << d.bitcount; d.bitcount += 8; } var sum = 0, cur = 0, len = 0, tag = d.t; do { cur = 2 * cur + (tag & 1); tag >>>= 1; ++len; sum += t.table[len]; cur -= t.table[len]; } while (cur >= 0); d.t = tag; d.bitcount -= len; return t.trans[sum + cur]; }
function _dtr(d, lt, dt) { var hlit, hdist, hclen, i, num, length; hlit = _rb(d, 5, 257); hdist = _rb(d, 5, 1); hclen = _rb(d, 4, 4); for (i = 0; i < 19; ++i) _len[i] = 0; for (i = 0; i < hclen; ++i) _len[_clc[i]] = _rb(d, 3, 0); _bt(_ct, _len, 0, 19); for (num = 0; num < hlit + hdist;) { var sym = _dsy(d, _ct); switch (sym) { case 16: var p = _len[num - 1]; for (length = _rb(d, 2, 3); length; --length) _len[num++] = p; break; case 17: for (length = _rb(d, 3, 3); length; --length) _len[num++] = 0; break; case 18: for (length = _rb(d, 7, 11); length; --length) _len[num++] = 0; break; default: _len[num++] = sym; } } _bt(lt, _len, 0, hlit); _bt(dt, _len, hlit, hdist); }
function _ib(d, lt, dt) { while (1) { var sym = _dsy(d, lt); if (sym === 256) return; if (sym < 256) d.dest[d.destLen++] = sym; else { var length, dist, o, i; sym -= 257; length = _rb(d, _lbits[sym], _lbase[sym]); dist = _dsy(d, dt); o = d.destLen - _rb(d, _dbits[dist], _dbase[dist]); for (i = o; i < o + length; ++i) d.dest[d.destLen++] = d.dest[i]; } } }
function _iu(d) { var length, inv, i; while (d.bitcount > 8) { d.i--; d.bitcount -= 8; } length = d.s[d.i + 1]; length = 256 * length + d.s[d.i]; inv = d.s[d.i + 3]; inv = 256 * inv + d.s[d.i + 2]; if (length !== (~inv & 0xffff)) throw new Error('len'); d.i += 4; for (i = length; i; --i) d.dest[d.destLen++] = d.s[d.i++]; d.bitcount = 0; }
function inflateRaw(src, dest) { var d = new IData(src, dest), bf, bt; do { bf = _gb(d); bt = _rb(d, 2, 0); if (bt === 0) _iu(d); else if (bt === 1) _ib(d, _sl, _sd); else if (bt === 2) { _dtr(d, d.ltree, d.dtree); _ib(d, d.ltree, d.dtree); } else throw new Error('btype'); } while (!bf); return d.dest.subarray(0, d.destLen); }
_bft(_sl, _sd); _bbb(_lbits, _lbase, 4, 3); _bbb(_dbits, _dbase, 2, 1); _lbits[28] = 0; _lbase[28] = 258;
function gunzip(b) {
  if (b.length < 18 || b[0] !== 0x1f || b[1] !== 0x8b) throw new Error('not gzip');
  var flg = b[3], off = 10;
  if (flg & 4) off += 2 + b[off] + (b[off + 1] << 8);
  if (flg & 8) { while (b[off++] !== 0); }
  if (flg & 16) { while (b[off++] !== 0); }
  if (flg & 2) off += 2;
  var isize = (b[b.length - 4] | (b[b.length - 3] << 8) | (b[b.length - 2] << 16) | (b[b.length - 1] << 24)) >>> 0;
  return inflateRaw(b.subarray(off), new Uint8Array(isize || b.length * 20));
}
function looksText(b) { const n = Math.min(b.length, 64); if (!n) return false; let p = 0; for (let i = 0; i < n; i++) { const c = b[i]; if (c === 9 || c === 10 || c === 13 || (c >= 32 && c < 127)) p++; } return p / n > 0.85; }
function ts() { return new Date().toISOString().slice(11, 23); }

// ===================== HTTP parsing =====================
function dechunk(body) {
  const out = []; let i = 0;
  while (i < body.length) {
    const eol = findSeq(body, CRLF, i); if (eol < 0) break;
    const sizeStr = utf8(body.slice(i, eol)).split(';')[0].trim();
    const size = parseInt(sizeStr, 16);
    if (isNaN(size)) { out.push(body.slice(i)); break; }
    i = eol + 2;
    if (size === 0) break;
    out.push(body.slice(i, i + size));
    i += size + 2;
  }
  return concat(out);
}
function formatBody(headers, body) {
  if (body.length === 0) return '';
  const ce = (headers['content-encoding'] || '').toLowerCase();
  let note = '';
  if (ce.includes('gzip') || isGzip(body)) {
    try { const z = body.length; body = gunzip(body); note = `[gunzipped ${z} -> ${body.length} bytes]\n`; }
    catch (e) { let s = `[gzip body, ${body.length} bytes — inflate failed: ${e.message}]`; if (HEXDUMP_BINARY) s += '\n' + hexdump(body.buffer, { length: Math.min(body.length, 128), ansi: false }); return s; }
  }
  if (!looksText(body)) { let s = note + `[binary body, ${body.length} bytes]`; if (HEXDUMP_BINARY) s += '\n' + hexdump(body.buffer, { length: Math.min(body.length, 256), ansi: false }); return s; }
  const text = utf8(body);
  const ct = (headers['content-type'] || '').toLowerCase();
  const trimmed = text.trim();
  if (PRETTY_JSON && (ct.includes('json') || trimmed.startsWith('{') || trimmed.startsWith('['))) {
    try { return note + JSON.stringify(JSON.parse(trimmed), null, 2); } catch (e) {}
  }
  return note + text;
}
function formatMessage(bytes) {
  const hdrEnd = findSeq(bytes, CRLF2, 0);
  let headBlock, body;
  if (hdrEnd < 0) { headBlock = utf8(bytes).replace(/\0+$/, ''); body = new Uint8Array(0); }
  else { headBlock = utf8(bytes.slice(0, hdrEnd)); body = bytes.slice(hdrEnd + 4); }
  const lines = headBlock.split('\r\n');
  const headers = {};
  for (let k = 1; k < lines.length; k++) { const c = lines[k].indexOf(':'); if (c > 0) headers[lines[k].slice(0, c).trim().toLowerCase()] = lines[k].slice(c + 1).trim(); }
  if ((headers['transfer-encoding'] || '').toLowerCase().includes('chunked')) body = dechunk(body);
  return { startLine: lines[0] || '', headBlock, bodyStr: formatBody(headers, body), host: headers['host'] };
}

// ===================== per-connection reassembly + scope gating =====================
const streams = {};   // `${ssl}|TX|RX` -> { chunks, timer }
const connHost = {};  // ssl -> host (learned from the request on that connection)

function flush(sslKey, dir) {
  const key = sslKey + '|' + dir; const s = streams[key];
  if (!s || s.chunks.length === 0) return;
  if (s.timer) { clearTimeout(s.timer); s.timer = null; }
  const bytes = concat(s.chunks); s.chunks = [];

  const m = formatMessage(bytes);
  let host;
  if (dir === 'TX') { host = m.host; if (host) connHost[sslKey] = host; }
  else { host = connHost[sslKey]; }

  if (!shouldShow(host)) return; // out of scope -> silently drop

  let banner;
  if (dir === 'TX') {
    banner = col(C.bold + C.cyan, '▶ REQUEST ') + '  ' + col(C.cyan, m.startLine);
  } else {
    const code = parseInt((m.startLine.match(/\s(\d{3})\s/) || [])[1], 10);
    const sc = code >= 500 ? C.red : code >= 400 ? C.red : code >= 200 && code < 300 ? C.green : C.yellow;
    banner = col(C.bold + sc, '◀ RESPONSE') + '  ' + col(sc, m.startLine);
  }
  console.log('\n' + banner);
  console.log(col(C.dim, `  ${host || '?'}  conn=${sslKey.slice(-6)}  ${ts()}  ${bytes.length}B`));
  console.log(col(C.dim, '─'.repeat(60)));
  console.log(m.headBlock);
  if (m.bodyStr) { console.log(''); console.log(m.bodyStr); }
  console.log('');
}

function feed(ssl, dir, buf, len) {
  if (len <= 0) return;
  const sslKey = ssl.toString();
  flush(sslKey, dir === 'TX' ? 'RX' : 'TX'); // direction switch => other side complete
  const key = sslKey + '|' + dir;
  if (!streams[key]) streams[key] = { chunks: [], timer: null };
  const s = streams[key];
  s.chunks.push(new Uint8Array(buf.readByteArray(len)));
  if (s.timer) clearTimeout(s.timer);
  s.timer = setTimeout(() => flush(sslKey, dir), FLUSH_IDLE_MS);
}

// ===================== hooks =====================
// SSL_write: request plaintext is in the buffer on ENTER (len = arg2).
// SSL_read : response plaintext is in the buffer on LEAVE (len = return value).
function install(base) {
  Interceptor.attach(base.add(SSL_WRITE_OFF), {
    onEnter(a) { feed(a[0], 'TX', a[1], a[2].toInt32()); }
  });
  Interceptor.attach(base.add(SSL_READ_OFF), {
    onEnter(a) { this.ssl = a[0]; this.buf = a[1]; },
    onLeave(r) { const n = r.toInt32(); if (n > 0) feed(this.ssl, 'RX', this.buf, n); }
  });
  console.log('[+] flutter-http-monitor on libflutter.so @ ' + base);
  console.log('    SSL_write +0x' + SSL_WRITE_OFF.toString(16) + ' (req)   SSL_read +0x' + SSL_READ_OFF.toString(16) + ' (resp)');
  console.log('    REPL: addScope(h) / removeScope(h) / clearScope() / listScope() / scopeOnly(true|false)');
  listScope();
  console.log('[*] Drive the app now...');
}
function findLib() {
  try { if (typeof Module.getBaseAddress === 'function') { const a = Module.getBaseAddress('libflutter.so'); if (a) return a; } } catch (e) {}
  try { const m = Process.findModuleByName('libflutter.so'); if (m) return m.base; } catch (e) {}
  try { if (typeof Module.findBaseAddress === 'function') { const a = Module.findBaseAddress('libflutter.so'); if (a) return a; } } catch (e) {}
  return null;
}
(function wait() { const l = findLib(); if (l === null) { setTimeout(wait, 300); return; } install(l); })();
"

def load_template(template_arg):
    if template_arg:
        return open(template_arg, "r", encoding="utf-8").read()
    if EMBEDDED_TEMPLATE_B64 == "__EMBED__":
        sys.exit("No embedded template. Pass --template flutter-http-monitor.js, or "
                 "run --embed flutter-http-monitor.js to bake it in.")
    return base64.b64decode(EMBEDDED_TEMPLATE_B64).decode("utf-8")

def embed_template(js_path):
    """Bake a template .js into this script's EMBEDDED_TEMPLATE_B64 (dev helper)."""
    b64 = base64.b64encode(open(js_path, "rb").read()).decode("ascii")
    me = os.path.abspath(__file__)
    src = open(me, "r", encoding="utf-8").read()
    src2, n = re.subn(r'EMBEDDED_TEMPLATE_B64 = "[^"]*"',
                      'EMBEDDED_TEMPLATE_B64 = "%s"' % b64, src, count=1)
    if not n:
        sys.exit("Could not find EMBEDDED_TEMPLATE_B64 to update.")
    open(me, "w", encoding="utf-8").write(src2)
    print(f"[+] embedded {js_path} ({len(b64)} b64 chars) into {os.path.basename(me)}")

# ----------------- input loading (.so or .apk) -----------------
def load_libflutter(path):
    if zipfile.is_zipfile(path):
        with zipfile.ZipFile(path) as z:
            cands = [n for n in z.namelist() if n.endswith("libflutter.so")]
            arm64 = [n for n in cands if "arm64-v8a" in n] or cands
            if not arm64:
                sys.exit("No libflutter.so found inside the APK.")
            print(f"[*] APK: extracting {arm64[0]}")
            return io.BytesIO(z.read(arm64[0]))
    return open(path, "rb")

# ----------------- helpers -----------------
def find_anchor_vaddrs(elf, needle):
    """vaddrs of NUL-terminated strings (in alloc PROGBITS) that contain `needle`."""
    out = []
    for sec in elf.iter_sections():
        if sec["sh_type"] != "SHT_PROGBITS" or not (sec["sh_flags"] & 0x2):
            continue
        data = sec.data(); base = sec["sh_addr"]; start = 0
        for j, b in enumerate(data):
            if b == 0:
                if start < j and needle in data[start:j]:
                    out.append(base + start)
                start = j + 1
    return out

def detect_version(raw):
    m = re.search(rb'(\d+\.\d+\.\d+)\s+\(stable\)\s+\([^)]*\)\s+on\s+"[^"]*"', raw)
    if m:
        return m.group(0).decode("latin1").strip()
    m = re.search(rb"(\d+\.\d+\.\d+)\s+\(stable\)", raw)
    if m:
        return m.group(0).decode("latin1").strip()
    m = re.search(rb"Dart VM version: (\d+\.\d+\.\d+)", raw)
    return m.group(1).decode() if m else "unknown"

# ----------------- core analysis -----------------
class Analyzer:
    def __init__(self, elf):
        self.elf = elf
        text = elf.get_section_by_name(".text")
        self.tdata = text.data(); self.tva = text["sh_addr"]
        self.md = Cs(CS_ARCH_ARM64, CS_MODE_ARM); self.md.skipdata = True

    def sweep(self, anchor_addrs):
        """Lite pass: refs to anchor strings, BL edges, function starts."""
        re_adrp = re.compile(r"^(\w+), #?(0x[0-9a-f]+)$")
        re_add = re.compile(r"^(\w+), (\w+), #?(0x[0-9a-f]+|\d+)$")
        re_ldr = re.compile(r"^(\w+), \[(\w+),? ?#?(0x[0-9a-f]+|\d+)?\]?$")
        re_bl = re.compile(r"^#?(0x[0-9a-f]+)$")
        anchors = set(anchor_addrs)
        adrp = {}; refs = []; bl_edges = []; bl_targets = set()
        for addr, size, mn, op in self.md.disasm_lite(self.tdata, self.tva):
            if mn == "adrp":
                m = re_adrp.match(op)
                if m: adrp[m.group(1)] = int(m.group(2), 16)
            elif mn == "add":
                m = re_add.match(op)
                if m and m.group(2) in adrp:
                    imm = int(m.group(3), 16) if m.group(3).startswith("0x") else int(m.group(3))
                    t = adrp[m.group(2)] + imm
                    if t in anchors: refs.append(addr)
                    adrp.pop(m.group(1), None)
            elif mn == "ldr":
                m = re_ldr.match(op)
                if m and m.group(2) in adrp:
                    d = m.group(3)
                    imm = (int(d, 16) if d.startswith("0x") else int(d)) if d else 0
                    if adrp[m.group(2)] + imm in anchors: refs.append(addr)
            elif mn == "bl":
                m = re_bl.match(op)
                if m:
                    t = int(m.group(1), 16); bl_targets.add(t); bl_edges.append((addr, t))
        self.func_starts = sorted(bl_targets)
        return refs, bl_edges

    def enclosing(self, addr):
        i = bisect.bisect_right(self.func_starts, addr) - 1
        return self.func_starts[i] if i >= 0 else None

    def window(self, addr, count=64):
        off = addr - self.tva
        return list(self.md.disasm(self.tdata[off:off + count * 4], addr))

    def window_to_next(self, addr, cap=2000):
        i = bisect.bisect_right(self.func_starts, addr)
        end = self.func_starts[i] if i < len(self.func_starts) else addr + cap * 4
        n = min(end - addr, cap * 4)
        off = addr - self.tva
        return list(self.md.disasm(self.tdata[off:off + n], addr))

    @staticmethod
    def _bl_target(op):
        m = re.match(r"^#?(0x[0-9a-f]+)$", op)
        return int(m.group(1), 16) if m else None

    def caller_votes(self, filter_funcs):
        """Scan filter functions; classify each BL target by how its result is used:
           clamp >=0 (bic/csel-after-cmp)  => read-like ; sign-bit test => write-like."""
        read_v, write_v = Counter(), Counter()
        for ff in filter_funcs:
            ins = self.window_to_next(ff)
            for k, x in enumerate(ins):
                if x.mnemonic != "bl":
                    continue
                tgt = self._bl_target(x.op_str)
                if tgt is None:
                    continue
                for y in ins[k + 1:k + 6]:
                    m, op = y.mnemonic, y.op_str
                    if (m == "bic" and "asr #31" in op) or \
                       (m in ("csel", "csinc") and "wzr" in op):
                        read_v[tgt] += 1; break
                    if (m in ("tbz", "tbnz") and ("#0x1f" in op or "#31" in op)) or \
                       (m in ("cmp",) and re.search(r", #0$", op)):
                        write_v[tgt] += 1; break
        return read_v, write_v

    def fingerprint(self, addr):
        """Score how much `addr` looks like SSL_read/SSL_write; capture error helper."""
        ins = self.window(addr, 64)
        frame = 0; field_load = False; neg1 = False; helpers = []; blc = 0
        for k, x in enumerate(ins):
            m, op = x.mnemonic, x.op_str
            if k == 0 and m == "sub" and op.startswith("sp, sp"):
                mm = re.search(r"#(0x[0-9a-f]+|\d+)", op)
                if mm: frame = int(mm.group(1), 16) if mm.group(1).startswith("0x") else int(mm.group(1))
            if m == "ldr" and "[x0" in op and k < 14:
                field_load = True
            if m in ("mov", "movn") and ("-1" in op or "0xffffffff" in op):
                neg1 = True
            if m == "bl":
                blc += 1
                for back in (1, 2):
                    if k - back >= 0:
                        pm = ins[k - back]
                        mm = re.match(r"^w\d+, #?(0x[0-9a-f]+|\d+)$", pm.op_str) if pm.mnemonic == "mov" else None
                        if mm:
                            val = int(mm.group(1), 16) if mm.group(1).startswith("0x") else int(mm.group(1))
                            if 0x20 <= val <= 0x6000:
                                tm = re.match(r"^#?(0x[0-9a-f]+)$", op)
                                if tm: helpers.append((int(tm.group(1), 16), val))
                            break
            if m == "ret":
                break
        score = (2 if field_load else 0) + (3 if helpers else 0) + (1 if neg1 else 0)
        return dict(score=score, frame=frame, helpers=helpers, blc=blc,
                    field_load=field_load, neg1=neg1)

    def find(self):
        anchors = find_anchor_vaddrs(self.elf, ANCHOR_FILTER)
        if not anchors:
            sys.exit("Anchor 'secure_socket_filter.cc' not found — not a Flutter engine, or non-arm64 build.")
        refs, bl_edges = self.sweep(anchors)
        filter_funcs = set(f for f in (self.enclosing(a) for a in refs) if f)
        if not filter_funcs:
            sys.exit("Could not locate the Dart TLS filter functions.")

        # Primary signal: how the Dart filter consumes each callee's int result.
        # Empirically: result clamped to >=0 (bic asr#31) follows SSL_write;
        #              result sign-tested (tbz #31) follows SSL_read.
        clamp_v, sign_v = self.caller_votes(filter_funcs)

        def best(votes, other):
            """pick the SSL data fn from voted targets: prefer clear winner with SSL shape."""
            ranked = []
            for tgt, v in votes.items():
                fp = self.fingerprint(tgt)
                ranked.append((v - other.get(tgt, 0), fp["score"], tgt, fp))
            ranked.sort(reverse=True)
            return ranked[0] if ranked else None

        wb_, rb_ = best(clamp_v, sign_v), best(sign_v, clamp_v)
        if not rb_ or not wb_:
            sys.exit("Could not classify SSL_read/SSL_write from caller result-handling.")
        write, write_fp = wb_[2], wb_[3]
        read, read_fp = rb_[2], rb_[3]

        if read == write:  # tie-break by structure (write = bigger frame / handshake loop)
            cand = sorted(set(clamp_v) | set(sign_v),
                          key=lambda t: -self.fingerprint(t)["score"])[:2]
            if len(cand) >= 2:
                a, b = cand[0], cand[1]
                fa, fb = self.fingerprint(a), self.fingerprint(b)
                write, write_fp = (a, fa) if (fa["frame"], fa["blc"]) >= (fb["frame"], fb["blc"]) else (b, fb)
                read, read_fp = (b, fb) if write == a else (a, fa)

        wv, rv = clamp_v.get(write, 0), sign_v.get(read, 0)
        confidence = "high" if (rv > 0 and wv > 0 and read != write) else "medium"
        evidence = {
            "filter_funcs": sorted(filter_funcs),
            "read_votes": rv, "write_votes": wv,
            "read_fp": read_fp, "write_fp": write_fp,
        }
        return write, read, confidence, evidence

# ----------------- generation -----------------
def generate(template_text, write_off, read_off, version):
    js = template_text
    js, n1 = re.subn(r"const\s+SSL_WRITE_OFF\s*=\s*0x[0-9a-fA-F]+\s*;",
                     f"const SSL_WRITE_OFF = 0x{write_off:x};", js, count=1)
    js, n2 = re.subn(r"const\s+SSL_READ_OFF\s*=\s*0x[0-9a-fA-F]+\s*;",
                     f"const SSL_READ_OFF  = 0x{read_off:x};", js, count=1)
    if not (n1 and n2):
        sys.exit("Template missing SSL_WRITE_OFF / SSL_READ_OFF constants to patch.")
    banner = (f"// AUTO-GENERATED by flutter_http_monitor.py\n"
              f"// Flutter/engine: {version}\n"
              f"// SSL_write +0x{write_off:x}   SSL_read +0x{read_off:x}\n\n")
    return banner + js

# ----------------- main -----------------
def main():
    ap = argparse.ArgumentParser(description="Auto-find SSL_read/SSL_write in libflutter.so and emit a Frida monitor.")
    ap.add_argument("input", nargs="?", help="libflutter.so or an .apk")
    ap.add_argument("-o", "--output", help="output Frida JS (default: flutter-http-monitor.generated.js)")
    ap.add_argument("--template", default=None, help="external template JS (default: built-in embedded template)")
    ap.add_argument("--print-only", action="store_true", help="only print offsets; do not generate JS")
    ap.add_argument("--embed", metavar="TEMPLATE.js", help="(dev) bake a template JS into this script and exit")
    args = ap.parse_args()

    if args.embed:
        embed_template(args.embed)
        return
    if not args.input:
        ap.error("input (libflutter.so or .apk) is required")

    with load_libflutter(args.input) as f:
        raw = f.read(); f.seek(0)
        elf = ELFFile(f)
        if elf.get_machine_arch() != "AArch64":
            sys.exit(f"Only arm64 (AArch64) is supported; got {elf.get_machine_arch()}.")
        version = detect_version(raw)
        print(f"[*] Flutter/engine: {version}")
        write_off, read_off, conf, ev = Analyzer(elf).find()

    print(f"[+] SSL_write @ +0x{write_off:x}   (req,  read buffer on ENTER)")
    print(f"[+] SSL_read  @ +0x{read_off:x}   (resp, read buffer on LEAVE)")
    print(f"[+] confidence: {conf}   clamp-votes read={ev['read_votes']} write={ev['write_votes']}")
    print(f"    filter funcs: {', '.join(hex(f) for f in ev['filter_funcs'])}")
    if conf != "high":
        print("    [!] medium confidence — verify at runtime: a REQUEST block must show an")
        print("        outgoing 'GET/POST ... HTTP/1.1'. If req/resp look swapped, swap the offsets.")

    if args.print_only:
        return
    template_text = load_template(args.template)
    out = args.output or "flutter-http-monitor.generated.js"
    open(out, "w", encoding="utf-8").write(generate(template_text, write_off, read_off, version))
    print(f"[+] wrote {out}")
    print(f"    run:  frida -U -f <package> -l {out}")

if __name__ == "__main__":
    main()