h0ps (@_h0p5) profile picture

Pwn & Rev

Joined April 2020
Photo by h0ps (@_h0p5)
if you're interested in building next-gen sandboxing for agents, have a ton of passion/ambition for low-level systems software (OS/hypervisor), and are itching to rewrite their internals for security/performance/whatever, don't miss this: job-boards.greenhouse.io/ant…
21
35
4
590
55,568
h0ps retweeted
⛳ Announcing the PCBGolf challenge ⛳ $1000 cash for the smallest PCBA by October 12. You can try to use your clanker, but it can't do it. Are you better than an autorouter? github.com/commaai/PCBGolf
34
23
17
304
92,153
Today, Project Zero is releasing MAccConc, a tool by @tehjh that enables deterministic testing of race conditions on Linux. It can be used for fuzzing, ad-hoc exploration, regression tests and more! projectzero.google/2026/09/m…
4
114
4
445
40,714
h0ps retweeted
New research: OEMpocalypse Now! Our own Lukas Maar spent a few weeks pursuing one question: How do you turn a normal Android app into root access across as many phones as possible without rewriting the exploit for every model? Generic Linux kernel bugs offer broad coverage: one exploit can target both Pixel and Galaxy. But bugs that survive years of auditing often provide only constrained slab-level primitives, forcing the exploit into heap grooming and per-device tuning. Chipset drivers offer stronger primitives. A GPU or DSP driver pins and maps entire pages for the device, giving the attacker page-level access. But coverage follows the silicon, and each OEM ships several chipsets across its lineup. Lukas chose a third target: the code Samsung, Xiaomi, and Oppo build on top of Android. These components belong to One UI, HyperOS, and ColorOS rather than the underlying hardware, so they span an OEM's lineup regardless of chipset. The strategy exploits a page use-after-free in an OEM kernel driver. If SELinux restricts the driver to a privileged domain, an OEM sandbox escape reaches it first. A stale mapping to a freed physical page bypasses much of Android's kernel hardening. It requires no KASLR leak and hijacks no control flow, leaving slab protections and CFI irrelevant. The same page-reclamation code worked unchanged from kernels 5.15 through 6.12. Lukas built the chain three times, once for each OEM. The exploits run on a Galaxy S26 Ultra, Galaxy S26, Xiaomi 17, Oppo Find X9 Ultra, and OnePlus Ace 6 Ultra, all running stock July 2026 firmware with locked bootloaders. The write-up includes demo videos. Part 1 explains the strategy, its reasoning, and its tradeoffs. Parts 2 through 4 present each OEM-specific chain. Read it at calif.io/research/oempocalyp….
7
46
2
163
55,680
h0ps retweeted
blog.ritsec.club/posts/vrig-… 😅 something me and my uni friends worked on, wasn't perfect but we learned a lot and people got j*bs out of it so not horrible lol We are doing XNU/IOS/MacOS stuff this year, I am sure it'll go a lot better lmao
4
14
95
7,097
Project Zero is hiring! google.com/about/careers/app… Please share with anyone you think would be great for the role. DMs are open for questions.
10
106
5
570
61,163
h0ps retweeted
In case you missed the blogpost by our members leo and bitfriends, please check it out!💥
I recently played GreyCTF Finals with @ARESxCTF. Me and @bitfriends_ managed to blood a kpwn challenge by finding some new triggers for modprobe_path. You can find the blogpost + writeup here: leo1.cc/posts/docs/socket020… Thanks @NUSGreyhats for hosting a great no-LLM CTF!
2
19
1,554
I am recruiting offensive security researchers to work with me in Palo Alto Networks. The role is not yet posted: Reverse engineering, vulnerability research, firmware analysis, secure boot, kernel internals, hardware debugging (JTAG/UART/SWD), and offensive security experience.
13
34
159
18,065
It's a gorgeous and funny bug. Fwiw, I'm the biggest eBPF fanatic, but I don't think unprivileged users should be able to load arbitrary eBPF programs.
found a verifier/interpreter mismatch in the Linux BPF subsystem (CVE-2026-31525, CVSS 7.8). arbitrary kernel read/write; become root, escape containers, disable SELinux, read TLS keys out of other processes' memory. anyway, it starts with the math bars, the absolute value. computers store negative numbers in two's complement. the smallest 32-bit signed integer is -2,147,483,648, and the largest positive is +2,147,483,647. there is no +2,147,483,648, since it simply does not fit. so when you call abs(-2,147,483,648), the C specification thinks about it for a moment, says "undefined," and leaves the room. on x86 and arm64, what you actually get back is -2,147,483,648. you asked for the absolute value of a negative number, you got back the same negative number. thank you computer :D the BPF interpreter implements signed 32-bit division (BPF_ALU | BPF_DIV/MOD, off == 1, added in ec0e2da95f72) by decomposing it into unsigned division: take abs() of both operands, divide via do_div(), reapply the sign. the handler in ___bpf_prog_run (kernel/bpf/core.c): AX = abs((s32)DST); AX = do_div(AX, abs((s32)SRC)); and look, the kernel even documents this. include/linux/math.h: "the return value is undefined when the input is the minimum value of the type." when DST = 0x80000000 (S32_MIN), abs() tries to negate it. -(-2,147,483,648) overflows s32, the C spec calls it undefined behavior, and the CPU hands back 0x80000000 unchanged. still negative. abs() had one job. this s32 then gets assigned into AX, a u64 BPF register. s32 → u64 sign-extends: 0x80000000 becomes 0xFFFFFFFF80000000. that's 18,446,744,071,562,067,968. you wanted 2,147,483,648, you got 18.4 quintillion; a rounding error of about 18.4 quintillion. do_div() is a 64-by-32-bit unsigned division macro and it operates on this full u64 numerator. the quotient is off by a factor of 2³². the smod path has the same problem since do_div() modifies the dividend in place and returns the remainder, both wrong. 8 call sites across sdiv32/smod32 src/imm handlers, all quietly producing nonsense whenever S32_MIN shows up. the BPF verifier is the safety system that statically analyzes every BPF program before allowing it to run. it exists specifically to guarantee that nothing bad can happen. scalar32_min_max_sdiv() in kernel/bpf/verifier.c tracks value ranges through abstract interpretation. it handles signed division correctly, including S32_MIN. computes tight, mathematically correct bounds. the interpreter, as we've established, computes whatever it feels like. so the verifier thinks register R0 is in range X. the interpreter puts value Y in R0. the safety system and the execution engine disagree about what a program does. in BPF security research, this is where you set down your coffee. concretely: load S32_MIN into R1, load 2 into R2, execute SDIV32 R1 R2. verifier determines R1 ∈ [-1,073,741,824, -1,073,741,824]. interpreter computes do_div(0xFFFFFFFF80000000, 2) = 0x7FFFFFFFC0000000, reapplies the sign, produces a completely unrelated value. use R1 as an index into a BPF map. verifier approves the access, bounds check passes against its calculated range. interpreter uses the actual value. out-of-bounds read/write on a kernel data structure. on every Linux machine running the BPF interpreter. the root cause of all of this: the absolute value function doesn't handle one number. one specific number, out of 4.2 billion possible inputs, and it's the one that gives you kernel read/write. the fix is: c static u32 abs_s32(s32 x) { return x >= 0 ? (u32)x : -(u32)x; } cast to u32 before negating. -(u32)0x80000000 = 0x80000000 unsigned. correct absolute value, no overflow, no undefined behavior. the kind of function you'd assume already exists somewhere in 30 million lines of kernel code. it did not. I got to write it. :D I reported this, wrote the patch, got it through 5 revisions of review. acked by Yonghong Song and Mykyta Yatsenko. now patched in stable 6.6, 6.12, 6.18, 6.19. if you haven't updated your kernel: maybe do that.
7
23
1
154
25,669
When it comes to in-depth technical write-ups, one of my favorite authors is @abhi9u. And this time, he has crafted a beautiful article, "Virtual Memory: A Deep Dive into Page Tables, TLBs, and Linux Internals." Go, give it a read. blog.codingconfessions.com/p…
3
115
1
837
31,690
h0ps retweeted
ARESx is proud to announce that we have placed 5th on Lake CTF in Lausanne🇨🇭 Thanks to the organization for the great event @LakeCtf and hope to see everyone soon!! 🚩🚀
7
28
1,171
Exploiting llama.cpp’s RPC Server - From Null Buffer to RCE Against PIE + Full RELRO + NX | CVE-2026-34159: The vulnerability is a one-line logic bug in the RPC server’s tensor deserialization pipeline. Youtube: youtube.com/@NullSecurityX Blog: pwntricks.com/ZeroClick-RCE-…
2
40
228
19,643
Our biggest breakthrough in efficiency yet, the Framework Laptop 13 Pro with 20 hours of battery life. In Graphite. Linux-first with options for Ubuntu pre-installed. Featuring Intel® Core™ Ultra Series 3 processors, LPCAMM2 Memory, a new haptic touchpad, and a touchscreen display. Pre-orders for the Framework Laptop 13 Pro open now: frame.work
554
1,184
522
16,668
2,994,913
Took me almost a month, but it’s finally done. I completely rewrote the first chapter of linux-insides about the Linux kernel initialization process. Now it should be aligned with modern kernels (up to master). github.com/0xAX/linux-inside…
10
210
2
1,233
59,325
h0ps retweeted
We open sourced the tool used to detect the Axios supply chain compromise! I built it Friday after a red eye home from RSAC. Also, wrote up the full story, including the hectic moments after that first critical alert github.com/elastic/supply-ch…
32
244
18
1,288
138,584
day 1: exploited by LiteLLM day 2: exploited by vim day 3: exploited by emacs day 4: exploited by axios day 5: echo "hello world" exploited me The threat model is now "software"
13
102
7
857
32,199
Just derestricted a now-fixed kernel bug in Pixel 10. I think this ranks as the most easily exploited kernel bug of all time😬 Thanks to @tehjh for collab'ing on this driver and full credits for noticing this bug in the first 5 minutes of auditing😂 project-zero.issues.chromium…
5
45
187
17,602
h0ps retweeted
With a slight delay of three months, me and @bitfriends_ finally found the time to finish our writeup for Still Not Malloc from LakeCTF Quals. Shout out to @LakeCtf organizers for the cool pwn. See you soon in Lousanne! leo1.cc/posts/writeups/lakeq…
7
25
1,254
h0ps retweeted
I started playing CTFs in 2022, and LLMs definitely changed the **competitive** CTF scene a lot, especially since mid-2025. I also started using LLMs in late 2025. Yes, those models did one-shot many challenges, but what's the fun of slopping them? I learned absolutely nothing 🥲
21
96
13
607
109,546