Hackaday Podcast Episode 395: Pancake Slicer, RGB LED Origami, And Farting Synthesizers

This week, Elliot Williams and Kristina Panos met up in the super-secret studio to bring you some Hackaday news, a ‘lil something from the Mailbag, and wax nerdily about a whole lot of hacks.

In the news, we’re hiring, so come join us! If you’re reading this, chances are good that you know the format, and you’re ready to get your hands on the tips line. Just do what it says in the post, and we’ll get back to you.

Elliot dumped out the Mailbag and a single letter fluttered down to the table. It was from [iPod enjoyer], who is still using an iPod in 2026 and seems to appreciate the embedded art that ships with this here Podcast.

Then, it was on to the hacks, as you’ve come to expect. There’s something for everyone!

Check out the links below if you want to follow along, and as always, tell us what you think about this episode in the comments!

Download in lovely MP3.

Continue reading “Hackaday Podcast Episode 395: Pancake Slicer, RGB LED Origami, And Farting Synthesizers” →

E-Paper Price Tags Become Picture Frames

E-paper has lots of applications, though it’s found a particularly solid market penetration as a replacement for simple paper price tags. Because why have a cheap slip of paper for a fraction of a cent when you could have a complicated piece of electronics displaying a price? In any case, some of these price tags can be repurposed for more interesting uses, as this work from [steanlab] demonstrates.

pin16 is an open firmware for Solum EFR32BG22 e-paper price tags. Or, as the industry calls them, Electronic Shelf Labels (ESL). It covers the El016 (200×200) and EL022 (160×296) models, both of which have four colors—black, white, red, and yellow. The firmware allows uploading images over Bluetooth from a browser, turning the humble price tag into a picture frame. Pictures are converted within the browser into a format suitable for display on the tags, and are then shown as a slideshow on a timer.

Updates to firmware can be made over Bluetooth once the pin16 firmware is installed, however, it’s worth noting that initial install requires using SWD to reprogram. There’s no way to backup the factory firmware either, so don’t do this on tags that don’t belong to you.

They may not be the highest-resolution or prettiest digital picture frames out there, but nevertheless, it’s fun to see these tags opened up for other uses. Of course, you’re not limited to just using them as picture frames, either—you can use the firmware to upload your own tag graphics if you still want to use them as labels. We’ve seen other similar hacks before, too, and we’d love to see more—so light up the tipsline if you’ve got ’em!

This Week In Security: Java4Shell, Optimizely Malware, Shrinking Disclosure Deadlines, Unpatchable Freezers

Last month, the details of PHP2Shell leaked before the embargo lifted, and PHP had to scramble its release out early. This week, the same research firm, Calif, had it happen again, this time with Java. Java4Shell (CVE-2026-114938) is a heap overflow in OpenJDK’s hardware-accelerated Base64 decoder, and on November 17, Calif said it was going public early because the vulnerability had leaked. Oracle and OpenJDK pushed fixes that afternoon, and Calif followed with its write-up.

Java normally runs virtual bytecode inside the Java virtual machine, but when a function gets called often enough, the HotSpot JIT compiler turns it into native code. For some common operations it goes a step further, and swaps in hand-tuned machine code which uses special CPU instructions. On x86-64 CPUs with AVX-512 instructions, Base64 decoding is one of those, chewing through 64 bytes at a time with a mask that decides which output bytes actually get written. When the last chunk of input is a short, malformed tail with “=” padding, the calculated output length underflows below zero, the mask ends up with every bit set, and the decoder writes 64 bytes where it should have written at most two. Java then correctly throws an exception for the bad input, but by then, 62 bytes past the end of the output buffer have already been overwritten.

The overwritten bytes are fixed; the attacker controls when and where the write happens, but not what is written. Calif turned that into a working exploit anyhow. The overflow overwrites the length field of a nearby array, which allows for overwriting more of the heap with chosen values, and then into a way to read heap memory back in a response, which may hold keys, tokens, and other secrets. From there, Calif escalated to code execution, grooming the heap remotely by carefully timing the pieces of the HTTP request. Calif is holding back the exploits for specific applications for now, and points out that every target needs its own custom setup.

Not every Java server is vulnerable. The bug needs OpenJDK 17.0.6 or newer, and an x86-64 processor with AVX-512 VBMI, which in practice means Intel Ice Lake or newer server chips, or AMD Zen 4 or newer; ARM servers are safe. The decoder also has to be JIT compiled first, which Upwind found took about 10,000 decodes, so a busy server qualifies and an idle one may not. Unfortunately, Base64 shows up everywhere attacker input arrives. i’IUpwind found that the standard HTTP Basic authentication handling in Spring Security, Tomcat, and Jetty, as well as Auth0’s java-jwt library, feed attacker-supplied data to the vulnerable decoder before checking any credentials. If you can’t update yet, starting Java with “-XX:-UseBASE64Intrinsics” disables the vulnerable code. Unlike Log4Shell, this is a bug in the Java runtime itself, not in a library, so dependency scanners won’t find it, and the fix means replacing the runtime everywhere it lives, including inside every container image.

