kmad

Full writeup and code here: https://github.com/kmad/agent-swarm-forensics

I had GLM-5.3 do some digging on the programmatic/ encoding elements of the data, what stuck out to me was:

  - Using api . microlink . io to run a headless browser agent against the url target and using it as a mechanism to run arbitrary HTTP / POST requests
  - Testing ablations of its obfuscation and encoding techniques to find what worked best (screenshot #2)
  - Embedding entire jq programs including markdown slicing logic
  - Triple and quadruple URL encoding indicating understanding of multiple layers of proxying/ decoding
  - Sophisticated understanding of time/clocks/covert channels: using clock.wait, heartbeats, counters, timestamps, thread ids

https://x.com/kmad/status/2096029334225997848

Seeing potentially similar activity on an obscure Chemistry message board from July:

https://tmcleod.org/cgi-bin/apchem/wiki.cgi?action=rc&days=1...

Some posts are tagged [proxy] - a leave behind for accessing sites?

This is, at least in part, the promise of frameworks like DSPy and PydanticAI. They allow you to structure LLM calls within the broader control flow of the program, with typed inputs and outputs. That doesn’t fix non-determinism, hallucinations, etc., but it does allow you to decompose what it is you’re trying to accomplish and be very precise about when an LLM is called and why.

Was anyone else's first thought to put this through Claude and see what it thought? Who knows if it's in the training data, etc. but I fed in the gist of the raw asm and didn't see any other network requests.

Opus 4.5 did pretty well considering it was raw assembly:

--- This is a classic hardware dongle detection routine for DOS/x86 systems from the 1980s-90s era. Here's what it does:

  Purpose

  Copy protection - it detects whether a specific hardware key (dongle) is connected to the parallel port.

  Step-by-Step Breakdown

  1. Find Parallel Port (lines 0000-0015)
  - Searches the BIOS data area (0000:0408) for parallel port addresses
  - Checks up to 4 possible LPT ports
  - Returns if no port found

  2. Save Port State (lines 0016-001D)
  - Disables interrupts (CLI)
  - Reads and saves current data and control register values
  - Pushes them onto stack for later restoration

  3. Initialization Sequence (lines 001F-003A)
  - Sends specific control signals: 0x82, 0x80, 0x82
  - Uses precise timing delays (0x9C40 and 0x3880 loops)
  - Prepares the dongle for interrogation

  4. Challenge-Response Loop (lines 003C-005F)
  - Runs 120 iterations (0x78)
  - Each iteration:
    - Sends 0xA2 to control port
    - Reads status register
    - Checks bit 6 (0x40 mask)
    - Records timing of specific responses in BL and BH registers
    - Looks for a response at iteration 0x76

  5. Cleanup (lines 0061-006F)
  - Writes 0x00 to reset
  - Restores original port state
  - Re-enables interrupts (STI)
  - Returns with BX containing the challenge result

  The dongle hardware would respond to these electrical signals with specific timing patterns that only genuine dongles would produce, making it very difficult to crack without the physical hardware.

---

Awesome! Have you considered pyodide[1]? Pydantic uses this for sandboxing its AI agents [2].

1. https://pyodide.org/en/stable/ 2. https://ai.pydantic.dev/mcp/run-python/

A plugin for Simon Willison's llm tool to support Structured Outputs using a simple YAML definition file.

Abstract:

As a matter of arithmetic, the trends of US government debt and deficits will eventually result in an outrageously high government debt-to-GDP ratio. But when exactly will the United States hit the constraint of infeasibility and how exactly will policy adjust to it? This article considers fiscal dominance, which is the possibility that accumulating government debt and deficits can produce increases in inflation that “dominate” central bank intentions to keep inflation low. Is it a serious possibility for the United States in the near future? And how might various policies change (especially those related to the banking system) if fiscal dominance became a reality?

This approach reminds me of RedisGraph[1] (which is now unfortunately EoL).

"RedisGraph is the first queryable Property Graph database to use sparse matrices to represent the adjacency matrix in graphs and linear algebra to query the graph."

1. https://github.com/RedisGraph/RedisGraph

Sounds like a perfect application for Micron/Intel's (yet to be widely commercialized) 3D XPoint[1] :) Although I find it highly unlikely a new Xbox would be the place to debut the technology.

Regardless, claimed latency is between DRAM and NAND, so I wonder if it would be performant enough for a gaming use case. To mikeash's point, 3D XPoint is byte-addressable, so perhaps it's possible...

[1] https://www.micron.com/products/advanced-solutions/3d-xpoint...

How does something like the U2F Zero[1] compare?

As I understand it, the u2f zero acts as an HID device and not as a smartcard provider, but could one modify the firmware to do that? Isn't this basically an open source yubikey you can make yourself for < $25?

1. https://github.com/conorpp/u2f-zero

Just going off memory, but something like this seems to work for me on rooted Android (or wherever your hosts file is):

curl http://someonewhocares.org/hosts/hosts > /system/etc/hosts

Of course all the normal disclaimer stuff, make sure you look at what you're putting in there, etc. But Mr. Pollock's list has worked wonders for me

Would love an invite! - kmadura AT googlemail