All posts

// TOPIC · 9 POSTS

#security

SECURITY

The TLS 1.3 Handshake: What Those Milliseconds Buy

One round trip now negotiates keys, proves identity, and encrypts everything after the first message. What actually happens in a TLS 1.3 handshake, why it's structurally safer than 1.2, and where the remaining sharp edges live.

SECURITY

Stack Canaries: How the Compiler Catches a Buffer Overflow

A classic stack smash overwrites the return address and hijacks execution. Stack canaries are the cheap, clever defense your compiler inserts automatically — and understanding them explains a whole class of exploits.

ALGORITHMS

Regex Engines: The NFA/Backtracking Split That Explains ReDoS

The same pattern runs in microseconds in Go and hangs for years in JavaScript, on the same input. The reason is a fork in engine design made in the 1970s — automata vs backtracking — and it's why one regex took Cloudflare's edge offline.

NETWORKING

ARP: The Protocol That Glues IP to Ethernet

Every packet's last hop is decided not by routing but by a 1982 protocol with no authentication, a cache with quirks, and failure modes — gratuitous ARP, proxy ARP, spoofing — that explain a shocking fraction of 'the network is weird' tickets.

COMPILERS

Undefined Behavior: The Compiler Is Not Your Friend Here

UB doesn't mean 'returns garbage' — it means the optimizer may assume it never happens and reason backwards from that. How signed overflow checks get deleted, why time-travel is real, and the sanitizer workflow that catches it.

SECURITY

ASLR: Security by Shuffling the Address Space

Every exploit needs an address; ASLR's bet is that the attacker shouldn't know any. How Linux randomizes stack, heap, and libraries, why PIE took years to become default, and the leak-one-pointer reality that keeps ASLR a speed bump, not a wall.