Continue reading “This Week In Security: Java4Shell, Optimizely Malware, Shrinking Disclosure Deadlines, Unpatchable Freezers” →

Hacking The Contra Pocket Player

The My Arcade Contra Pocket Player is a fun little handheld that lets you play the arcade versions of Contra and Super Contra… and nothing else. However, [Rob Simon] put in the work to get the device loading custom games as well.

The work started with the usual—identifying the system-on-chip and supporting hardware, dumping the flash, and just generally mapping out how the device was laced together. From there, [Rob] dived into firmware analysis to figure out how the filesystem was laid out and how it could be re-flashed. It turned out the handheld was basically just feeding ROMs into RetroArch, so it wasn’t too hard to get it playing different games. Though there are certain limitations based on what support was compiled in. Basically, it can play games compatible with the FBAlpha libretro emulation core. Files are on GitHub for those eager to mod their own units.

We love seeing hardware like this hacked to play custom games. We saw similar action with the NES Classic almost a decade ago.

Continue reading “Hacking The Contra Pocket Player” →

One Hundred Gratuitous Case Fans? We’re Fans Of This.

Sometimes you can’t help but boast about a project once you have it in your hands. [Sasa Karanovic] proudly declared that his new fan controller could handle “one hundred fans, without breaking a sweat” — but you should be mindful of that which you speak into being, for [Sasa] from that moment was haunted by the specter of those hundred fans. It would not leave him until he built what may literally be the coolest thing we’ve seen on YouTube this week: a literal wall of PC cooling fans.

Do you need one hundred computer fans? Does [Sasa]? Does anyone? No, of course not. That’s what makes this project great: it has no reason to exist, other than to prove a boast that. [Sasa]’s bespoke fan controller doesn’t have 100 outputs, though, so he had to chain the things together through a comical number of fan splitters. The frame is a big mass of aluminum extrusion with some 3D printed brackets to hold fans and wires both in place.

The fans are controlled in their rows of 10 by the fan controller, but as a stress test he drives 50 fans per channel just to see how his controller holds up. Spoiler: it does. If that kind of power interests you, the fan controller will be open-sourced once [Sasa] has finished development.

Now all he needs is an idea of what to use this gratuitous fan wall for — let us know in the comments if you have any ideas. Perhaps a really big fume extractor? Maybe a hilarious hovercraft?

Continue reading “One Hundred Gratuitous Case Fans? We’re Fans Of This.” →

Crashing Microcontrollers Competitively

[Ani] has produced rather an interesting game. Kacken Open Air (KOA) is a browser-based game, wherein players compete for access to a limited resource—namely, festival toilets. So far, so amusing, but there’s a neat technical twist. You’re actually competing to crash microcontrollers in the real world (German, Google Translate link).

The way the game works is simple enough. There are more players than there are toilets, so players have to fight over them. This is achieved by knocking on the toilet doors in the game. However, paired to each toilet in the game is a real ESP8266 microcontroller. Each knock from a player adds computational load to the microcontroller. Knock enough, and the microcontroller will slow enough, and the player occupying the toilet will be kicked out. Keep knocking, and eventually the microcontroller will run out of memory, crash, and reboot. In game, this causes the toilet to collapse. The whole setup runs on a cluster of microcontrollers, with an ESP32-P4, a bunch of ESP8266s, a few Raspberry Pi Pico 2s, Arduino Dues, and an STM8 working as a hardware watchdog to make sure everything stays alive when it should.

If you want to sample the game, try it out in your browser here. (German, Google Translate link). It’s a really fun concept to combine hardware performance with actual gameplay outcomes. It’s so totally different from other projects we’ve seen that involve gaming on ESP microcontrollers. If you’ve done something similar, or something totally zany and different, bell us on the tipsline either way!

DabbleCAD Takes Design Offline

These days, there are all kind of online-only and in-browser CAD packages. DabbleCAD is the opposite of all that—a simple, offline, open-source design solution.

DabbleCAD handles 3D design in a similar way to TinkerCAD. It’s shape based modelling, with all the usual tools for stretching, deforming, punching holes, and the like. It’s set up to export your geometry to STL or 3MF so you can throw it straight into a slicer for 3D printing.

However, it’s also a package that can handle design for laser cutters, too. There are simple tools for importing artwork or drawing it from scratch, and it will export the relevant G-code or directly send to a GRBL-compatible laser cutter hooked up over USB. As a nice bonus, there’s also an engraving feature. 3D models or images can be turned into height maps for relief engraving if you’ve got the tools for it.

DabbleCAD doesn’t do anything groundbreaking or new that existing software can’t handle. It’s just a convenient, portable piece of software in an era when so much of what we use is tied to logins and clouds and endless headaches around connectivity. If you’re whipping up your own tools to suit your chosen working ethos, don’t hesitate to let us know on the tipsline.