[{"content":"Summary Pointed at a codebase with no guidance, an agent produces a long list of plausible-sounding findings and very few real ones. Given a narrow scope, the build, a sanitizer and a rule that every claim needs a reproducing test, the same model found two genuine memory-safety bugs in a protocol parser in an afternoon. Most of the gain came from the setup around the model, not from the model.\nBackground Vulnerability research is mostly reading code with a suspicious mind, which looks like the kind of work an agent should be good at. The failure mode is confidence: agents describe a bug convincingly whether or not one exists, so the cost shifts from finding candidates to verifying them.\nMethod I write a short brief for each session and keep it in the repository so it can be reused and diffed. The brief names the target, the files in scope, the tools the agent may call, and the rules for reporting.\ntask: audit the packet parser for memory-safety bugs scope: src/mqtt/parse*.c, include/mqtt/*.h tools: [ripgrep, clang-tidy, build_asan, run_fuzz_corpus] rules: - cite file and line for every claim - reproduce with a failing test before reporting - stop and ask if a fix needs a design change Findings Requiring a reproducing test removed almost every false positive, because an agent that cannot make an address sanitizer complain has to say so. Giving it the fuzzing corpus as a tool turned vague suspicions about length fields into concrete crashing inputs.\nTakeaways Treat the agent as a fast, tireless junior who must show its work. Invest in scope, tools and verification, and keep a human in the loop for anything that changes behaviour.\n","permalink":"https://personal-blog-1jz.pages.dev/writeups/placeholder-agent-vulnerability-research/","summary":"A coding agent finds more real bugs when it is given the right context and a way to check its own work. What I hand it, which tools I wire in, and the review loop that keeps false positives from eating my day.","title":"Getting more out of a coding agent for vulnerability research: context, tools and a review loop"},{"content":"Summary The remote on my test bench is sold as \u0026ldquo;rolling code, impossible to clone\u0026rdquo;. It isn\u0026rsquo;t. The receiver accepts any frame whose counter sits inside a window of 4,096 values ahead of the last one it saw, and it never invalidates codes that were skipped. A single captured button press therefore stays valid until the owner has pressed the button thousands of times, and in practice that is never. This post walks through the capture, the decoding, and a replay that opened the test door on the first try.\nBackground Sub-GHz remotes are everywhere: garage doors, gates, alarm fobs, ceiling fans. Most of them sit in the 433.92 MHz or 868 MHz bands and use simple on-off keying, which makes them a friendly first target for anyone learning to work with software-defined radio.\nThe target The device is a two-button remote and a matching receiver board, both bought from a hardware store. The receiver has no network interface and no debug header I could find, so everything here is black-box over the air.\nWhat \u0026ldquo;rolling code\u0026rdquo; should mean A well-built system derives each transmitted code from a shared secret and a counter, and the receiver accepts only a small forward window. Capturing one frame then gives an attacker nothing, because the receiver moves its counter forward as soon as the legitimate frame arrives. The interesting question is always how big that window is, and what happens to codes inside it that were never used.\nMethod I kept the setup deliberately boring so that every step can be reproduced with inexpensive gear.\nTune the SDR to 433.92 MHz with a 2 MHz sample rate and record a few seconds of the remote being pressed. Open the recording in a spectrogram viewer and confirm the signal is OOK with a symbol length of about 400 µs. Slice the recording into individual frames and demodulate each one to a bit string. Press the same button repeatedly and diff the frames to find the fields that change. Decoding the frame Every frame starts with a 12-bit preamble of alternating symbols, followed by a 4-bit button identifier, a 24-bit counter and a 32-bit value that looks like a keyed hash. Diffing ten presses made the layout obvious, because only the counter and the hash changed.\nimport numpy as np SYMBOL_US = 400 SAMPLE_RATE = 2_000_000 def demod(iq: np.ndarray) -\u0026gt; str: \u0026#34;\u0026#34;\u0026#34;Slice an OOK recording into a bit string.\u0026#34;\u0026#34;\u0026#34; env = np.abs(iq) thresh = (env.max() + env.min()) / 2 bits = env \u0026gt; thresh per_symbol = int(SAMPLE_RATE * SYMBOL_US / 1_000_000) return \u0026#34;\u0026#34;.join(\u0026#34;1\u0026#34; if bits[i : i + per_symbol].mean() \u0026gt; 0.5 else \u0026#34;0\u0026#34; for i in range(0, len(bits) - per_symbol, per_symbol)) A decoded frame, with the fields split out, looks like this:\npreamble 101010101010 button 0001 counter 000000000000100111000101 hash 10111100010010101101000111001010 Lining ten presses up side by side shows the pattern at a glance: the preamble and the button never change, the counter ticks up by one, and the hash looks random.\nTen presses of the same button, aligned by field. Highlighted bits changed since the previous press.\nFindings The counter increments by one per press, and the hash changes with it. I could not recover the hash function, and I did not need to: the receiver does not check that a replayed hash matches the latest counter, only that the counter is within its window.\nTest Counter offset from last seen Receiver response Replay of latest frame 0 Opens Replay of a frame 1,000 presses old −1,000 Ignored Replay of a captured future frame +1,500 Opens Replay of a captured future frame +5,000 Ignored The window is therefore at least 1,500 codes wide, and bisecting the boundary put the edge at 4,096. Two further observations made it worse:\nSkipped codes are never invalidated, so a stockpile of frames captured while the owner is away stays usable. Pressing the button out of range advances the remote\u0026rsquo;s counter without advancing the receiver\u0026rsquo;s, which widens the effective window over time. Rolling codes only help when the receiver is strict about the window. A wide window turns a rolling code into a slightly longer fixed code.\nTakeaways For vendors: shrink the acceptance window to single digits, invalidate skipped codes on resync, and require a second button press to resynchronise. For owners of this class of remote: treat it as a convenience, not a lock, and do not use it as the only barrier to anything valuable.\nFor me, the main lesson was how far a spectrogram and a diff get you before any reverse engineering of firmware is needed. Next I want to see whether the same weakness shows up in the vendor\u0026rsquo;s 868 MHz alarm fob.\n","permalink":"https://personal-blog-1jz.pages.dev/writeups/placeholder-wireless-protocol-writeup/","summary":"A 433 MHz remote that advertises rolling-code security but accepts any frame whose counter falls inside a 4,096-code window. How I captured it, decoded the frame format, and replayed a valid unlock from a $30 SDR.","title":"Replaying a sub-GHz garage remote when the rolling code never rolls"},{"content":"Summary The vendor publishes no firmware images, so the only way in was the flash chip. Clipping onto the SOIC-8 package and reading it in-circuit gave a clean 8 MiB dump on the third attempt. Strings and a quick unpack exposed a default administrator password shared across the product line.\nBackground Budget cameras are built from a small set of reference designs, which means one teardown often generalises across a dozen brands. This one uses a common SoC, a 25-series SPI flash and an unpopulated UART header next to the antenna.\nMethod I identified the flash from its markings, powered the board from a bench supply at 3.3 V so the SoC stayed in reset, and read the chip over SPI. A logic analyser on the same pins let me confirm the clock speed and rule out contention with the SoC.\nFindings The image contains a SquashFS root filesystem and a U-Boot environment. The environment leaves the bootloader prompt reachable over the UART with no delay, and the web interface ships with a fixed administrator account.\nTakeaways Lock the bootloader, remove default credentials, and treat the flash chip as readable by anyone with a clip. For researchers: a logic analyser is worth its price the first time a dump comes back half corrupted.\n","permalink":"https://personal-blog-1jz.pages.dev/writeups/placeholder-iot-device-writeup/","summary":"Two evenings, one SOIC-8 clip and a logic analyser: how I pulled the firmware from a camera that ships with no update file, then found a hard-coded credential in the first strings pass.","title":"Dumping SPI flash from a budget IP camera with a clip and a logic analyser"},{"content":"Summary Given an unpacked router firmware image, an agent mapped the filesystem, summarised the services and ranked binaries by risk faster than I would have by hand. It also invented a hard-coded key in a function it had not read. Splitting the work into steps it could check made the difference.\nBackground Firmware triage is a long tail of small questions: which services listen, which binaries parse untrusted input, which scripts shell out. Each is easy to answer and tedious to answer a hundred times, which is where an agent should help.\nMethod I gave the agent a read-only view of the extracted filesystem, a disassembler it could script, and a rule that any claim about behaviour had to quote the code or the command output that supported it.\nFindings Enumeration and summarisation were reliable. Reasoning about stripped binaries without running them was not: when it had to guess, it guessed fluently. Claims that came with a quoted decompiler snippet were right far more often than claims that did not.\nTakeaways Use agents for breadth and make them cite evidence for depth. If a statement cannot be checked in one command, treat it as a hypothesis.\n","permalink":"https://personal-blog-1jz.pages.dev/writeups/placeholder-agent-firmware-triage/","summary":"A field report from letting an agent loose on an unpacked firmware image. It was excellent at the boring parts, confidently wrong about the interesting ones, and the difference came down to what it could actually run.","title":"Where agents fall down at reverse engineering: triaging a firmware image with an LLM"},{"content":"Summary The sample is a 6 MB Go binary whose only visible behaviour is opening a picture. The picture is the payload: configuration bytes are hidden in the low bits of the pixel data and decoded at start-up with a rolling XOR. I recovered the config with a short script and no execution.\nBackground Go binaries are large and carry their symbol tables, which makes them easier to navigate than most packed samples, but the runtime also buries the interesting code under thousands of library functions.\nMethod I loaded the sample in a disassembler, recovered function names from the pclntab, and looked for calls into image/png. The decoder lived two calls away from main, next to a 16-byte constant that turned out to be the XOR key.\nFindings The extracted configuration lists two C2 hosts, a sleep interval with jitter, and a campaign identifier. The same key appears in three older samples, which makes it a useful pivot for hunting related files.\nTakeaways Static recovery is quick once the staging point is found. For defenders: the key and the pixel layout make a stable detection that survives repacking.\n","permalink":"https://personal-blog-1jz.pages.dev/writeups/placeholder-malware-reversing-writeup/","summary":"A loader that looks like an image viewer and carries its command-and-control settings in the least significant bits of a bundled PNG. Recovering the config statically, without ever running the sample.","title":"Unpacking a Go loader that hides its configuration inside a PNG"},{"content":"Summary Feeding random bytes to an MQTT broker mostly exercises the first parser and nothing else, because almost every interesting handler sits behind a valid CONNECT. A harness that performs the handshake once and then fuzzes the following packets in persistent mode reached the subscription and retained-message code paths and found three memory-safety bugs.\nBackground MQTT is a small publish-subscribe protocol that runs under a large amount of IoT infrastructure. Brokers are long-lived, stateful and exposed, which makes them a good fuzzing target and a worthwhile one.\nMethod I split the broker\u0026rsquo;s connection handling from its socket code, replaced the network layer with an in-memory buffer, and wrapped a session setup in an AFL++ persistent loop. A small dictionary of packet types and flag bytes kept mutations structured without forcing them to be valid.\nFindings Throughput went from a few hundred to roughly 20,000 executions per second. Coverage climbed steadily for two days and then plateaued, at which point a custom mutator that rewrote the remaining-length field found two more crashes.\nTakeaways Harness quality matters more than raw speed. Spend the first day on state and reachability, and only then on performance.\n","permalink":"https://personal-blog-1jz.pages.dev/writeups/placeholder-fuzzing-writeup/","summary":"Naive packet fuzzing never got past CONNECT. Building a harness that drives a real session, keeps state between messages, and runs fast enough in persistent mode to find three crashes in a week.","title":"Fuzzing an MQTT broker with AFL++ persistent mode and a state-aware harness"},{"content":"Summary A fitness tracker advertises every 200 ms, whether or not anything is paired to it. Those advertisements carry a manufacturer-specific payload that includes a battery level, a firmware revision and a counter that is easy to correlate across address rotations. Nothing here needs authentication, pairing, or anything stronger than a ten-dollar dongle.\nBackground BLE advertising is a broadcast. Any receiver in range can read every packet, and the privacy feature meant to stop tracking, a resolvable private address that rotates every 15 minutes, only protects the address field itself.\nMethod I flashed an nRF52840 dongle with the sniffer firmware, captured on the three advertising channels in turn, and exported the result to a capture file for analysis. Walking away from the tracker and returning later gave me a clean set of address rotations to line up.\nFindings The payload keeps a monotonic counter in the clear. Matching counters across the two address epochs links the tracker\u0026rsquo;s old and new addresses with certainty, which defeats the point of rotating them in the first place.\nTakeaways Rotate everything that can be correlated, not just the address, and keep counters out of advertisements. For researchers: always look at the manufacturer data before assuming the address is the only identifier.\n","permalink":"https://personal-blog-1jz.pages.dev/writeups/placeholder-ble-advertisement-sniffing/","summary":"Bluetooth Low Energy trackers broadcast far more than their owners expect. A walkthrough of passive capture, decoding the manufacturer-specific data, and what a rotating address does and does not hide.","title":"Sniffing BLE advertisements from a fitness tracker with a $10 nRF52 dongle"},{"content":"Summary The smart plug\u0026rsquo;s update file is a plain archive with a header, a kernel and a compressed filesystem. Unpacking it takes one command; understanding the local web service takes the rest of this post. A parameter passed unsanitised to a shell helper yields root without authentication.\nBackground Cheap plugs run a stripped-down Linux with a single web service for local setup. That service is often the entire attack surface, because the cloud connection is outbound only.\nMethod I downloaded the update file, ran binwalk to carve out the filesystem, and mounted it read-only. A grep for system( and popen( in the web binary produced a short list of calls worth reading.\nFindings One handler builds a shell command from the ssid field. Quotes are not escaped, so a crafted network name runs arbitrary commands as root.\nTakeaways Validate and quote everything that reaches a shell, or better, stop shelling out. For researchers: start from the strings, not from the disassembly.\n","permalink":"https://personal-blog-1jz.pages.dev/writeups/placeholder-smart-plug-firmware/","summary":"Pulling a vendor update file apart, mounting the filesystem, and following a command-injection bug in the local web service from a string in the binary to a root shell.","title":"From a Wi-Fi smart plug to root: unpacking firmware with binwalk"},{"content":"Summary During a 4G attach, the identity request and a handful of capability messages travel before security is established. That is enough for a nearby base station to learn a permanent identifier, the device\u0026rsquo;s radio capabilities and, in some cases, which network it last registered on. The setup needed is a laptop, a USRP and an open-source stack.\nBackground LTE separates the air interface from the core network, but the first messages of an attach sit in a window where neither side has agreed keys. Everything exchanged before the security mode command is readable, and a phone will usually answer a strong enough cell that claims to belong to a network it trusts.\nMethod I ran srsRAN\u0026rsquo;s eNodeB against a USRP B210 inside a shielded enclosure with a test SIM, so the experiment stayed off the public network. A short script logged each attach request together with the identity and capability fields the handset volunteered.\nFindings The phone answered an identity request with its permanent identifier on the first try. Capability messages revealed the supported bands and ciphering algorithms, which is useful for fingerprinting a handset model without ever decrypting traffic.\nTakeaways Treat the attach as hostile territory. Operators can reduce exposure by preferring temporary identifiers, and 5G\u0026rsquo;s concealed identifier closes the most obvious gap, though capability leakage remains.\n","permalink":"https://personal-blog-1jz.pages.dev/writeups/placeholder-lte-attach-imsi-exposure/","summary":"A phone attaching to an LTE cell says more in the clear than most people expect. A look at what a rogue eNodeB sees during the attach procedure, and which of it survives the move to 5G.","title":"What a 4G attach leaks: measuring IMSI exposure with srsRAN and an SDR"},{"content":"Summary A single host sent a short TCP message every 60 seconds, give or take a few seconds of jitter. The messages were not TLS and not HTTP, and they were not random either. Treating the capture as a protocol-reversing exercise recovered the framing, the command set and a trivial obfuscation layer.\nBackground Beaconing is the easiest malware behaviour to find and one of the harder ones to read. Fixed-interval traffic stands out on a timeline, but the payload is usually wrapped in a format nobody has documented.\nMethod I plotted packet times to confirm the interval, grouped payloads by length, and compared the first bytes of each group. A length prefix and a one-byte command code fell out within minutes, and a repeating four-byte XOR key followed from a known plaintext.\nFindings The decoded stream shows a check-in, a task request and a result upload. Command codes map to file listing, upload and shell execution.\nTakeaways Alert on the interval and jitter rather than on the payload. For researchers: always look for known plaintext, since protocol headers are rarely random.\n","permalink":"https://personal-blog-1jz.pages.dev/writeups/placeholder-c2-beacon-decoding/","summary":"No source, no sample, just an hour of pcap. Spotting the heartbeat, aligning the framing, and writing a decoder good enough to read the operator\u0026rsquo;s commands.","title":"Following the beacon: decoding a custom C2 protocol from a packet capture"},{"content":"Summary A Zigbee stack hands every received frame to a single function before doing anything else, which makes it a clean fuzzing entry point. The harness is thirty lines. The work that took time was triage: forty crashes collapsed into three root causes once I grouped them by the faulting instruction and the allocation site.\nBackground Radio frames are attacker-controlled input that reaches the parser before any authentication, so bugs here are reachable by anyone in range.\nMethod I built the parser as a standalone library with AddressSanitizer, wrote a harness that feeds the fuzzer\u0026rsquo;s buffer to the frame handler, and ran four AFL++ instances with a shared corpus seeded from captured frames.\nFindings Two crashes were out-of-bounds reads on a length field that was trusted before it was validated. The third was an integer underflow in the fragment reassembly code.\nTakeaways Minimise first, then group, then read. Triage by stack hash alone overcounts, and triage by crash site alone undercounts.\n","permalink":"https://personal-blog-1jz.pages.dev/writeups/placeholder-zigbee-frame-fuzzing/","summary":"The full loop on a small parser: isolating the frame-handling code from the radio stack, writing the harness, and turning forty raw crashes into three distinct root causes.","title":"From harness to crash triage: fuzzing a Zigbee frame parser"},{"content":"Summary In a 5G standalone network the handset never sends its permanent identifier in the clear. It sends a concealed one, derived with the operator\u0026rsquo;s public key, which only the home network can open. A first capture against an open-source core confirms the change and shows where useful metadata remains.\nBackground The concealed identifier is the headline privacy improvement in 5G. It does not hide everything: message timing, capability exchange and the network\u0026rsquo;s own behaviour can still tell a careful observer a good deal.\nMethod I deployed Open5GS as the core, an srsRAN gNodeB on a software-defined radio, and a test handset with a provisioned SIM. Wireshark decoded the NAS messages from the core side so I could compare them with what an over-the-air observer sees.\nFindings Registration requests carried a SUCI that changed on every attempt, which breaks simple tracking by identifier. Capability fields and the timing of the exchange stayed stable enough to link repeat attachments from the same handset.\nTakeaways SUCI is a real improvement, but identity is more than one field. Test the whole registration, not just the identifier, when assessing what a network leaks.\n","permalink":"https://personal-blog-1jz.pages.dev/writeups/placeholder-5g-sa-suci-concealment/","summary":"Moving from 4G to 5G standalone encrypts the permanent identifier before it leaves the handset. Setting up an open 5G core to test it, and what the capture still shows once the identifier is hidden.","title":"5G standalone, first look: how SUCI concealment changes what an attacker can see"},{"content":"I am a security researcher who spends most evenings with a soldering iron, a logic analyser or a disassembler. The work started as curiosity about how a garage remote talks to its receiver and turned into a habit of asking the same question about every connected device I own.\nDay to day I look at wireless and cellular protocols, the firmware that runs on cheap connected hardware, and the malware that ends up on it. A lot of my time goes on malware analysis, on 4G and 5G networks, and on getting AI agents to do useful security work. I write up the interesting ones here, including the dead ends, because the dead ends are usually where I learned the most.\nEverything I publish follows coordinated disclosure. If a writeup names a vendor, the vendor has already had time to fix the problem, and if they have not responded, the writeup says so.\n","permalink":"https://personal-blog-1jz.pages.dev/about/","summary":"\u003cp\u003eI am a security researcher who spends most evenings with a soldering iron, a logic analyser or a disassembler. The work started as curiosity about how a garage remote talks to its receiver and turned into a habit of asking the same question about every connected device I own.\u003c/p\u003e\n\u003cp\u003eDay to day I look at wireless and cellular protocols, the firmware that runs on cheap connected hardware, and the malware that ends up on it. A lot of my time goes on malware analysis, on 4G and 5G networks, and on getting AI agents to do useful security work. I write up the interesting ones here, including the dead ends, because the dead ends are usually where I learned the most.\u003c/p\u003e","title":"About"},{"content":"","permalink":"https://personal-blog-1jz.pages.dev/contact/","summary":"","title":"Contact"}]