A general-purpose large language model can read, modify and write working machine code when it is given nothing but raw bytes, according to a set of experiments published as a blog post by researchers George Xenos and Sotiris Giannopoulos. The model received no disassembler, no compiler and no tools. It worked only from hexadecimal dumps.
The team tested the model, GPT-6.1 Sol, on three abilities: reading a program's bytes to say what it does, extending a program by editing those bytes, and writing a new executable from a plain-English description. They also tested it on a real malware sample. Each program was run through the model once, with no feedback and no second attempt, and the output was checked against a reference build compiled with GCC.
Reading came first. The model correctly identified what all four test programs did, using only their bytes. Three were written by the team, including a word counter and an AES encryption tool. The fourth was ministat, a statistics tool from FreeBSD, built with optimizations, linked statically, stripped of symbols and with its last three strings deliberately hidden.
The model found the decoding routine that hid those strings, recovered the tool's option list and described all eight options. It also spotted a bug the team had not expected. The tool's option labeled 99.5 percent confidence uses critical values for about 99.8 percent, which means that option applies a stricter test than it claims. The team confirmed the bug against the original source code, using Claude.
Patching and writing binaries
In the patching test, the model was asked to add one new feature to each of three programs. It replied with a list of byte edits, each the same length as the bytes it replaced. All three patched programs passed hidden tests for old behavior, new behavior and long inputs. The changes were small, touching between 1.4 and 5.9 percent of each program's bytes.
The model worked the way a human would patch a binary. It found unused padding, changed the segment headers so that space could run code, wrote new code there and redirected existing instructions to call it. For the word counter, that meant adding a fourth output number, the length of the longest line.
The writing test was harder. The model received a written specification and no hex. It had to produce a complete ELF64 program, headers included, with every byte. All three files ran and matched the reference build on every test case. The smallest was 391 bytes, compared with 5,432 bytes for the GCC build of the same word counter. The model worked out every jump, call and header field without an assembler. The team said the AES tool's lookup tables matched the AES standard exactly.
The malware test
In the final experiment, the model was given a 4,608-byte Windows executable with no hint that it was malicious. The file's only visible import was Sleep. Its other API calls were hidden behind name hashes, and its strings were assembled on the stack.
In 211 seconds, the model concluded that the file downloads machine code and runs it in memory. It named a hardcoded server and a port. The team later compared the report with a public VMRay sandbox analysis of the same file, identified by its SHA-256 hash. The sandbox contacted the same address and requested the same URL. The model also correctly identified all 13 API functions the sample used, after the team recomputed their hashes. The sandbox did not confirm a retry behavior the model described, or the single-byte XOR key.
The team cautioned that this was one sample and one run. They also noted that the hash-based technique is common in public tooling, so recognizing it may have helped the model.
In a separate test, the team ran the same malware prompt through a different tool, opencode, using DeepSeek V4.1 Flash, a model with public weights released under an MIT license. The model reached the same conclusion, that the sample downloads and runs code in memory. It identified 9 of the 13 API names and misread the marker-file check because of two naming errors. It used about 17 times as many reasoning tokens and took 859 seconds, compared with 211 seconds for GPT-6.1 Sol. The team called this preliminary evidence that the ability is not limited to closed models.
The authors say the biggest limit is size. A hex dump costs roughly 2.4 tokens per byte, so their 67 KB binary used about 163,000 tokens. A 10 MB program would need about 24 million tokens, which is beyond what this approach can handle. The team said it did not find a prior account of a general-purpose LLM patching and writing working executables with no tools, although its search was not exhaustive.
Dieser Artikel wurde mit Unterstützung von KI verfasst.
News Factory APP - agentische News für besseres SEO & AEO.