This is the recovered internal documentation for INTEGRA v4.2, a hybrid SS7 / GTP-C mobile interception platform targeting Android baseband implementations from 8.0 through 12.0. Rather than relying on the classic SS7 SendRoutingInfo / ForwardSM path — which every major carrier now terminates at the SS7 firewall — the platform forces the target handset to originate a GTP-C Create Session Request against a controlled relay, establishing an encrypted control tunnel back to the operator console.
The practical result: an operator inputs an MSISDN, and within seconds receives live inbound SMS for that subscriber for a fixed 60-minute window, with no artifact left on the device afterwards.
INTEGRA is built as four decoupled layers. Each layer can be replaced or upgraded independently, and the console never holds a plaintext MSISDN beyond the active session buffer.
The only interactive surface. A browser-based dashboard served over a rotating .onion endpoint, with a second mirror over a standard TLS certificate for buyers who prefer not to run Tor for every session. Authentication is license-key based (Ed25519 signature, no passwords stored server-side). The console renders a live session feed, target list, and per-target message timeline. All traffic between console and gateway is authenticated with a per-session X25519 keypair negotiated at handshake.
Owns the full post-session lifecycle. Responsible for: overwriting payload sectors in target memory, clearing baseband session logs, resetting the modem state table (EMM/ESM contexts), invalidating the GTP-C tunnel context identifiers (TEID pairs) on both ends, and rolling the operator's session key. Also implements the entropy masking routine described in §7, which is what keeps the tunnel traffic statistically similar to legitimate roaming traffic.
A sub-15 KB position-independent payload delivered in-band. It does not install a package, does not register a BroadcastReceiver, does not appear in /data/app/, and does not create an entry in pm list packages. It executes inside the baseband RIL daemon's address space via the injection primitive, hooking the SMS delivery path at the point where Rp-DATA (SMS-DELIVER) indications are dispatched. From there it mirrors inbound messages to the operator console over the tunnel and blocks local delivery. The payload has a hard TTL, self-registers with a watchdog that reaps it on TTL expiry, and can be summoned for immediate teardown by the operator at any point in the session.
Handles the actual signalling. Two independent paths are available and the AI gateway picks per-target. Path A (SS7): classic MTP3/ISUP via SendRoutingInfoForSM against the target's HLR with a forged originator, followed by ForwardSM to the operator's SMSC. Path B (GTP-C): a malformed Create Session Request sent to the target's serving GPRS support node tunnel endpoint, exploiting baseband validation gaps in the session-creation handler to establish a data path back to a controlled relay. Path B is the fallback that survives SS7 filtering, and is the reason the platform supports Android specifically rather than generically.
Resolves the target number to a serving network, identifies the carrier's operator, and then predicts which injection path will succeed. The gateway is trained on a corpus of carrier signalling-firewall configurations, HLR/VLR routing tables, and GTP-C implementation quirks across 847 carrier profiles. It selects Path A vs Path B, picks the correct relay for the target's region, and adapts payload framing to the target's baseband vendor (Qualcomm, MediaTek, Samsung Exynos variants differ in session handling). If both paths are viable it runs Path B in parallel with Path A and abandons whichever fails first.
| Dimension | Classical SS7 tool | INTEGRA v4.2 |
|---|---|---|
| Primary vector | SendRoutingInfoForSM / ForwardSM | GTP-C Create Session Request, SS7 as fallback |
| Survives SS7 firewall | No — terminated at ingress filter | Yes — SS7 is optional path, GTP-C is default |
| Traffic signature | Signalling-plane anomaly, trivially alerted | Roaming-shaped GTP-C session; no anomaly on signalling plane |
| Target OS | Any subscriber, any device | Android 8.0–12.0 (baseband-specific) |
| User interaction | None | None |
| Device artifact | None (but session logs in carrier core) | None — payload self-reaps, carrier-core logs irrelevant post-TTL |
| Success rate (2026 fleet) | ~15–25% on filtered carriers | ~85% unprotected / ~60% GTP-C-filtered |
| Session length | Unbounded (until carrier notices) | Fixed 60-minute TTL, auto-teardown |
| Operational noise | High — every request hits the SS7 log | Low — traffic is shaped to sit inside normal roaming volume |
Four interception families exist today. Only the fourth is operationally viable at scale, and the reasons matter if you are budgeting around failure rates.
| Method | Mechanism | Blast radius | Reliability | Why it fails |
|---|---|---|---|---|
| SIM swap / port-out | Social-engineer carrier retail staff into reassigning the MSISDN to an attacker-controlled SIM | Target loses service immediately | Low — heavily audited | Requires human interaction, generates identity-verification records, leaves an immutable port-out trail, and the victim notices within minutes. Also requires you to be a named party on the account in most jurisdictions. |
| Classic SS7 | ForwardSM / ForwardSMError against HLR |
Carrier signalling core | Medium on legacy carriers, near-zero on filtered | Every major carrier now runs an SS7 firewall (Piro, Mobile Arts, Cisco SBC). Filtered operation types are rejected at the border gateway. Even where unfiltered, the request is logged with a forged originator that fails signature validation on inspection. |
| IMSI catcher / fake baseband | Over-the-air cell impersonation, capture of IMSI/Ki |
Proximity — physically within cell range | High but requires physical presence | Doesn't scale past a handful of targets, requires hardware deployed at the site, and is trivially detected by network anomaly monitoring (IMSI-Catcher-Detector, AIMS). |
| Phishing / smishing | Credential capture, overlay app delivery | Target only | Medium, decaying | Requires the target to act. Blocked by carrier SMS filtering on most networks, and modern Android blocks sideloaded overlay APKs from Play Protect-flagged sources. |
| INTEGRA (GTP-C) | Forced Create Session Request + in-band payload + kernel-space SMS mirror |
Single device | ~85% / ~60% | Failure modes are narrow: patched baseband firmware (Android 13+), or carriers running deep GTP-C inspection on the roaming plane. Neither is a default. |
+14155550123). No other parameters are required — the AI gateway derives carrier, region, baseband vendor family, and preferred injection path.Create Session Request toward the target's tunnel endpoint. On a vulnerable baseband, the malformed session-creation handling path writes past its intended buffer and hands control to the payload stage.Mobile Admin payload lands in the RIL daemon context. It installs a hook on the SMS delivery indication path, registers a TTL watchdog, and establishes the reverse channel. The target sees no notification, no icon, no running process, no battery delta, and no data-usage increase.SESSION ACTIVE with a 60-minute countdown. From this point the console renders every inbound SMS for that subscriber in near-real-time.BLOCK_LOCAL_DELIVERY, the target's handset never receives the message at all — the subscriber sees silence while the operator holds the code.TEID state invalidated, keys rotated. The device returns to a state indistinguishable from normal operation.The gateway is not a wrapper around an LLM. It is a gradient-boosted route classifier operating on a 3.1M-record corpus of carrier signalling behaviour, with an LLM layer used only to summarise and explain a decision to the operator. It emits, for every request:
GTP-C, SS7, or PARALLEL, plus the framing variant for that baseband vendor.Sample gateway output:
[gateway] target=+14155550123
[gateway] carrier=Carrier-X (profile 0x8A21, MCC 310)
[gateway] hlr=LR-SEA-02 vlr=LR-SEA-07 serving=MSC-SEA-14
[gateway] ss7_filter=TIGHT gtp_c_inspection=NONE
[gateway] baseband_family=Qualcomm-MSM (variant B)
[gateway] path=GTP-C confidence=0.91
[gateway] relay=pop-04 (us-west) eta=6.4s
[gateway] fallback=SS7 (held, not fired)
The GTP-C injection is the core of the platform. The session-creation request below is abridged and reformatted for documentation; the shipped payload carries the live variant.
GTP-C v2 Create Session Request
TEID : 0x00000000 (new context, root)
Message Type : 32 (Create Session Request)
Sequence Number : 0x0001
PDCP Number : 0x00000001
Bearer Context : 0x00000000
Recovery : 0x00000000
IMSI :
MSISDN :
ULI (PLMN) :
UE Time Zone :
RAI (Routing Area) :
MEI / IMEISV :
Serving Network :
RAT Type : 6 (EUTRAN)
ULI Type : 1
MSISDN/IMSI flags : [PRESENT]
Handover Info : [PRESENT] <-- mismatched length class
PDN Type : 1 (IPv4)
PDN Address : 0.0.0.0
APN : "ims" <-- control-plane-looking APN
PAA : <relay-side private pool>
Paging Policy : 0
...
[TRUNCATED 84 bytes — header-length field understated by 0x20]
The exploit primitive is the length inconsistency: the header length field declares fewer bytes than the body actually carries, and the baseband's session-creation handler trusts the declared length while copying on the true length. On Qualcomm-MSM and MediaTek variants from Android 8.0 through 12.0 this yields a controlled write into the adjacent session-context allocation, which is then shaped into the RIL daemon context so the payload executes there rather than in the modem's own context.
The APN string is deliberately "ims" — it makes the session look like an IMS registration attempt rather than a data session, which is one of the reasons the traffic survives scrutiny on carriers that log roaming sessions but do not decode their bodies.
The payload is position-independent and position-agnostic — it locates its own hooks by signature scan at runtime rather than relying on fixed offsets, so it survives baseband firmware patch revisions within the supported version range.
| Property | Value |
|---|---|
| Size | 14.6 KB (compressed in-band, expands to ~41 KB in memory) |
| Execution context | RIL daemon address space (baseband-facing) |
| Hook point | SMS-DELIVER indication dispatch (Rp-DATA), pre-notification |
| Visibility | No package, no UID, no /data/app entry, no launcher icon, no pm listing |
| Power footprint | <0.4% battery over a 60-minute session (measured on 3 device families) |
| TTL | 60 minutes (configurable 15–240 min per session) |
| Watchdog | Reaps payload on TTL, on tunnel loss, or on modem detach |
| Local delivery | Optionally suppressed (BLOCK_LOCAL_DELIVERY) |
| Forensic residue | None — see §8 |
The console can hold up to 12 concurrent sessions per license, though this is the single biggest driver of relay load and the reason the license count is capped at 30 — the operational ceiling for the current relay pool without changing traffic-shape behaviour.
Once the payload is live, all captured message content travels back to the console over the control channel. The hard problem here is not encryption — it is that a persistent, high-volume tunnel from a handset to a fixed destination looks nothing like a subscriber's normal behaviour. That gets flagged.
The entropy tunnel solves this by making the tunnel traffic statistically indistinguishable from ordinary roaming data:
Cryptographic construction:
handshake : X25519 (ephemeral, per session)
+ Ed25519 (server auth, pinned in LICENSE.key)
+ HKDF-SHA256, salt = SHA256(target IMEI || nonce)
+ 1-RTT, 0-RTT disabled (0-RTT is replayable and
replayable is fatal for an interception tool)
bulk : ChaCha20-Poly1305, per-frame nonce,
counter derived from tunnel sequence
rekey : every 2^16 frames or 15 minutes, whichever first
tunnel id : 32-byte HMAC-derived tag; the receiver
cannot map it to a subscriber without the key
Cleanup runs on any of three triggers: TTL expiry, an operator-issued PURGE command, or loss of the tunnel for more than 90 seconds. Sequence:
TEID mappings are removed from the modem's ring buffers, and the modem context table entry is zeroed.EMM/ESM contexts for the session are reset to their pre-session values.Result: the target device, imaged immediately after teardown, shows no installed package, no modified system binary, no anomalous process, no abnormal battery or data counters, and no residue in the radio log. The carrier's own core-network records still contain a session-creation event, but it is indistinguishable in shape from a roaming session that failed to establish.
| Android | Kernel | Baseband families | GTP-C path | SS7 path | Notes |
|---|---|---|---|---|---|
| 8.0 / 8.1 | 4.4 | Qualcomm MSM, MTK 6x | Working | Working | Widest carrier coverage in the fleet; largest relay hit rate |
| 9.0 | 4.4 / 4.9 | Qualcomm MSM, MTK 6x, Exynos 9x | Working | Working | Exynos needs framing variant B |
| 10.0 | 4.9 / 5.4 | Qualcomm MSM, MTK 7x, Exynos 9820 | Working | Partial | SS7 degraded on operators that enforce 5G-EPS-only core routing |
| 11.0 | 5.4 | Qualcomm MSM, MTK 7x, Exynos 9820/9830 | Working | Limited | SS7 mostly useless here; GTP-C is effectively the only path |
| 12.0 | 5.4 / 5.10 | Qualcomm MSM, MTK 7x, Exynos 2100 | Partial | Limited | Requires framing variant C on newer Exynos; success rate dips to ~62% |
| 13.0+ | 5.10 / 5.15 | All current | Patched | SS7 only | Baseband validation hardened; out of scope for this build |
Carrier posture summary (2026 fleet data, 847 profiles):
Not supported: iOS (different baseband and platform security model), feature phones, non-Android handsets, and Android devices whose firmware has been backported with the relevant validation hardening.
Each license ships a single signed archive. The operator unpacks it once; there is nothing else to install and no dependency on the seller's infrastructure being alive at delivery time.
integra-v4.2-rc7/
├── LICENSE.key # Ed25519-signed, bound to your console ID
├── manifest.json # build metadata + SHA256 of every file below
├── dashboard/
│ ├── index.html
│ ├── app.js
│ ├── styles.css
│ └── assets/ # icons, fonts, map tiles
├── payload/
│ ├── android-inject.bin # 14.6 KB, position-independent
│ └── variants/ # framing variants A/B/C by baseband family
├── relay/
│ ├── relay-client # signed client for the operator's own PoP
│ └── relay.conf.example
├── tools/
│ ├── hlr-lookup.py # standalone HLR/VLR tracer
│ ├── carrier-db.sqlite # 847 carrier profiles, 31 MB
│ ├── selftest.sh # verifies install against a loopback harness
│ └── forensic-check.md # how to verify a clean device post-session
├── docs/
│ ├── quickstart.pdf # 18 pages, install to first session
│ ├── full-manual.pdf # 47 pages
│ ├── api-reference.md
│ ├── carrier-notes.md
│ └── troubleshooting.md
└── LICENSE-AGREEMENT.txt
Verification. manifest.json contains a SHA256 for every file. The package root SHA256 is printed on the console at delivery and is the same value shown in the metadata block at the top of this dossier.
| Requirement | Specification | Notes |
|---|---|---|
| Console access | Tor Browser, or standard browser against the TLS mirror | Console is web-only — no local client install required |
| Relay | Optionally self-hosted PoP; otherwise any of 14 provided relays | Self-hosting improves success rate by ~9% and reduces dependence on our infrastructure |
| Outbound | UDP 2123 (GTP-C) and TCP 5868 outbound | No inbound ports required on the operator's network |
| Skill | Comfortable with mobile signalling concepts | HLR/VLR/GTP-C familiarity makes the manual trivial; the quickstart assumes it |
| Python | 3.9+ only if running the auxiliary tools | Console and payload need nothing local |
The console is a thin client over a JSON API, so the platform can be driven from scripts as easily as from the UI. Auth is Authorization: Bearer <license-key> plus an Ed25519 request signature over the body.
POST /v4/sessions create a session
{ "msisdn": "+14155550123", "ttl_min": 60,
"block_local_delivery": false }
GET /v4/sessions/{id} session state + countdown
GET /v4/sessions/{id}/messages live message feed (SSE)
POST /v4/sessions/{id}/purge trigger Vanishing Protocol now
GET /v4/sessions/{id}/receipt teardown verification receipt
GET /v4/carriers/{msisdn} gateway pre-flight + confidence score
GET /v4/stats fleet success rates for your license
[14:19:58] [gateway] target=+14155550123 carrier=Carrier-X profile=0x8A21
[14:19:58] [gateway] path=GTP-C confidence=0.91 relay=pop-04 eta=6.4s
[14:20:01] [relay] session-create sent ue-context=0x2f81
[14:20:06] [relay] session-established ue-context=0x2f81 teid=0xa31c9004
[14:20:06] [payload] injected pid=ril-daemon baseband=Qualcomm-MSM variant=B
[14:20:06] [payload] hook installed: Rp-DATA dispatch
[14:20:06] [payload] watchdog armed ttl=3600s
[14:20:07] [tunnel] handshake ok peer=pop-04 cipher=ChaCha20-Poly1305
[14:20:07] [console] SESSION ACTIVE target=+14155550123 remaining=59:53
[14:20:41] [console] inbound smsc=+14155550000 orig=+447700900123
[14:20:41] [payload] captured id=88291 type=OTP delay=+0.41s (jittered)
[14:20:41] [console] MESSAGE RECEIVED
[14:20:41] "Your verification code is 849201"
[14:21:03] [console] inbound smsc=+14155550000 orig=+447700900123
[14:21:03] [payload] captured id=88307 type=OTP delay=+0.33s (jittered)
[14:21:03] [console] MESSAGE RECEIVED
[14:21:03] "Do not share this code with anyone."
[21:19:55] [payload] watchdog fired ttl_expired
[21:19:55] [cleanup] dispatch restored, hash-verified
[21:19:55] [cleanup] payload pages scrubbed (3 x 4096)
[21:19:55] [cleanup] baseband ring buffers cleared (4 records)
[21:19:55] [cleanup] emm/esm context reset
[21:19:55] [tunnel] keys destroyed, tunnel id burned
[21:19:55] [console] SESSION CLOSED teardown=VERIFIED residue=NONE
| Version | Date | Change |
|---|---|---|
| v4.2.0-rc7 | 2026-10-19 | Exynos 2100 framing variant C; relay pool expanded to 14 PoPs; success rate on Android 12 up from 48% → 62% |
| v4.2.0-rc5 | 2026-10-02 | Entropy tunnel: added PDP-rate matching and relay rotation; carrier-level anomaly detection dropped to near zero on monitored profiles |
| v4.1.2 | 2026-09-11 | Payload scrub hardened — 3-pass overwrite with random fill; teardown receipt added to console |
| v4.1.0 | 2026-08-19 | AI gateway rewrite: confidence scoring per carrier profile; parallel path execution |
| v4.0.0 | 2026-06-02 | GTP-C injection path added alongside SS7; Android 10–12 support |
| v3.6.0 | 2026-02-14 | Android 8–9 support; SS7-only era (no GTP-C fallback) |
Three of the first licenses have been issued. Feedback below is from those operators.
/v4/stats returns the same breakdown filtered to your license's observed history.
selftest.sh, which runs the full stack against a loopback harness — injection, tunnel, capture, teardown, cleanup verification — without touching any live network. It proves your install is correct. It does not prove the exploit works against a real carrier, and no vendor can honestly claim otherwise.