What I'm doing now

ELFGuard's six tests and the bounded mutation regression remain local static-analysis evidence. AuthRace's 24 competing HTTP mutations show 120 units in the deliberately vulnerable handler versus 5 with atomic idempotency. For agent security, the browser trace demonstrates a denied tool request; it is not a Linux sandbox attestation.

A box marked 'secure' doesn't help anyone review a system. The useful parts are where untrusted input crosses into authority, what stops it, and what the implementation cannot prove. The Go container runner stays documented as a local reference; no end-to-end Linux kernel isolation claim.

A trained nonlinear encoder, vector-quantized codebook and decoder are interesting. An idealized low bitrate is not the same thing as good reconstructed speech.

I built five small speech and audio implementations and measured their behavior. ASR errors, turn detection, codecs, prosody and classifier ablations each have different ways to mislead you.

How I connected Swift and Kotlin clients to agent workflows, built Core ML and TensorFlow Lite integration boundaries, and kept authorization on the backend.

Building an agent that talks is the easy demo. The harder work is authenticated tools, retries, evaluation, telemetry, CRM synchronization and the people who have to operate it.

Retry logic looks harmless in isolation. When a gateway, application service and SDK each apply their own retry policy, a single failed operation can multiply into a dependency outage. That interaction is the starting point for my retry-storm analysis.

An encrypted database value can be perfectly unreadable to an attacker and still end up in the wrong record. If a service moves ciphertext between tenants without binding the record's context, the system may de

When a robotics node starts, I don't want "the process launched" to be confused with "the robot is ready to move." The ROS 2 managed-node design makes this difference explicit with lifecycle states. That's a be

I traced Stuxnet as a boundary-crossing problem: from Windows software into industrial control commands. Calling it sophisticated Windows malware misses the physical-system risk. The attack path targeted software used to supervise and program indust

Raspberry Robin showed why incident timelines need separate columns for initial access and what attackers do later. Microsoft's October 2022 research described a USB-propagating worm that was connected to a bro

Melissa demonstrates why I include document and user-interaction boundaries in propagation analysis, not only remotely exploitable network services. In March 1999, a Microsoft Word document with a malicious macro relied on someone o

In my analysis of Mirai, the failure starts with a simple hardware assumption: devices that ship with weak or default remote-management credentials will eventually be found by automated scanners. In 2016, many cameras, recorders and routers were ex

The starting point I emphasized in my NotPetya review is a trusted enterprise distribution path: the update path for Ukrainian accounting software M.E.Doc. It then moved laterally and disrupted organizations well beyond its initial target geography.

In my review of WannaCry's propagation path, the network boundary matters as much as the payload. The May 2017 outbreak combined ransomware with self-propagation across vulnerable Windows SMB services.

The trust failure I examined in Android toll-fraud reporting is the confirmation step: an OTP does not protect a purchase if malicious software on the same device can intercept or submit it. Microsoft documented Android toll-fraud workflows in which malware tried to subscribe victim

In reviewing the Joker/Bread campaigns, I focused on the separation between an app doing its advertised job and subscription activity the owner never authorized. Google's 2020 report on Bread—often called Joker—documented that exact billing-fraud problem. The family kept adapting as defenses a

A real capture of the live lab below. Try a replay, a forged integrity signal, or an unauthorized object request. The server is still the one that has to make the authorization decision. The client can be very persuasive; it doesn't get a vote.

The first pass hit HTTP 403 on a shared IP. Rather than fake a green check, the site now uses official GitHub badges when a repository and workflow are genuinely public. My private builds stay private. Unexciting fallback, correct result. That's a win.

Why this corner of the internet isn't going to be only about code.