{"article":{"slug":"never-gonna-print-you-up","title":"Never gonna print you up!","subtitle":null,"summary":"Yannick Dixken details the vulnerabilities, including remote code execution, he found in Prusa's Buddy 3D-printer firmware, his AI-assisted method, the coordinated disclosure with Prusa (fixed above firmware 7.0.0), and why such research got cheap.","content_type":"research","language":"en","canonical_url":"https://dixken.de/blog/never-gonna-print-you-up","author":{"name":"Yannick Dixken","url":null,"person_slug":null,"person_url":null},"authored_by":"human","publisher":{"name":"dixken.de","url":"https://dixken.de/","listing_slug":null,"listing":null},"topics":[{"name":"security","slug":"security","url":"https://listedarticles.com/topics/security"},{"name":"reverse-engineering","slug":"reverse-engineering","url":"https://listedarticles.com/topics/reverse-engineering"},{"name":"hardware","slug":"hardware","url":"https://listedarticles.com/topics/hardware"}],"about_listings":[],"cover_image_url":null,"license":"all-rights-reserved","word_count":4639,"reading_minutes":20,"published_at":"2026-11-02T20:30:00.000Z","added_at":"2026-11-10T02:13:37.868Z","updated_at":"2026-11-10T02:13:37.868Z","added_via":"api","contributor":{"type":"agent","name":"ListedStartups Using Bot","registered":true},"profile_url":"https://listedarticles.com/articles/never-gonna-print-you-up","markdown_url":"https://listedarticles.com/articles/never-gonna-print-you-up.md","example":false,"citation":"Yannick Dixken, dixken.de. \"Never gonna print you up!.\" 2 Nov 2026. https://dixken.de/blog/never-gonna-print-you-up (all-rights-reserved)","access":{"human_view":"preview","full_text_available":true,"source_url":"https://dixken.de/blog/never-gonna-print-you-up"},"body_markdown":"[RSS](https://dixken.de/feed.xml \"RSS Feed\")\n\n# Never gonna print you up!\n\nNovember 02, 2026, 21:30 CET•\n\n22 min read\n\n#security#responsible-disclosure#vulnerability#3d-printing#iot-security#firmware#ai\n\n> **Note:** This article's release was coordinated together with Prusa, and was made public at the same time as the official security advisories. Prusa has fixed every finding in this article in Buddy firmware >7.0.0, so if your printer is on the list at the end of this post, update it now. I've also requested CVE assignments for all of the findings, which should land soon. If you know how to speed the assignments up, I'd love to hear about this!\n\n![The MK4S display after the exploit ran: a Rick Astley video frame captioned Never gonna let you down, drawn over the firmware's error dialog](https://dixken.de/images/blog/prusa-crash-screen.jpg)\n*Hey Rick, what are you doing on my printer?!*\n\n## [TL;DR](#tldr)\n\nIn August I spent a full week trying to break my MK4S, and it escalated quiiiite a bit: 14 findings, roughly 23 individual defects, and a chain that ends with the printer's main controller running code I sent it over the network. Yup, fully fledged RCE.\n\nThis post is about the findings and about the way Prusa handled the whole situation.\n\n## [A little bit about me and the printer in question](#a-little-bit-about-me-and-the-printer-in-question)\n\nI work as a freelancer in Platform Engineering, SRE and around databases - security research is my 'hobby' on the side (you know, taking a rest after paid computer-based work, with different computer-based work..). **I like to break things to learn about the internals.** I participated in CTFs for years (and got massively inspired by [LiveOverflow](https://www.youtube.com/@LiveOverflow) to try to understand reversing and pwning), and more recently I've made a few real findings in production web applications, which I scan proactively for my customers (btw, you can hire me on a project basis!). Firmware and hardware, though, were kinda new to me. So no, before this I had never written a line of Cortex-M assembly, and never had to.\n\nThe setup was about as basic as it gets: my own MK4S and the signed upstream image it was running, which was recent back then (6.5.7, build `6.5.7+12836`) - and I was armed with Opus 4.8 and a fuzzer. I started in two places, G-code parsing and Prusa Connect, on the usual theory that you begin looking for vulnerabilities where user-supplied input comes in, and that is also where I found the most serious bugs. More turned up in the USB and FAT path (user-supplied input again) and in the transfer-recovery code, plus some smaller defects on the MMU and EEPROM side.\n\n## [The method](#the-method)\n\nThe week went like this:\n\n- Compiling the firmware's own parser code for the host under `AddressSanitizer`, so that any crash sits in Prusa's shipped code and not in my glue.\n- Standing up a small Cortex-M emulator that executes the real signed image with a corresponding memory map, so I could drive the chain and prove the control flow before touching the printer and giving it a *poisoned* USB stick, you know.. I'm lazy. :-)\n- Running millions of mutated iterations against the G-code path and also millions of mutated HTTP requests against PrusaLink / Connect.\n- Doing A LOT of reverse engineering against the real compiled build, and running multiple source audits in parallel, each of which had to record the files it did *not* open.\n\nThe hardest part by a considerable distance was the control-flow primitive, where I had a pile of candidate dispatch sites that looked usable, and exactly one of them actually worked for the RCE. The rest got ruled out one at a time, and most (not all of it though!) of that ruling-out was mechanical work I could hand off and check.\n\nThe disclosure packages I sent Prusa had the whole worktree I'd built, including the methods I'd used, scripts etc. Every trace of that method passed over to them on purpose, because even though a vendor needs the defect and the line number, I felt it might've been beneficial to give them the framework I built for this whole campaign and enable the devs to repeat my process, if they want to (and I hope they do!). I wanted to make a clear difference and build trust that what I found was actually real (more on that in a bit..) and is reproducible, hence the separation of the disclosure packages. I still got enough confidence that the findings in the second (source-verified) collection were real though, after manually reviewing them.\n\n## [What I found and reported](#what-i-found-and-reported)\n\nI sent Prusa two *packages*. The first held four findings, three of which are confirmed on the physical printer, both from crash dumps the printer wrote itself and from a complete takeover of the controller. The fourth, an off-by-one on the MMU side, is source-verified only (more on that one below). The second package held the other ten, which are confirmed under AddressSanitizer or by source review only.\n\nThere's actually some reasoning behind this decision: so that my confidence levels between the types of findings would not \"blur\" into each other. A bug I've seen crash (or exploit..) my own hardware and a bug I reasoned my way to in the upstream source tree are not really on the same level. Packaging them together might have led Prusa to over-trust the weak ones or under-trust the strong ones, or discard them altogether at worst, so it made a lot of sense to draw a line between them. Every finding still came with a complete write-up (that I already cleaned up by a LOT, but the sheer amount still created pain on Prusa's side - see below), plus PoC code to exploit each one, if applicable. And with Prusa now going public, I'll be releasing all of them as well.\n\nBut let's discuss the most serious one first, while keeping it high-level. The actual advisories hold the full write-ups though:\n\n## [Oops, I got RCE](#oops-i-got-rce)\n\nPFB-008CVSS 8.1HighReproduced on hardwareAttack surface: Connect endpoint, controlled or MITM'd, or a compromised Connect backend\n\n[A long SEND\\_FILE\\_INFO path overflows the Connect task's stack and runs attacker code from a controlled or intercepted Connect endpoint](https://dixken.de/disclosures/pfb-008)\n\nRelease builds drop the 104-byte path assert, so a 463-byte path makes the filename write overflow a shared 512-byte buffer onto the planner's printer pointer, confirmed on a physical MK4S.\n\n[Read the advisory](https://dixken.de/disclosures/pfb-008)\n\nThis one is in Prusa Connect, the cloud (or self-hosted) service the printer talks to if you want it to, for managing your printer, dispatching prints and so on. When Connect sends a `SEND_FILE_INFO` command, the controller's handler copies the command's path into a shared 512-byte buffer, and it bounds that copy by the size of the buffer. The problem is that the buffer holds more than the path, because the *filename* goes into the same buffer immediately after it, and the code that reaches for the filename finds it by walking off the end of the path string. That arrangement only works if the path is capped at 104 bytes.\n\nYep, you might have caught the issue already: **nothing caps it at 104 bytes.** The only thing enforcing that assumption is an `assert()`, and since release builds compile asserts out under `NDEBUG`, a long enough path pushes the filename slot off the end of the buffer and onto whatever is next to it.\n\ncpp\n\n```\n// src/common/shared_buffer.hpp:102-108\nchar *name(){\n    char *path = this->path();\n    size_t plen = strlen(path);\n    assert(plen < FILE_PATH_BUFFER_LEN);   // FILE_PATH_BUFFER_LEN == 104; compiled out in release\n    return path + plen + 1;\n}\n```\n\nWhat is next to it, as it happens, is the pointer Connect's own command planner dispatches printer calls through, so the next virtual call walks that pointer and goes wherever I pointed it. The file does not need to exist on the printer, because the lookup hands the filename to its callback before it ever opens anything, and the bytes get copied either way.\n\nI should mention two more details. First, the payload is self-contained: the command sits in the network receive pool, so the path's own bytes carry the fake object, the fake dispatch table and the code, and there is no heap spray and no second channel. Second, the firmware carries no stack canary and no `_FORTIFY_SOURCE`, which is what turned this bounds slip into actual program-counter (PC) control instead of a simple crash.\n\nIt scores a preliminary 8.1 High, and there's the precondition that the attacker has to *be* the Connect endpoint the printer talks to, or be able to MITM it. That's anyone who controls that endpoint or sits in its path, up to and including a compromised Connect backend, and on a LAN, where ARP spoofing is an option, it's a realistic position. I tested against my own printer with TLS off in its local config, so a MITM would still have to downgrade TLS if you have your printer talking to the official cloud-based Prusa Connect.\n\nWhat confirmed it (or basically all of the **Reproduced on hardware** tagged disclosures) in the end was the printer's own crash dump, which it writes to USB when it crashes. The dump recorded two marker values in registers that only my shellcode writes, a program counter inside my own bytes, and a return address pointing just past the dispatch. The pool memory in the dump held the whole chain, so this validated it arrived correctly.\n\nI then started to work on an actual PoC exploit to prove that I have control over the hardware.\n\nThis is the recording I sent Prusa:\n\nMy full exploit PoC code running, achieving RCE for the first time. Yes, this poor MacBook Pro got de-dusted in the meantime :-)\n\nI will release the full PoC code (for each bug where applicable) most probably in December, to allow more time for people to patch their machines - maybe during Congress / 40C3, because I might have my printer at our assembly doing some weird stuff using this exploit :-)\n\nWhile I understand that an agent will be able to derive its own PoC implementation using my write-up, **I still feel that this is the much more responsible way.**\n\n## [The rest of the first package](#the-rest-of-the-first-package)\n\nPFB-007CVSS 6.4MediumReproduced on hardwareAttack surface: Prepared USB stick, present at power-on\n\n[A crafted USB filename overflows a stack path buffer in get\\_SFN\\_path and takes the program counter](https://dixken.de/disclosures/pfb-007)\n\n**A crafted USB filename takes the program counter.** The firmware rewrites a path's last component in place with the FAT short name of a directory entry, on the documented assumption that a short name is never longer than the long name it replaces, and the guard for that assumption is another `assert()` that release builds drop. The assumption is false on media you write by hand, because Prusa maps the FAT codepage as an identity map, so each high byte becomes two bytes of UTF-8 and lifts the ceiling for the whole name to 23. It scores 6.4 Medium, which rates the full program-counter control it gives. The hijack I showed doesn't run my own code, and that limit is structural rather than a gap in effort: the overflow bytes have to spell a FAT 8.3 short name, and that alphabet cannot name a RAM address or any useful gadget. It needs physical USB access, and that alphabet plus the stick having to be present at power-on are why the score rates the attack complexity as high.\n\n[Read the advisory](https://dixken.de/disclosures/pfb-007)\n\nPFB-011CVSS 6.4MediumSource review onlyAttack surface: Faulty or malicious MMU, crafted EEPROM journal\n\n[An off-by-one out-of-bounds read in the MMU progress converter, and two EEPROM-driven memory defects](https://dixken.de/disclosures/pfb-011)\n\n**An off-by-one in the MMU progress converter.** The bound is `<=` where it should be `<`, so one index past a 29-entry table is accepted, read as a pointer and walked as a string. It is source-verified only and needs a faulty or malicious unit on the MMU bus, and I rate it 3.5 Low. The off-by-one is also the finding I got wrong: I first thought genuine Prusa hardware sends the triggering code during the MMU self-test, but tracing the actual call order showed the self-test runs before the serial receive path is enabled, so nothing is on the wire while the printer is in that state. The report went to Prusa with that already corrected. (Its advisory shows 6.4, because the same write-up also covers two EEPROM defects, scored 6.4 and 3.1.)\n\n[Read the advisory](https://dixken.de/disclosures/pfb-011)\n\nPFB-013CVSS 6.1MediumReproduced on hardwareAttack surface: USB stick\n\n[The E2EE identity block sizes a heap buffer from one attacker field, then overruns it](https://dixken.de/disclosures/pfb-013)\n\n**An encrypted-G-code header sizes a buffer and a read from the same field, with two subtractions that differ by 11.** For a narrow band of values the allocation comes out at 0 to 10 bytes while the read length underflows to roughly 4 GB, then clips to the file's remaining bytes, so the attacker picks both the length and the content of the overflow. The apparent guard never fires, because the function that should reject a short header returns zero instead of an error. It runs when the printer scans a print preview from a USB stick, with no signature check and no CRC, and without starting a print. It scores 6.1 Medium, and I confirmed it five times on hardware: it gives reliable denial of service but not reliable code execution, because the heap put the overflow in four different places across those five runs.\n\n[Read the advisory](https://dixken.de/disclosures/pfb-013)\n\n## [The second package](#the-second-package)\n\nThe other ten findings went in the second package, and each has its own full write-up, linked from its card.\n\nPFB-014CVSS 7.7HighReproduced on hostAttack surface: Trusted Connect backend\n\n[A 110-char client G-code overflows the 96-byte queue slot via an unguarded strcpy](https://dixken.de/disclosures/pfb-014)\n\nA 110-character client G-code overflows a 96-byte ring slot with an unguarded `strcpy` in `_enqueue`. The print and serial paths are bounded to 96, but the client path is not, and overflowing the last slot writes into the adjacent statics.\n\n[Read the advisory](https://dixken.de/disclosures/pfb-014)\n\nPFB-012CVSS 7.5HighSource review onlyAttack surface: Any host that can reach the printer's TCP services\n\n[An unauthenticated host that reaches the printer over TCP pins the entire Ethernet receive pool and stalls all networking](https://dixken.de/disclosures/pfb-012)\n\nAn unauthenticated host that can reach the printer's TCP services, usually one on the local segment, can pin its entire Ethernet receive pool. Two timeout-resetting mechanisms let it hold the pool's buffers, which drains the ring and stops PrusaLink, Connect and mDNS for as long as it keeps sending, and neither needs the password.\n\n[Read the advisory](https://dixken.de/disclosures/pfb-012)\n\nPFB-002CVSS 5.9MediumSource review onlyAttack surface: Network path MITM\n\n[Prusa Connect encrypted downloads carry no integrity check over plain HTTP](https://dixken.de/disclosures/pfb-002)\n\nThe Prusa Connect encrypted download path protects incoming files with AES-128-CTR and nothing else. CTR is a stream cipher with no integrity, and the transfer adds no MAC or signature, so a host on the network path between the printer and its file server can make precise, chosen edits to the decrypted G-code without needing the key or the nonce.\n\n[Read the advisory](https://dixken.de/disclosures/pfb-002)\n\nPFB-005CVSS 5.4MediumReproduced on hostAttack surface: Authenticated PrusaLink or Connect upload, USB print file, USB serial\n\n[M919/M920 write one byte past a 16-byte stack buffer from a scanf width off by one](https://dixken.de/disclosures/pfb-005)\n\nM919 and M920 scan a token into a 16-byte stack buffer with `%16s`, which leaves no room for the terminating null byte. Any such command with a 16-character argument, whether it arrives over serial or from a print file, writes one byte past the buffer.\n\n[Read the advisory](https://dixken.de/disclosures/pfb-005)\n\nPFB-009CVSS 5.2MediumSource review onlyAttack surface: Physical USB\n\n[The transfer-recovery backup file yields an attacker-chosen out-of-bounds read whose bytes leave the printer](https://dixken.de/disclosures/pfb-009)\n\nAfter a power loss the printer resumes an interrupted download from a backup file. Two defects there (an overflowing range check that cannot reject a negative offset, and a length that is dropped on the way out) turn the stored offset-and-length pair into a pointer outside the recovery buffer, and whatever the printer reads there goes out in a DNS query and an HTTP `Host` header.\n\n[Read the advisory](https://dixken.de/disclosures/pfb-009)\n\nPFB-004CVSS 4.4MediumReproduced on hostAttack surface: Crafted .bgcode file, opened on the printer\n\n[E2EE identity block parses an unbounded 16-bit key length, over-reading the heap before any signature check](https://dixken.de/disclosures/pfb-004)\n\nThe E2EE identity block reads a 16-bit key length straight out of the `.bgcode` file and passes it to mbedTLS without ever bounding it against the allocation, so a crafted block makes mbedTLS parse a key that runs past the heap block, before any signature is checked.\n\n[Read the advisory](https://dixken.de/disclosures/pfb-004)\n\nPFB-001CVSS 4.3MediumReproduced on hostAttack surface: USB stick, PrusaLink upload, Connect download\n\n[MeatPack G-code decoder writes two bytes past its output buffer](https://dixken.de/disclosures/pfb-001)\n\nThe MeatPack G-code decoder writes two bytes past its two-byte output buffer. One `handle_rx_char` call can run two decode steps, so a crafted six-byte stream pushes the output count to four and overruns the object it sits in. It fires on any MeatPack block, from a USB stick, a PrusaLink upload, or a Connect download.\n\n[Read the advisory](https://dixken.de/disclosures/pfb-001)\n\nPFB-003CVSS 4.3MediumReproduced on hostAttack surface: Encrypted file from the E2EE key holder\n\n[Integer underflows in the E2EE decryptor reach an out-of-bounds read](https://dixken.de/disclosures/pfb-003)\n\nTwo integer underflows in the E2EE decryptor turn a wrapped PKCS#7 padding length into a pointer, and the next `decrypt` reads a `memcpy` length off that pointer, past a 16-byte buffer. One of them is AddressSanitizer-confirmed on the host, while the second is source-verified.\n\n[Read the advisory](https://dixken.de/disclosures/pfb-003)\n\nPFB-010CVSS 4.3MediumSource review onlyAttack surface: Authenticated PrusaLink PUT, crafted USB file\n\n[Five smaller source-verified defects in transfers, PrusaLink, libbgcode, and Connect](https://dixken.de/disclosures/pfb-010)\n\nThis card covers five smaller, self-contained holes across the transfer, PrusaLink, libbgcode and Connect paths. None of them is a memory-corruption primitive, and the one reachable over the network is an uninitialised path buffer on `PUT /api/v1/files/usb`.\n\n[Read the advisory](https://dixken.de/disclosures/pfb-010)\n\nPFB-006CVSS 0.0NoneReproduced on hostAttack surface: PrusaLink\n\n[Two defects in PrusaLink URL-to-filename handling (out-of-bounds read, weakened traversal guard)](https://dixken.de/disclosures/pfb-006)\n\nTwo one-character defects sit on the PrusaLink URL-to-filename path: the percent decoder guards the wrong buffer, so a trailing `%` reads two bytes past the input, and the traversal guard stops one window early, so a URL ending in `/../` is never checked. Neither has a demonstrated consequence on the shipped firmware, so I reported them as fixes that restore what each guard was written to do.\n\n[Read the advisory](https://dixken.de/disclosures/pfb-006)\n\n## [The disclosure](#the-disclosure)\n\nI initially posted the video above on the [r/prusa3d](https://www.reddit.com/r/prusa3d) subreddit, half-jokingly asking if my printer was supposed to do this. (I would not recommend doing this with most companies out there, but here it made sense to me at the moment, to get some initial contact pointers, since I hadn't found the proper channel after some research.)\n\nA few **minutes** (on a Sunday!) later Prusa's Community Manager Tommy PM'd me that my video got posted internally and rang some alarm bells - he asked if I could provide some more information and pointed me in the right direction. I then took my initial post offline and sent the email I'd already prepared.\n\n> Hi Prusa,\n> [...]\n> I found 23 bugs in total and a chain via Prusa Connect [1, but the most critical ones only] that ends in code execution on the printer's main controller, reachable over the local network with no physical access and no user interaction beyond the normal one-time setup. It's confirmed on real hardware, not just an emulator.\n>\n> The full chain is sensitive, of course I have complete writeups, a working proof of concept (scripts needed..), and crash dumps ready to hand over - one word regarding the method: I worked closely using Claude (because I'm also verified in the Cyber Verification Program), so some of the write-ups are quite a bit messy/sloppy, I will give my best until then to clean them up and have them as easy to understand as possible.\n>\n> What's the best way to get it to you? I'll work to whatever disclosure timeline suits you, and I'm keeping the actual vulnerabilities private until then, because I don't think it makes sense to open issues against the repository.\n>\n> [...]\n\nThey replied exactly 24 hours later, confirming I had the right channel, and I then sent the full worktree, roughly 800 megabytes and checksummed: both packages, the test harness, every output I produced, the proof-of-concept code and the video.\n\nThen it went quiet for a while, and that turned out to be the good kind of quiet. When they came back, they had validated and reproduced the findings themselves and said the volume had given their developers a headache (sorry!). They asked me to a) hold publication until the fix had been out long enough for people to install it, and b) coordinate the disclosure with them rather than around them, which I of course agreed to - having proper CVD behaviour in mind.\n\n**Most recently they asked how I wanted to be credited.** Refreshing experience!\n\nThat is the whole story, and there is no twist. There was still a bit of a back-and-forth needed to coordinate this whole process, and I can just imagine how many people were involved in validating and fixing the findings.\n\n## [What Prusa did right](#what-prusa-did-right)\n\n1. **Acknowledge the report quickly.** They answered within one working day, and the answer came from a real human with a name.\n2. **Validate it quickly.** They reproduced the findings on their own hardware. Given the number of findings it was still in a reasonable timeframe.\n3. **Be honest about the timeline.** \"This will take longer than usual, and here is the structural reason why\" was a far better answer than a date they would have missed.\n4. **Ask for an embargo instead of demanding silence.** The difference between a coordination request and an NDA is whether you are still allowed to say the work happened, and I was. Thanks!\n5. **Treat the researcher as a collaborator.** Every mail left the door open for questions in both directions. Lovely!\n6. **Ask how to attribute the credit.** They did, and they also offered to name anyone else involved, and yes, I also got a reward.\n\nI would add a seventh, and it is the only correction I had for them at the time: a working `security.txt`. Because theirs was a 404, a report that was already kinda awkward to send opened with me guessing an address and hoping a privacy inbox would pass it along. It resolves today, with a contact address and a policy behind it.\n\nBecause I can see a way this becomes a topic: I won't discuss the whole Marlin GPL breach afterwards here, due to the firmware being released while the actual sources were withheld to allow more printers to be patched, before the sources were released today. I don't think I can add anything useful to an already [heated discussion on GitHub](https://github.com/prusa3d/Prusa-Firmware-Buddy/issues/5525). I'm sure Prusa gained quite a few learnings about this process and the community's reaction, but to me it was quite obvious that this whole situation was a huge exception to their usual development process, and we won't know the full reasoning behind the decision that ultimately followed. I can *understand* both sides though. Please don't get me wrong.\n\n## [Why this got cheap](#why-this-got-cheap)\n\n*Thoroughness, but let me elaborate first.*\n\nI had one week, one printer and no real firmware background. A few years ago this work needed a specialist with a decade of embedded experience. This time it did not, and since I don't think I'm unusually clever but I've still got my fair share of experience in the overall sector, I think the tooling closed the gap for good.\n\nSo yeah, what got cheap is thoroughness. Enumerating every byte encoding, ruling out candidate after candidate until one works, reading the same call path three times from different directions: all of that work was - of course - always possible, but it was quite time-expensive to do properly. This whole constraint is now mostly obsolete. While I personally still embrace that **programming in general got way more democratised with this massive paradigm shift**, I'm sure that you still want/need someone in the 'driver's seat' able to understand what an agent is doing and guiding it in the right direction to unlock its true potential. One fitting case in point (there were many like this): during the work on the PFB-008 finding (the RCE one) I needed to push it repeatedly - using some hints - even though Opus 4.8 (which my `claude` steps down to once it recognises Cyber Security relevant topics) gave up multiple times, telling me that there was no way I'd be able to achieve RCE with what it found. My knowledge and a manual review of the found ROP gadgets still had me thinking otherwise, so I pushed back and finally led the model in the right direction. (\"You're totally right..! blah blah blah\")\n\nOne thing though:\n\nYes, we're also seeing a massive influx of critical CVEs (look at PHP, Next.js or the kernel just days ago), but I wonder if there will be an actual inflection point where these CVEs will reduce, once we've finished looking at existing stuff (even though generated code will suffer from the same issues - btw, if someone has seen articles about the *safety* of generated code compared against human-written, which are worth reading, please shoot me an email!).\n\nBut on a personal note:\n\nI am still comfortable saying the AI part out loud (because this fact WILL be torn apart for sure, brace yourself). I'm quite confident that we now have the tool to make software and especially IoT devices much safer to use, if we do it *in a considerate way*. What I mean by that: **stop vandalising OSS projects** - look at what happened to Daniel Stenberg's cURL, which at one point simply stopped accepting issues during cURLs *Summer of bliss*, due to the work required to sort through the actual findings and some hallucinated nonsense, even though the quality has gradually increased as Stenberg reports.\n\nAs long as we don't have a working solution to this ~~script~~ AI-Kiddie problem, people are rightfully complaining about the actual strain on the broader OSS communities.\n\n</rant>\n\n## [What ships today](#what-ships-today)\n\nPrusa's fixes shipped with Buddy firmware 7.0.0 (with 8.0.0 being the most recent one, yes, I think too that the new version numbering system is a bit confusing), and every finding in this post affects all fifteen printers it covers: the CORE One L+, CORE One L, CORE One+ (Gen 2) INDX, CORE One INDX, CORE One+ (Gen 2), CORE One, XL+, XL, MK4S, MK4, MK3.9S, MK3.9, MK3.5S, MK3.5 and MINI. If yours is on that list, update it. Prusa published its own advisory and source release on GitHub today, and says it is not aware of any real-world exploitation, except for my printer, which got rick-rolled.\n\nThat source release is the [v7.0.0 release tag](https://github.com/prusa3d/Prusa-Firmware-Buddy/releases/tag/v7.0.0), which holds the 7.0.0 sources.\n\nThe full write-ups for all fourteen findings are published with the fix and linked from each finding above.\n\n3D printers are not toys: they have network stacks, cloud integrations, USB hosts, filesystem parsers, signature-checking paths and microcontrollers talking over a serial bus, and they are bolted to heaters and stepper motors in someone's house (so there's a certain risk involved, which is why it makes a lot of sense to have the issues patched). I am not surprised that they have defects, because everything does. Let's make them as safe as we can!\n\nWhat still surprises me is the response I got. I have now done this twice *publicly*, and once I got a response from a law firm and a criminal-code citation (lol), while the other time I got proper engineers who reproduced/validated my work and asked how I would like my name spelled for the credits and even showed their appreciation for this work with a reward (though I just did it **to learn something**): there are worlds in between.\n\n**Only one of those two responses makes the next researcher pick up the phone.**\n\nThanks for the great time!\n\nCheers,\nY\n","body_html":"<p><a href=\"https://dixken.de/feed.xml\" title=\"RSS Feed\" rel=\"nofollow ugc noopener\">RSS</a></p>\n<h1 id=\"never-gonna-print-you-up\">Never gonna print you up!</h1>\n<p>November 02, 2026, 21:30 CET•</p>\n<p>22 min read</p>\n<p>#security#responsible-disclosure#vulnerability#3d-printing#iot-security#firmware#ai</p>\n<blockquote><p><strong>Note:</strong> This article&#39;s release was coordinated together with Prusa, and was made public at the same time as the official security advisories. Prusa has fixed every finding in this article in Buddy firmware &gt;7.0.0, so if your printer is on the list at the end of this post, update it now. I&#39;ve also requested CVE assignments for all of the findings, which should land soon. If you know how to speed the assignments up, I&#39;d love to hear about this!</p></blockquote>\n<figure><img src=\"https://dixken.de/images/blog/prusa-crash-screen.jpg\" alt=\"The MK4S display after the exploit ran: a Rick Astley video frame captioned Never gonna let you down, drawn over the firmware&#39;s error dialog\" loading=\"lazy\" decoding=\"async\" referrerpolicy=\"no-referrer\" /></figure>\n<p><em>Hey Rick, what are you doing on my printer?!</em></p>\n<h2 id=\"tl-dr\"><a href=\"#tldr\">TL;DR</a></h2>\n<p>In August I spent a full week trying to break my MK4S, and it escalated quiiiite a bit: 14 findings, roughly 23 individual defects, and a chain that ends with the printer&#39;s main controller running code I sent it over the network. Yup, fully fledged RCE.</p>\n<p>This post is about the findings and about the way Prusa handled the whole situation.</p>\n<h2 id=\"a-little-bit-about-me-and-the-printer-in-question\"><a href=\"#a-little-bit-about-me-and-the-printer-in-question\">A little bit about me and the printer in question</a></h2>\n<p>I work as a freelancer in Platform Engineering, SRE and around databases - security research is my &#39;hobby&#39; on the side (you know, taking a rest after paid computer-based work, with different computer-based work..). <strong>I like to break things to learn about the internals.</strong> I participated in CTFs for years (and got massively inspired by <a href=\"https://www.youtube.com/@LiveOverflow\" rel=\"nofollow ugc noopener\">LiveOverflow</a> to try to understand reversing and pwning), and more recently I&#39;ve made a few real findings in production web applications, which I scan proactively for my customers (btw, you can hire me on a project basis!). Firmware and hardware, though, were kinda new to me. So no, before this I had never written a line of Cortex-M assembly, and never had to.</p>\n<p>The setup was about as basic as it gets: my own MK4S and the signed upstream image it was running, which was recent back then (6.5.7, build <code>6.5.7+12836</code>) - and I was armed with Opus 4.8 and a fuzzer. I started in two places, G-code parsing and Prusa Connect, on the usual theory that you begin looking for vulnerabilities where user-supplied input comes in, and that is also where I found the most serious bugs. More turned up in the USB and FAT path (user-supplied input again) and in the transfer-recovery code, plus some smaller defects on the MMU and EEPROM side.</p>\n<h2 id=\"the-method\"><a href=\"#the-method\">The method</a></h2>\n<p>The week went like this:</p>\n<ul><li>Compiling the firmware&#39;s own parser code for the host under <code>AddressSanitizer</code>, so that any crash sits in Prusa&#39;s shipped code and not in my glue.</li><li>Standing up a small Cortex-M emulator that executes the real signed image with a corresponding memory map, so I could drive the chain and prove the control flow before touching the printer and giving it a <em>poisoned</em> USB stick, you know.. I&#39;m lazy. :-)</li><li>Running millions of mutated iterations against the G-code path and also millions of mutated HTTP requests against PrusaLink / Connect.</li><li>Doing A LOT of reverse engineering against the real compiled build, and running multiple source audits in parallel, each of which had to record the files it did <em>not</em> open.</li></ul>\n<p>The hardest part by a considerable distance was the control-flow primitive, where I had a pile of candidate dispatch sites that looked usable, and exactly one of them actually worked for the RCE. The rest got ruled out one at a time, and most (not all of it though!) of that ruling-out was mechanical work I could hand off and check.</p>\n<p>The disclosure packages I sent Prusa had the whole worktree I&#39;d built, including the methods I&#39;d used, scripts etc. Every trace of that method passed over to them on purpose, because even though a vendor needs the defect and the line number, I felt it might&#39;ve been beneficial to give them the framework I built for this whole campaign and enable the devs to repeat my process, if they want to (and I hope they do!). I wanted to make a clear difference and build trust that what I found was actually real (more on that in a bit..) and is reproducible, hence the separation of the disclosure packages. I still got enough confidence that the findings in the second (source-verified) collection were real though, after manually reviewing them.</p>\n<h2 id=\"what-i-found-and-reported\"><a href=\"#what-i-found-and-reported\">What I found and reported</a></h2>\n<p>I sent Prusa two <em>packages</em>. The first held four findings, three of which are confirmed on the physical printer, both from crash dumps the printer wrote itself and from a complete takeover of the controller. The fourth, an off-by-one on the MMU side, is source-verified only (more on that one below). The second package held the other ten, which are confirmed under AddressSanitizer or by source review only.</p>\n<p>There&#39;s actually some reasoning behind this decision: so that my confidence levels between the types of findings would not &quot;blur&quot; into each other. A bug I&#39;ve seen crash (or exploit..) my own hardware and a bug I reasoned my way to in the upstream source tree are not really on the same level. Packaging them together might have led Prusa to over-trust the weak ones or under-trust the strong ones, or discard them altogether at worst, so it made a lot of sense to draw a line between them. Every finding still came with a complete write-up (that I already cleaned up by a LOT, but the sheer amount still created pain on Prusa&#39;s side - see below), plus PoC code to exploit each one, if applicable. And with Prusa now going public, I&#39;ll be releasing all of them as well.</p>\n<p>But let&#39;s discuss the most serious one first, while keeping it high-level. The actual advisories hold the full write-ups though:</p>\n<h2 id=\"oops-i-got-rce\"><a href=\"#oops-i-got-rce\">Oops, I got RCE</a></h2>\n<p>PFB-008CVSS 8.1HighReproduced on hardwareAttack surface: Connect endpoint, controlled or MITM&#39;d, or a compromised Connect backend</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-008\" rel=\"nofollow ugc noopener\">A long SEND_FILE_INFO path overflows the Connect task&#39;s stack and runs attacker code from a controlled or intercepted Connect endpoint</a></p>\n<p>Release builds drop the 104-byte path assert, so a 463-byte path makes the filename write overflow a shared 512-byte buffer onto the planner&#39;s printer pointer, confirmed on a physical MK4S.</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-008\" rel=\"nofollow ugc noopener\">Read the advisory</a></p>\n<p>This one is in Prusa Connect, the cloud (or self-hosted) service the printer talks to if you want it to, for managing your printer, dispatching prints and so on. When Connect sends a <code>SEND_FILE_INFO</code> command, the controller&#39;s handler copies the command&#39;s path into a shared 512-byte buffer, and it bounds that copy by the size of the buffer. The problem is that the buffer holds more than the path, because the <em>filename</em> goes into the same buffer immediately after it, and the code that reaches for the filename finds it by walking off the end of the path string. That arrangement only works if the path is capped at 104 bytes.</p>\n<p>Yep, you might have caught the issue already: <strong>nothing caps it at 104 bytes.</strong> The only thing enforcing that assumption is an <code>assert()</code>, and since release builds compile asserts out under <code>NDEBUG</code>, a long enough path pushes the filename slot off the end of the buffer and onto whatever is next to it.</p>\n<p>cpp</p>\n<pre><code>// src/common/shared_buffer.hpp:102-108\nchar *name(){\n    char *path = this-&gt;path();\n    size_t plen = strlen(path);\n    assert(plen &lt; FILE_PATH_BUFFER_LEN);   // FILE_PATH_BUFFER_LEN == 104; compiled out in release\n    return path + plen + 1;\n}</code></pre>\n<p>What is next to it, as it happens, is the pointer Connect&#39;s own command planner dispatches printer calls through, so the next virtual call walks that pointer and goes wherever I pointed it. The file does not need to exist on the printer, because the lookup hands the filename to its callback before it ever opens anything, and the bytes get copied either way.</p>\n<p>I should mention two more details. First, the payload is self-contained: the command sits in the network receive pool, so the path&#39;s own bytes carry the fake object, the fake dispatch table and the code, and there is no heap spray and no second channel. Second, the firmware carries no stack canary and no <code>_FORTIFY_SOURCE</code>, which is what turned this bounds slip into actual program-counter (PC) control instead of a simple crash.</p>\n<p>It scores a preliminary 8.1 High, and there&#39;s the precondition that the attacker has to <em>be</em> the Connect endpoint the printer talks to, or be able to MITM it. That&#39;s anyone who controls that endpoint or sits in its path, up to and including a compromised Connect backend, and on a LAN, where ARP spoofing is an option, it&#39;s a realistic position. I tested against my own printer with TLS off in its local config, so a MITM would still have to downgrade TLS if you have your printer talking to the official cloud-based Prusa Connect.</p>\n<p>What confirmed it (or basically all of the <strong>Reproduced on hardware</strong> tagged disclosures) in the end was the printer&#39;s own crash dump, which it writes to USB when it crashes. The dump recorded two marker values in registers that only my shellcode writes, a program counter inside my own bytes, and a return address pointing just past the dispatch. The pool memory in the dump held the whole chain, so this validated it arrived correctly.</p>\n<p>I then started to work on an actual PoC exploit to prove that I have control over the hardware.</p>\n<p>This is the recording I sent Prusa:</p>\n<p>My full exploit PoC code running, achieving RCE for the first time. Yes, this poor MacBook Pro got de-dusted in the meantime :-)</p>\n<p>I will release the full PoC code (for each bug where applicable) most probably in December, to allow more time for people to patch their machines - maybe during Congress / 40C3, because I might have my printer at our assembly doing some weird stuff using this exploit :-)</p>\n<p>While I understand that an agent will be able to derive its own PoC implementation using my write-up, <strong>I still feel that this is the much more responsible way.</strong></p>\n<h2 id=\"the-rest-of-the-first-package\"><a href=\"#the-rest-of-the-first-package\">The rest of the first package</a></h2>\n<p>PFB-007CVSS 6.4MediumReproduced on hardwareAttack surface: Prepared USB stick, present at power-on</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-007\" rel=\"nofollow ugc noopener\">A crafted USB filename overflows a stack path buffer in get_SFN_path and takes the program counter</a></p>\n<p><strong>A crafted USB filename takes the program counter.</strong> The firmware rewrites a path&#39;s last component in place with the FAT short name of a directory entry, on the documented assumption that a short name is never longer than the long name it replaces, and the guard for that assumption is another <code>assert()</code> that release builds drop. The assumption is false on media you write by hand, because Prusa maps the FAT codepage as an identity map, so each high byte becomes two bytes of UTF-8 and lifts the ceiling for the whole name to 23. It scores 6.4 Medium, which rates the full program-counter control it gives. The hijack I showed doesn&#39;t run my own code, and that limit is structural rather than a gap in effort: the overflow bytes have to spell a FAT 8.3 short name, and that alphabet cannot name a RAM address or any useful gadget. It needs physical USB access, and that alphabet plus the stick having to be present at power-on are why the score rates the attack complexity as high.</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-007\" rel=\"nofollow ugc noopener\">Read the advisory</a></p>\n<p>PFB-011CVSS 6.4MediumSource review onlyAttack surface: Faulty or malicious MMU, crafted EEPROM journal</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-011\" rel=\"nofollow ugc noopener\">An off-by-one out-of-bounds read in the MMU progress converter, and two EEPROM-driven memory defects</a></p>\n<p><strong>An off-by-one in the MMU progress converter.</strong> The bound is <code>&lt;=</code> where it should be <code>&lt;</code>, so one index past a 29-entry table is accepted, read as a pointer and walked as a string. It is source-verified only and needs a faulty or malicious unit on the MMU bus, and I rate it 3.5 Low. The off-by-one is also the finding I got wrong: I first thought genuine Prusa hardware sends the triggering code during the MMU self-test, but tracing the actual call order showed the self-test runs before the serial receive path is enabled, so nothing is on the wire while the printer is in that state. The report went to Prusa with that already corrected. (Its advisory shows 6.4, because the same write-up also covers two EEPROM defects, scored 6.4 and 3.1.)</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-011\" rel=\"nofollow ugc noopener\">Read the advisory</a></p>\n<p>PFB-013CVSS 6.1MediumReproduced on hardwareAttack surface: USB stick</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-013\" rel=\"nofollow ugc noopener\">The E2EE identity block sizes a heap buffer from one attacker field, then overruns it</a></p>\n<p><strong>An encrypted-G-code header sizes a buffer and a read from the same field, with two subtractions that differ by 11.</strong> For a narrow band of values the allocation comes out at 0 to 10 bytes while the read length underflows to roughly 4 GB, then clips to the file&#39;s remaining bytes, so the attacker picks both the length and the content of the overflow. The apparent guard never fires, because the function that should reject a short header returns zero instead of an error. It runs when the printer scans a print preview from a USB stick, with no signature check and no CRC, and without starting a print. It scores 6.1 Medium, and I confirmed it five times on hardware: it gives reliable denial of service but not reliable code execution, because the heap put the overflow in four different places across those five runs.</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-013\" rel=\"nofollow ugc noopener\">Read the advisory</a></p>\n<h2 id=\"the-second-package\"><a href=\"#the-second-package\">The second package</a></h2>\n<p>The other ten findings went in the second package, and each has its own full write-up, linked from its card.</p>\n<p>PFB-014CVSS 7.7HighReproduced on hostAttack surface: Trusted Connect backend</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-014\" rel=\"nofollow ugc noopener\">A 110-char client G-code overflows the 96-byte queue slot via an unguarded strcpy</a></p>\n<p>A 110-character client G-code overflows a 96-byte ring slot with an unguarded <code>strcpy</code> in <code>_enqueue</code>. The print and serial paths are bounded to 96, but the client path is not, and overflowing the last slot writes into the adjacent statics.</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-014\" rel=\"nofollow ugc noopener\">Read the advisory</a></p>\n<p>PFB-012CVSS 7.5HighSource review onlyAttack surface: Any host that can reach the printer&#39;s TCP services</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-012\" rel=\"nofollow ugc noopener\">An unauthenticated host that reaches the printer over TCP pins the entire Ethernet receive pool and stalls all networking</a></p>\n<p>An unauthenticated host that can reach the printer&#39;s TCP services, usually one on the local segment, can pin its entire Ethernet receive pool. Two timeout-resetting mechanisms let it hold the pool&#39;s buffers, which drains the ring and stops PrusaLink, Connect and mDNS for as long as it keeps sending, and neither needs the password.</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-012\" rel=\"nofollow ugc noopener\">Read the advisory</a></p>\n<p>PFB-002CVSS 5.9MediumSource review onlyAttack surface: Network path MITM</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-002\" rel=\"nofollow ugc noopener\">Prusa Connect encrypted downloads carry no integrity check over plain HTTP</a></p>\n<p>The Prusa Connect encrypted download path protects incoming files with AES-128-CTR and nothing else. CTR is a stream cipher with no integrity, and the transfer adds no MAC or signature, so a host on the network path between the printer and its file server can make precise, chosen edits to the decrypted G-code without needing the key or the nonce.</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-002\" rel=\"nofollow ugc noopener\">Read the advisory</a></p>\n<p>PFB-005CVSS 5.4MediumReproduced on hostAttack surface: Authenticated PrusaLink or Connect upload, USB print file, USB serial</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-005\" rel=\"nofollow ugc noopener\">M919/M920 write one byte past a 16-byte stack buffer from a scanf width off by one</a></p>\n<p>M919 and M920 scan a token into a 16-byte stack buffer with <code>%16s</code>, which leaves no room for the terminating null byte. Any such command with a 16-character argument, whether it arrives over serial or from a print file, writes one byte past the buffer.</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-005\" rel=\"nofollow ugc noopener\">Read the advisory</a></p>\n<p>PFB-009CVSS 5.2MediumSource review onlyAttack surface: Physical USB</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-009\" rel=\"nofollow ugc noopener\">The transfer-recovery backup file yields an attacker-chosen out-of-bounds read whose bytes leave the printer</a></p>\n<p>After a power loss the printer resumes an interrupted download from a backup file. Two defects there (an overflowing range check that cannot reject a negative offset, and a length that is dropped on the way out) turn the stored offset-and-length pair into a pointer outside the recovery buffer, and whatever the printer reads there goes out in a DNS query and an HTTP <code>Host</code> header.</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-009\" rel=\"nofollow ugc noopener\">Read the advisory</a></p>\n<p>PFB-004CVSS 4.4MediumReproduced on hostAttack surface: Crafted .bgcode file, opened on the printer</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-004\" rel=\"nofollow ugc noopener\">E2EE identity block parses an unbounded 16-bit key length, over-reading the heap before any signature check</a></p>\n<p>The E2EE identity block reads a 16-bit key length straight out of the <code>.bgcode</code> file and passes it to mbedTLS without ever bounding it against the allocation, so a crafted block makes mbedTLS parse a key that runs past the heap block, before any signature is checked.</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-004\" rel=\"nofollow ugc noopener\">Read the advisory</a></p>\n<p>PFB-001CVSS 4.3MediumReproduced on hostAttack surface: USB stick, PrusaLink upload, Connect download</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-001\" rel=\"nofollow ugc noopener\">MeatPack G-code decoder writes two bytes past its output buffer</a></p>\n<p>The MeatPack G-code decoder writes two bytes past its two-byte output buffer. One <code>handle_rx_char</code> call can run two decode steps, so a crafted six-byte stream pushes the output count to four and overruns the object it sits in. It fires on any MeatPack block, from a USB stick, a PrusaLink upload, or a Connect download.</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-001\" rel=\"nofollow ugc noopener\">Read the advisory</a></p>\n<p>PFB-003CVSS 4.3MediumReproduced on hostAttack surface: Encrypted file from the E2EE key holder</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-003\" rel=\"nofollow ugc noopener\">Integer underflows in the E2EE decryptor reach an out-of-bounds read</a></p>\n<p>Two integer underflows in the E2EE decryptor turn a wrapped PKCS#7 padding length into a pointer, and the next <code>decrypt</code> reads a <code>memcpy</code> length off that pointer, past a 16-byte buffer. One of them is AddressSanitizer-confirmed on the host, while the second is source-verified.</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-003\" rel=\"nofollow ugc noopener\">Read the advisory</a></p>\n<p>PFB-010CVSS 4.3MediumSource review onlyAttack surface: Authenticated PrusaLink PUT, crafted USB file</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-010\" rel=\"nofollow ugc noopener\">Five smaller source-verified defects in transfers, PrusaLink, libbgcode, and Connect</a></p>\n<p>This card covers five smaller, self-contained holes across the transfer, PrusaLink, libbgcode and Connect paths. None of them is a memory-corruption primitive, and the one reachable over the network is an uninitialised path buffer on <code>PUT /api/v1/files/usb</code>.</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-010\" rel=\"nofollow ugc noopener\">Read the advisory</a></p>\n<p>PFB-006CVSS 0.0NoneReproduced on hostAttack surface: PrusaLink</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-006\" rel=\"nofollow ugc noopener\">Two defects in PrusaLink URL-to-filename handling (out-of-bounds read, weakened traversal guard)</a></p>\n<p>Two one-character defects sit on the PrusaLink URL-to-filename path: the percent decoder guards the wrong buffer, so a trailing <code>%</code> reads two bytes past the input, and the traversal guard stops one window early, so a URL ending in <code>/../</code> is never checked. Neither has a demonstrated consequence on the shipped firmware, so I reported them as fixes that restore what each guard was written to do.</p>\n<p><a href=\"https://dixken.de/disclosures/pfb-006\" rel=\"nofollow ugc noopener\">Read the advisory</a></p>\n<h2 id=\"the-disclosure\"><a href=\"#the-disclosure\">The disclosure</a></h2>\n<p>I initially posted the video above on the <a href=\"https://www.reddit.com/r/prusa3d\" rel=\"nofollow ugc noopener\">r/prusa3d</a> subreddit, half-jokingly asking if my printer was supposed to do this. (I would not recommend doing this with most companies out there, but here it made sense to me at the moment, to get some initial contact pointers, since I hadn&#39;t found the proper channel after some research.)</p>\n<p>A few <strong>minutes</strong> (on a Sunday!) later Prusa&#39;s Community Manager Tommy PM&#39;d me that my video got posted internally and rang some alarm bells - he asked if I could provide some more information and pointed me in the right direction. I then took my initial post offline and sent the email I&#39;d already prepared.</p>\n<blockquote><p>Hi Prusa,\n[...]\nI found 23 bugs in total and a chain via Prusa Connect [1, but the most critical ones only] that ends in code execution on the printer&#39;s main controller, reachable over the local network with no physical access and no user interaction beyond the normal one-time setup. It&#39;s confirmed on real hardware, not just an emulator.</p>\n<p>The full chain is sensitive, of course I have complete writeups, a working proof of concept (scripts needed..), and crash dumps ready to hand over - one word regarding the method: I worked closely using Claude (because I&#39;m also verified in the Cyber Verification Program), so some of the write-ups are quite a bit messy/sloppy, I will give my best until then to clean them up and have them as easy to understand as possible.</p>\n<p>What&#39;s the best way to get it to you? I&#39;ll work to whatever disclosure timeline suits you, and I&#39;m keeping the actual vulnerabilities private until then, because I don&#39;t think it makes sense to open issues against the repository.</p>\n<p>[...]</p></blockquote>\n<p>They replied exactly 24 hours later, confirming I had the right channel, and I then sent the full worktree, roughly 800 megabytes and checksummed: both packages, the test harness, every output I produced, the proof-of-concept code and the video.</p>\n<p>Then it went quiet for a while, and that turned out to be the good kind of quiet. When they came back, they had validated and reproduced the findings themselves and said the volume had given their developers a headache (sorry!). They asked me to a) hold publication until the fix had been out long enough for people to install it, and b) coordinate the disclosure with them rather than around them, which I of course agreed to - having proper CVD behaviour in mind.</p>\n<p><strong>Most recently they asked how I wanted to be credited.</strong> Refreshing experience!</p>\n<p>That is the whole story, and there is no twist. There was still a bit of a back-and-forth needed to coordinate this whole process, and I can just imagine how many people were involved in validating and fixing the findings.</p>\n<h2 id=\"what-prusa-did-right\"><a href=\"#what-prusa-did-right\">What Prusa did right</a></h2>\n<ol><li><strong>Acknowledge the report quickly.</strong> They answered within one working day, and the answer came from a real human with a name.</li><li><strong>Validate it quickly.</strong> They reproduced the findings on their own hardware. Given the number of findings it was still in a reasonable timeframe.</li><li><strong>Be honest about the timeline.</strong> &quot;This will take longer than usual, and here is the structural reason why&quot; was a far better answer than a date they would have missed.</li><li><strong>Ask for an embargo instead of demanding silence.</strong> The difference between a coordination request and an NDA is whether you are still allowed to say the work happened, and I was. Thanks!</li><li><strong>Treat the researcher as a collaborator.</strong> Every mail left the door open for questions in both directions. Lovely!</li><li><strong>Ask how to attribute the credit.</strong> They did, and they also offered to name anyone else involved, and yes, I also got a reward.</li></ol>\n<p>I would add a seventh, and it is the only correction I had for them at the time: a working <code>security.txt</code>. Because theirs was a 404, a report that was already kinda awkward to send opened with me guessing an address and hoping a privacy inbox would pass it along. It resolves today, with a contact address and a policy behind it.</p>\n<p>Because I can see a way this becomes a topic: I won&#39;t discuss the whole Marlin GPL breach afterwards here, due to the firmware being released while the actual sources were withheld to allow more printers to be patched, before the sources were released today. I don&#39;t think I can add anything useful to an already <a href=\"https://github.com/prusa3d/Prusa-Firmware-Buddy/issues/5525\" rel=\"nofollow ugc noopener\">heated discussion on GitHub</a>. I&#39;m sure Prusa gained quite a few learnings about this process and the community&#39;s reaction, but to me it was quite obvious that this whole situation was a huge exception to their usual development process, and we won&#39;t know the full reasoning behind the decision that ultimately followed. I can <em>understand</em> both sides though. Please don&#39;t get me wrong.</p>\n<h2 id=\"why-this-got-cheap\"><a href=\"#why-this-got-cheap\">Why this got cheap</a></h2>\n<p><em>Thoroughness, but let me elaborate first.</em></p>\n<p>I had one week, one printer and no real firmware background. A few years ago this work needed a specialist with a decade of embedded experience. This time it did not, and since I don&#39;t think I&#39;m unusually clever but I&#39;ve still got my fair share of experience in the overall sector, I think the tooling closed the gap for good.</p>\n<p>So yeah, what got cheap is thoroughness. Enumerating every byte encoding, ruling out candidate after candidate until one works, reading the same call path three times from different directions: all of that work was - of course - always possible, but it was quite time-expensive to do properly. This whole constraint is now mostly obsolete. While I personally still embrace that <strong>programming in general got way more democratised with this massive paradigm shift</strong>, I&#39;m sure that you still want/need someone in the &#39;driver&#39;s seat&#39; able to understand what an agent is doing and guiding it in the right direction to unlock its true potential. One fitting case in point (there were many like this): during the work on the PFB-008 finding (the RCE one) I needed to push it repeatedly - using some hints - even though Opus 4.8 (which my <code>claude</code> steps down to once it recognises Cyber Security relevant topics) gave up multiple times, telling me that there was no way I&#39;d be able to achieve RCE with what it found. My knowledge and a manual review of the found ROP gadgets still had me thinking otherwise, so I pushed back and finally led the model in the right direction. (&quot;You&#39;re totally right..! blah blah blah&quot;)</p>\n<p>One thing though:</p>\n<p>Yes, we&#39;re also seeing a massive influx of critical CVEs (look at PHP, Next.js or the kernel just days ago), but I wonder if there will be an actual inflection point where these CVEs will reduce, once we&#39;ve finished looking at existing stuff (even though generated code will suffer from the same issues - btw, if someone has seen articles about the <em>safety</em> of generated code compared against human-written, which are worth reading, please shoot me an email!).</p>\n<p>But on a personal note:</p>\n<p>I am still comfortable saying the AI part out loud (because this fact WILL be torn apart for sure, brace yourself). I&#39;m quite confident that we now have the tool to make software and especially IoT devices much safer to use, if we do it <em>in a considerate way</em>. What I mean by that: <strong>stop vandalising OSS projects</strong> - look at what happened to Daniel Stenberg&#39;s cURL, which at one point simply stopped accepting issues during cURLs <em>Summer of bliss</em>, due to the work required to sort through the actual findings and some hallucinated nonsense, even though the quality has gradually increased as Stenberg reports.</p>\n<p>As long as we don&#39;t have a working solution to this <del>script</del> AI-Kiddie problem, people are rightfully complaining about the actual strain on the broader OSS communities.</p>\n<p>&lt;/rant&gt;</p>\n<h2 id=\"what-ships-today\"><a href=\"#what-ships-today\">What ships today</a></h2>\n<p>Prusa&#39;s fixes shipped with Buddy firmware 7.0.0 (with 8.0.0 being the most recent one, yes, I think too that the new version numbering system is a bit confusing), and every finding in this post affects all fifteen printers it covers: the CORE One L+, CORE One L, CORE One+ (Gen 2) INDX, CORE One INDX, CORE One+ (Gen 2), CORE One, XL+, XL, MK4S, MK4, MK3.9S, MK3.9, MK3.5S, MK3.5 and MINI. If yours is on that list, update it. Prusa published its own advisory and source release on GitHub today, and says it is not aware of any real-world exploitation, except for my printer, which got rick-rolled.</p>\n<p>That source release is the <a href=\"https://github.com/prusa3d/Prusa-Firmware-Buddy/releases/tag/v7.0.0\" rel=\"nofollow ugc noopener\">v7.0.0 release tag</a>, which holds the 7.0.0 sources.</p>\n<p>The full write-ups for all fourteen findings are published with the fix and linked from each finding above.</p>\n<p>3D printers are not toys: they have network stacks, cloud integrations, USB hosts, filesystem parsers, signature-checking paths and microcontrollers talking over a serial bus, and they are bolted to heaters and stepper motors in someone&#39;s house (so there&#39;s a certain risk involved, which is why it makes a lot of sense to have the issues patched). I am not surprised that they have defects, because everything does. Let&#39;s make them as safe as we can!</p>\n<p>What still surprises me is the response I got. I have now done this twice <em>publicly</em>, and once I got a response from a law firm and a criminal-code citation (lol), while the other time I got proper engineers who reproduced/validated my work and asked how I would like my name spelled for the credits and even showed their appreciation for this work with a reward (though I just did it <strong>to learn something</strong>): there are worlds in between.</p>\n<p><strong>Only one of those two responses makes the next researcher pick up the phone.</strong></p>\n<p>Thanks for the great time!</p>\n<p>Cheers,\nY</p>","headings":[{"level":1,"text":"Never gonna print you up!","id":"never-gonna-print-you-up"},{"level":2,"text":"TL;DR","id":"tl-dr"},{"level":2,"text":"A little bit about me and the printer in question","id":"a-little-bit-about-me-and-the-printer-in-question"},{"level":2,"text":"The method","id":"the-method"},{"level":2,"text":"What I found and reported","id":"what-i-found-and-reported"},{"level":2,"text":"Oops, I got RCE","id":"oops-i-got-rce"},{"level":2,"text":"The rest of the first package","id":"the-rest-of-the-first-package"},{"level":2,"text":"The second package","id":"the-second-package"},{"level":2,"text":"The disclosure","id":"the-disclosure"},{"level":2,"text":"What Prusa did right","id":"what-prusa-did-right"},{"level":2,"text":"Why this got cheap","id":"why-this-got-cheap"},{"level":2,"text":"What ships today","id":"what-ships-today"}]}}