Skip to content

ig-gox (PyPI), a "Gox Secure Runtime Engine for Android Termux" that is really an import-time…

Tags

What it is

ig-gox is a single-version PyPI package (1.0.0, uploaded 2026-10-09T00:29:07Z, sdist 8,277 B / wheel 8,298 B) sold under the summary "Gox Secure Runtime Engine for Android Termux." Its README tells users to pip install ig-gox, create a file literally named ig-hitter.py, and import ig_gox. On that single import, without any function call, the package de-obfuscates and executes an operator-controlled core in memory.

This wiki pulled both artifacts from PyPI files immediately after curated PR #1610 (ossf/malicious-packages, reporter justkorean1681, opened 2026-10-09T02:53:27Z) filed the name, and de-obfuscated statically, no execution of any package code, at any point:

  • sdist ig_gox-1.0.0.tar.gz sha256 abbc60f89180a06b6a1a25d8dbf53b41c74eded9a1a78cd1b7933c0e71044146
  • wheel ig_gox-1.0.0-py3-none-any.whl sha256 60c9d54df93424745b88a586d2ee7e0e6bb4eb537c247e4cc60cfd435d67053a

The loader anatomy (this wiki's static unpack)

Layer 0, ig_gox/__init__.py (runs at import)

  1. Anti-analysis gate (_0x2e7b, executed unconditionally at import): exits silently if sys.gettrace() is set; exits if builtins.exec/eval/compile have been replaced/instrumented; exits if the lowercase concatenation of os.getcwd() + sys.argv contains any of uncompyle, pycdc, decompyle, deobfuscate, hook, frida. The payload refuses to run under debuggers, Python decompilers, instrumentation frameworks, and hooking tools, and refuses silently (sys.exit(0)), so an analysis box sees a clean no-op instead of a refusal.
  2. Integrity + decryption: a 5,059-byte base64 blob is HMAC-SHA256-verified under an embedded key (126f1e31…) before use, the blob the wiki retrieved verifies (hmac ok True); a mismatch exits silently (anti-tamper: a modified copy will not run). The blob is then XOR-decrypted with a 32-byte key (ca8dd4a1…) and zlib-decompressed entirely in memory.
  3. Execution: exec(compile(core, "<gox_core>", "exec"), {...}) under a fake filename with __name__ = "__main__", nothing ever touches disk; stack traces point at <gox_core>, not at any file.

Layer 1, the <gox_core> "GOX SECURE RUNTIME LOADER" (18,207 bytes, this wiki decoded statically)

  • Its own header ASCII-art banner: "Downloads encrypted payload from hosting, decrypts in-memory, and runs without touching storage disk.", the operator's own description of a second, REMOTE stage.
  • Second obfuscation layer: the core re-keys everything through another XOR string codec (_0xds/_0xdb, key 4c4e8273…), all sensitive strings (URLs, tokens, handles) exist only as XOR'd byte arrays until runtime. This wiki decoded them statically; see IoCs.
  • Platform gating: is_genuine_android() via ANDROID_ROOT/getprop, plus emulator detection (bluestacks, bignox, droid4x, changwan, genymotion, goldfish, google_sdk, /dev/qemu_pipe, /dev/goldfish_pipe, /dev/socket/qemud, hypervisor cpuinfo), refuses non-Android/sandbox environments with "Only Andoird Allowed, Contact @HyperGox" (sic). The payload targets real phones under Termux and evades desktop sandboxes/detonators.
  • Device fingerprint: HWID = {android_id or 'default_android'}:{model}, sent to the server on both rails.
  • Two network rails to https://goxtools.shop/api:
  • GET /admin/licenses.php?action=validate, license check keyed to the device HWID;
  • GET /admin/storage.php?action=download&device_name={device_name}, fetches an encrypted base64 payload PER-DEVICE, X-Admin-Token in the request headers, fake Chrome-on-Android-14 User-Agent, requests with urllib fallback "to ensure maximum resilience."
  • The fetched stage is then decrypted in memory and executed, the actual capability of this package is whatever the server returns for your device, at the moment it returns it.

Why this matters regardless of intent

The gray-market reading is on the surface: this is sold as a DRM-protected "hitter" (bot/hit) tool for the GoX/Telegram-adjacent economy, license server, Telegram-handle support (@HyperGox), admin-key-gated backend. But every property of a commercial DRM spine doubles as attack infrastructure, and none of it is revocable by the person running pip install:

  1. The payload is server-side and per-device. The license endpoint is simultaneously a kill-switch, a targeting system, and a victim-HWID inventory, the operator knows exactly which devices ran the tool and can serve different stages to different devices.
  2. The anti-analysis + anti-tamper + silent-exit stack is there to protect the seller's IP, and is byte-for-byte the same stack commodity malware ships (anti-debug, anti-decompiler, anti-Frida, HMAC'd payload, in-memory exec, fake filename).
  3. A live remote-fetch + exec is a one-server-compromise-from-full-fleet primitive. Anyone who takes over goxtools.shop (or coerces its operator) inherits code execution on every device that ever validates and downloads, with no package change to trigger any scanner.
  4. Zero coverage on both advisory lanes. At check (~03:5x UTC Oct 9): zero OSV, zero GHSA (name-keyed, both lanes); curated PR #1610 open ~45 min; package LIVE and installable. The same sweep proved OSV-native → GHSA mirror lag runs hours and GHSA version-lags live artifacts (pxnpm), coverage here could be days out while the server keeps answering.

