Loading video...

Video Failed to Load

Go Home

New video on format string vulnerabilities. It's the classic printf(user) bug. An attacker can read and write almost any memory in the process, from a single print statement. I walk through all of it in a live GDB session. Leaking the stack with %p, turning %n into an arbitrary...

12,610 views • 7 days ago •via X (Twitter)

8 Comments

acidburn's profile picture
acidburn7 days ago

java devs discovering printf can spawn a shell

tetsuo's profile picture
tetsuo7 days ago

I'll cover Apache Log4j next. 😂

Pitchfork & Torch ♞'s profile picture
Pitchfork & Torch ♞7 days ago

Hello world?

BullBear.News's profile picture
BullBear.News7 days ago

Using percent n for arbitrary write is a clean demonstration of classic memory corruption risks.

Path of Totality's profile picture
Path of Totality7 days ago

Quite educational thanks

Robi's profile picture
Robi7 days ago

Idź mi stąd w pizdu -90 ty kurwa pajacu .

Ricci Research's profile picture
Ricci Research7 days ago

Beautiful illustration of the real lesson: the bug isn't a missing bounds check, it's an API where the safe call and the catastrophic one differ by four characters. Compilers have warned about this for twenty years and it still ships, which says more about how warnings get triaged than about the developers.

why's profile picture
why7 days ago

The single-print-statement angle really shows why printf(user) is far more dangerous than a simple crash.

Related Videos

BROP is such a clean ASLR bypass. After brute-forcing the stack canary, the attacker starts overwriting the return address with guesses. Most guessed addresses jump into garbage or non-executable memory. The child process segfaults, and the socket closes. But occasionally, a guessed return address lands in real code that does something like sleep, pause, or an infinite loop. The process hangs, so the socket stays open. That address becomes a stop gadget. A known "safe landing pad" in the ROP chain. It gives the attacker a reusable signal. From there, they probe for stack-pop gadgets. probe_addr > trap_addr > stop_addr If probe_addr is not a pop reg; ret, execution returns into the trap address and crashes. If probe_addr is a pop reg; ret, it consumes the trap value from the stack and returns into the stop gadget instead. The socket stays open. So the attacker can remotely classify gadgets without seeing the binary. On x86-64, syscall/function args are in registers, not on the stack. So it’s not enough to know "this gadget pops one value." You need to know which register it controls. BROP uses signal syscalls like pause to map the gadgets. find pop rax; ret find pop rdi; ret find pop rsi; ret find pop rdx; ret find syscall Once those gadgets are identified, the attacker can directly assemble a write(2) syscall: rax = SYS_write rdi = socket fd rsi = pointer into .text rdx = length then return into syscall to execute it Once write(2) is reachable, BROP turns the live process into its own ASLR leak, and the server sends its text segment back over the socket. From that dump, the attacker recovers gadgets and offsets offline, then builds the final ROP chain for the same randomized layout the forked server keeps reusing. MIT 6.858.

tetsuo

25,142 views • 3 months ago

The same kinds of productivity gains we've seen in coding with AI agents are heading to the rest of knowledge work. This is the jump when you go from having a chatbot to being able to actually have an agent go off and do work for minutes or even hours and come back with a complete work output that you then review. Here's an example of the new Box Agent filling out an RFP response from an existing knowledge base. This process would normally take hours to fill out, and requires the full attention of the user doing the work. Now, you provide the Box Agent with the RFP questions, and it will go off, make a plan, extract all the relevant questions, read through existing source material to come up with an answer, and then generate a new word document as the final output. All while you're doing something else. The key to this architecture is that the agent is able to use all of the same tools in the background that a user uses to get work done. The agent can search for documents, read entire files, run scripts and tools in the background, and even be able to write code on the fly to automate tasks it hasn't seen before. And best of all, the Box Agent will (soon) work from the Box MCP and CLI so you can invoke it in any agentic system as a step in a process. This kind of agent complexity would have been impossible even 6 months ago. Models consistently failed at tracking long running tasks or using the right tools at the right moment for the task. But this is all now possible because of models like GPT-5.4, Opus 4.6, and Gemini 3, and is only getting better by the month. Just as we moved from engineers writing code and using AI as an assistant to answer questions, in many areas of knowledge work -like legal, finance, consulting, sales, marketing, and more- when we have a problem we'll just kick off the AI agent to just go work on it for us in the background.

Aaron Levie

24,728 views • 5 months ago