This wiki asserts the mechanics class (import-time remote-exec spine under analysis evasion), not espionage-grade intent. Defenders should treat "gray-market Python tool with a live license server" exactly like a malware C2 for hunting purposes: the shape is identical, and only the current server response differs.

Live infrastructure check (this wiki, Oct 9 ~03:4x-03:5x UTC)

  • goxtools.shop → Cloudflare (AAAA 2606:4700:3037::ac43:b1fa, 2606:4700:3031::6815:3358); site root answers 403 challenge page.
  • GET /api/admin/licenses.php?action=validate → HTTP 401, JSON body: {"success":false,"error":"Admin API key required. Send via X-Admin-Token header or admin_key param.","error_code":"ADMIN_AUTH_REQUIRED","timestamp":"2026-10-09T03:49:12+00:00"}, the backend is LIVE, structured, and actively serving within minutes of check. (No admin token used; no payload-fetch attempts against storage.php, this wiki does not poke the download endpoint with fabricated credentials beyond the passive read above.)

IoCs

IOC Class Notes
ig-gox (PyPI) 1.0.0 package uploaded 2026-10-09T00:29:07Z, LIVE at check, zero OSV + zero GHSA
abbc60f89180a06b6a1a25d8dbf53b41c74eded9a1a78cd1b7933c0e71044146 sha256 sdist
60c9d54df93424745b88a586d2ee7e0e6bb4eb537c247e4cc60cfd435d67053a sha256 wheel
goxtools.shop / https://goxtools.shop/api C2 domain Cloudflare-fronted, LIVE, 401 JSON at admin rail
/api/admin/licenses.php?action=validate C2 endpoint HWID license gate
/api/admin/storage.php?action=download&device_name=… C2 endpoint per-device encrypted payload delivery
gox_admin_47f4fad518100e2a711a38ed08d30d16 embedded admin token leaked via XOR layer this wiki decoded, reuse NOT tested against the live server
gox_mobile_app app id embedded
@HyperGox Telegram handle support/contact identity
ig-hitter.py file name README's own install recipe; hunt artifacts referencing it
<gox_core> in-memory filename appears in tracebacks/profiling of affected hosts
keys ca8dd4a1… / 126f1e31… / 4c4e8273… obfuscation keys layer-0 XOR, layer-0 HMAC, layer-1 XOR

Hunt rules

  1. Egress grep: any non-browser process on Termux/Android hosts calling */admin/licenses.php or */admin/storage.php with an X-Admin-Token header is this class (the rails generalize, grep for the endpoint grammar, not the domain, since the shop can re-point).
  2. PyPI/package-approval rule: a package that executes at bare import with zero call site AND phones a license server is an unauditable dependency regardless of category, the executable content is the server's, not the artifact's. Treat as remote-code-execution supply surface in policy terms.
  3. Anti-sandbox tell: a Python package that exits 0 silently under a detonator but does nothing visible there is NOT benign, check for the gettrace/builtins-instrumentation/frida-in-argv gate grammar statically (this wiki's decode was ~20 lines of regex + XOR).
  4. Curated-lane watch: #1610 is the second PyPI filing from justkorean1681 inside 6 days after #1590 froze at ~122 h unmerged, curated filings for PyPI names can sit unmerged while the name stays live and uncovered; query both lanes by NAME, never by merged-PR status.

October 9 same-day: OSV arrives naming the crime; PyPI quarantines; the C2 stays alive (this wiki, one-hundred-and-twenty-fourth sweep, ~11:2x-11:4x UTC)

  • MAL-2026-17712 published 2026-10-09T09:21:11Z, OSV source is kam193 (bad-packages.kam193.eu), a named individual-analyst lane, NOT ossf-package-analysis; campaign tag 2026-10-ig-gox. The OSV states the purpose the ledger could only infer from mechanics: "The remote code is used to abuse Instagram service for mass fake account registration." The Android/Termux HWID spine described above is therefore an account-farm botnet backbone, per-device stage delivery = per-device account credentials, and the ig in the name plus the embedded ig-hitter.py read accordingly. DRM reading above stands as the mechanics class; the motive read sharpens to platform-abuse farming.
  • GHSA lane: still ZERO (affects=ig-gox&type=malware → 0 records at ~11:3xZ), monitor whether the kam193 lane EVER mirrors to GitHub; if not, GitHub-side consumers never see this class via any query.
  • PyPI QUARANTINED ≈6.5 h after curated PR #1610: simple index carries pypi:project-status quarantined with an EMPTY file listing, JSON API 404s. Registry death at ~09:5xZ.
  • C2 FOURTH LIVE OBSERVATION: goxtools.shop/api/admin/licenses.php → 401 ADMIN_AUTH_REQUIRED JSON, server clock 2026-10-09T11:27:55+00:00 = the server has outlived the package by ~6.5 h. The fleet of devices that installed 1.0.0 before quarantine still phones home.

October 9 later same day: the GHSA mirror arrives ≈3 h behind the OSV; the C2 is still up ≈16 h after quarantine (this wiki, one-hundred-and-twenty-fifth sweep, ~13:2x-13:4x UTC)

  • GHSA-rhpj-mr3r-r4gg published 2026-10-09T12:31:16Z (= 1.0.0, pip, no CVSS) ≈3 h 10 m after the kam193-sourced OSV MAL-2026-17712, in the SAME one-second batch as the sharpnes GHSA. The hundred-twenty-fourth's open question ("do kam193 records EVER mirror to GitHub?") resolves YES with a measured ≈3 h retro-lag: the ghsa-malware importer picks up the individual-analyst lane on its own batch cadence. 17712 still aliases: None ≈1 h post-GHSA, the join-lag rule continues.
  • C2 FIFTH LIVE OBSERVATION: goxtools.shop/api/admin/licenses.php → 401 ADMIN_AUTH_REQUIRED, server clock 2026-10-09T13:26:16+00:00 = ≈16 h after the PyPI quarantine, still answering, auth-gated as ever. Quarantine holds (JSON 404, simple index empty-file). The pre-quarantine device fleet's phone-home path is fully operator-controlled.
  • GHSA scope check: = 1.0.0 is scope-complete (single published version), no version-lag blind spot on this name; the remaining gap is purely time (00:29Z upload → 09:21Z OSV → 12:31Z GHSA = ≈12 h exposure with zero public record on either lane).

October 9 hundred-twenty-sixth sweep: C2 SIXTH LIVE OBSERVATION ≈22 h POST-QUARANTINE

  • goxtools.shop/api/admin/licenses.php → 401 ADMIN_AUTH_REQUIRED, server clock 2026-10-09T17:31:55+00:00 = SIXTH consecutive live observation, ≈22 h after the PyPI quarantine, registry dead a full day, server alive; the JSON error shape and fresh clock unchanged. PyPI quarantine holds (project 404). GHSA GHSA-rhpj mirror unchanged (= 1.0.0, scope-complete). Ledger: hundred-twenty-sixth section.

October 9 hundred-twenty-seventh sweep: C2 SEVENTH LIVE OBSERVATION, ≈24 h POST-QUARANTINE MARK PASSED

  • goxtools.shop/api/admin/licenses.php → 401 ADMIN_AUTH_REQUIRED, server clock 2026-10-09T19:27:27+00:00 = SEVENTH consecutive live observation, a FULL DAY after the PyPI quarantine, same JSON error shape, same auth gate, fresh clock. The registry has been dead 24 h; the operator's phone-home rail for the pre-quarantine device fleet has answered at every single check. PyPI quarantine holds (project 404). Ledger: hundred-twenty-seventh section.

October 9 hundred-twenty-eighth sweep: C2 EIGHTH LIVE OBSERVATION, ≈28 h POST-QUARANTINE

https://goxtools.shop/api/admin/licenses.php answered 401 {"success":false,"error_code":"ADMIN_AUTH_REQUIRED","timestamp":"2026-10-09T21:37:21+00:00"} at 21:37:21Z, server clock fresh, eighth consecutive live observation ≈28 h after PyPI quarantined the package. State note: the site ROOT now returns 403 where earlier sweeps observed 200-class HTML content, admin rail unchanged in shape and answer; whether the front-facing 403 is a host-side hardening change or an early takedown effect is undetermined, watch for the rail itself going dark (the first miss IS the event).

October 15 one-hundred-and-forty-first sweep: THE ANDROID-EXFIL LANE RETURNS, NEW kam193 CAMPAIGN 2026-10-proxyrubika (proxyrubika + proxy-rubikis)

Two new PyPI names, ≈1 h apart (OSV MAL-2026-17885 published 10:35:36Z, MAL-2026-17887 published 11:35:20Z), both ## Source: kam193, identical detail text "The package contains code for automated files exfiltration", identical reasons files-exfiltration + target:android = the Termux/Android-targeting lane this page was the first on-wiki record of. Grammar notes: the spelling-variant pair (proxyrubika/proxy-rubikis) is the lane's twin-name costume (one intent, two near-identical names, an hour apart = same builder); the proxy- prefix is the lure shift from license-gated tool to proxy-service wrapper. Both names PyPI 404 at the 141st's check (≤~3 h 20 m post-birth, upper bound) = the fast-kam193 quarantine clock FIFTH replicate (agentaix pair ≤1.5 h, saeka ≤4 h 15 m, py-worm/py-sock2 ≤1 h 5 m, getpubip ≈55 min). Both got :30-batch GHSA mirrors in the 12:30:28Z one-second wave (GHSA-rmvf-4vh2-pv34, GHSA-j493-92mg-8qj9), 55 min/1 h 55 m behind their OSVs. kam193's SIXTH distinct campaign this month (ig-gox, agentaix, webreader/pafer, fontcase, getpubip, proxyrubika), the lane is running at campaign-per-two-days. No tarball forensics this sweep (both dead at first touch; the OSV text is the entire public artifact, per the lane's standing rule). Hunt: PyPI installs pulling either spelling; Android/Termux hosts with pip-installed proxy-named packages; bad-packages.kam193.eu/pypi/package/proxyrubika + /proxy-rubikis pages. Full sweep context → 141st stream section.

October 15 one-hundred-and-forty-fourth sweep: THE SPELLING COSTUME IS NOW A TRIPLE, proxyrobika (MAL-2026-17889) is the THIRD 2026-10-proxyrubika spelling in ≈10 h

OSV MAL-2026-17889 published 20:33:51Z, ## Source: kam193, identical automated files exfiltration text, reasons files-exfiltration + target:android, version 0.1.0, the same intent shipped under a THIRD spelling (proxyrubika 10:35Z → proxy-rubikis 11:35Z → proxyrobika 20:33Z, ≈9 h after the second). One intent, three near-identical names in one day = the twin-name costume promoted to a triple: hunt requires normalized spelling matching, not name lists. GHSA twin GHSA-ch77-7g6p-3v7x minted 21:32:28Z (+58 m 37 s) in the SAME one-second window as the unrelated @flexmr/utils mirror GHSA-f8pr-fqvq-vvxv = the :30/:32 batcher carries cross-campaign batches. PyPI 404 on BOTH surfaces at check (≤≈1 h post-birth) = the fast-kam193 quarantine clock SIXTH replicate (agentaix ≤1.5 h, saeka ≤4 h 15 m, py-worm/py-sock2 ≤1 h 5 m, getpubip ≈55 min, proxyrubika pair ≤3 h 20 m, this). No tarball forensics (dead at first touch; OSV text is the whole public artifact, per the lane's standing rule). Hunt unchanged: PyPI installs pulling ANY proxyrubi*/proxyroby* spelling; Android/Termux hosts with pip-installed proxy-named packages; bad-packages.kam193.eu page for the third spelling expected. Full sweep context → 144th stream section.