STM32 Blue Pill Turned GPG Security Token

June 10, 2020 by Tom Nardi 30 Comments

Feeling the cost of commercial options like the YubiKey and Nitrokey were too high, [TheStaticTurtle] started researching DIY alternatives. He found an open source project allows the STM32F103 to act as a USB cryptographic token for GNU Privacy Guard, which was a start. All he had to do was build a suitable device to install it on.

The first step was to test the software out on the popular “Blue Pill” development board, which [TheStaticTurtle] documents in the write-up should anyone want to give it a try themselves. The ST-Link V2 was already a supported target, so it only took some relatively minor tweaks to get running and add support for a simple push button. The output of gpg --card-status showed the device was working as expected, so with the software sorted, it was time to take a closer look at the hardware.

To create his “TurtleAuth” dongle, [TheStaticTurtle] started with the basic layout of the Blue Pill and added in a TTP223E touch control IC. The original Micro USB port was also swapped for a male USB-A connector so the device could be plugged directly into a computer. An upper PCB, containing the status LEDs and touch pad, was then designed so it would fit over the main board as an enclosure of sorts. While the sides are still open, the device looks robust enough to handle life in a laptop bag at least.

While it’s not exactly a common project, this isn’t the first time we’ve seen somebody spin up their own hardware token. More evidence of what the dedicated individual can accomplish these days on a relatively limited budget.

Fusion For STM32: Development Board With Debugging And Programming Via WiFi

June 2, 2020 by Maya Posch 26 Comments

Clearly profiling itself as the Lamborghini or Ferrari of the STM32 development board world, MikroElektronika’s current (8th) revision of their Fusion development board was released last year with support for not only flashing but also debugging the attached STM32 MCU via the onboard WiFi module. The Serbian company’s pricing for the bare board without MCU modules or any other peripherals appears to be around 300 USD/Euro. Additional MCU boards cost between $28 – $60 each.

As the official product page explains, the board is combined with the CodeGrip software to manage the board either via USB-C (driver-free) – which also allows one to configure the WiFi option – and via WiFi. Peripheral boards are added via the 5 onboard MikroBUS expansion slots, either with existing boards, or custom MikroBUS boards. The power supply is also onboard, powered via USB, a barrel jack connector, or an external battery.

The use of WiFi to connect to the board would allow for it to be easily managed and debugged when it’s in a less convenient location than one’s desk, which would seem like a major boon.

Obviously it’s not a cheap board, and the MCU cards each cost about as much as a Nucleo or Discovery board from ST would cost, making it hard to justify purchasing it for anything but a professional environment. However, the tantalizing thing here is probably that so much of the design details are available, from the expansion bus to the pin-out and schematic of the MCU cards (STM32F767ZG version).

The MCU cards use the Hirose FX10A-168S-SV and FX10A-168P-SV(71) connectors, all readily available. This opens the possibility of developing compatible MCU cards. An MCU card template project can for example be found here.

A Hot Printer For Cool Selfies

May 7, 2020 by Moritz v. Sivers 12 Comments

Randomly buying some hackable gadgets just because they are cheap and seem potentially interesting for future projects is something that most of us can relate to. It also happened to [fruchti] when he bought five thermal printer modules without any specific purpose for them in mind. It was not until several years later that he put them to good use for his inverse thermal camera project.

The name perfectly summarizes the device’s function which is to convert images to heat instead of the other way around. To put it in a less cryptic manner, [fruchti] built a selfie camera that instantly prints out pictures on thermochromic paper. The project would have been easy to implement on a Raspberry Pi but instead, he chose a more minimalist approach by using an STM32 microcontroller. This involved some challenges because the MCU didn’t have enough RAM to store an entire frame and the camera module came without a FIFO buffer. To capture and store the image data [fruchti] applied a line-by-line dithering algorithm which is described in detail in his accompanying blog post while the corresponding code is available on GitHub. Even though the case was improvised from scrap PCB materials the finished device still looks great. In particular, the fuse holders that are being used to hold the paper roll make it almost steampunk.

Naturally, this is not the first time we have seen thermal printers being used for instant picture taking and it probably won’t be the last.

CPAP Firmware Hack Enables BiPAP Mode; Envisions Use As Temporary Ventilator

April 15, 2020 by Tom Nardi 16 Comments

Operating under the idea that a Constant Positive Airway Pressure (CPAP) machine isn’t very far removed electrically or mechanically from a proper ventilator, [Trammell Hudson] has performed some fascinating research into how these widely available machines could be used as life support devices in an emergency situation. While the documentation makes it clear the project is a proof of concept and is absolutely not intended for human use in its current state, the findings so far are certainly very promising.

For the purposes of this research, [Trammell] has focused on the Airsense S10 which currently retails for around $600 USD. Normally the machine is used to treat sleep apnea and other disorders by providing a constant pressure on the lungs, but as this project shows, it’s also possible for the S10 to function in what’s known as Bi-level Positive Airway Pressure (BiPAP) mode. Essentially this means that the machine detects when the user is attempting to inhale, and increases the air pressure to support their natural breathing.

Critically, this change is made entirely through modifications to the S10 firmware. No additional hardware is required, and outside of opening up the device to attach an STM32 programmer (a process which [Trammell] has carefully documented), there’s nothing mechanically that needs to be done to the machine for it to operate in this breathing support function. It seems at least some of the functionality was already included via hidden diagnostic menus which can be enabled through a firmware patch.

As many of these CPAP machines feature cellular data connections for monitoring and over-the-air updates, [Trammell] believes it should be possible for manufacturers to push out a similarly modified firmware on supported devices. Of course, the FDA would have to approve of something like that before the machines could actually be used as emergency, non-invasive ventilators. They would also need to have viral filters installed and some facility for remote control added, but those would be relatively minor modifications.

Learn more about the efforts being put into ventilators right now. Start with this excellent hardware overview called Ventilators 101 and then take a look at some of the issues with trying to build a ventilator from scratch.

Thunder Pack Is A Bolt Of Lightning For Wearables

March 25, 2020 by Kristina Panos 19 Comments

Do you need portable power that packs a punch? Sure you do, especially if you want to light up the night by mummifying yourself with a ton of LED strips. You aren’t limited to that, of course, but it’s what we pictured when we read about [Jeremy]’s Thunder Pack. With four PWM channels at 2.3 A each, why not go nuts? [Jeremy] has already proven the Thunder Pack out by putting it through its paces all week at Burning Man.

After a few iterations, [Jeremy] has landed on the STM32 microcontroller family and is currently working to upgrade to one with enough flash memory to run CircuitPython.

The original version was designed to run on a single 18650 cell, but [Jeremy] now has three boards that support similar but smaller rechargeable cells for projects that don’t need quite as much power.

We love how small and powerful this is, and the dongle hole is a great touch because it opens up options for building it into a wearable. [Jeremy] made a fantastic pinout diagram and has a ton of code examples in the repo. If you want to wade into the waters of wearables, let whimsical wearables wizard [Angela Sheehan] walk you through the waves.

Breaking Into A Secure Facility: STM32 Flash

March 24, 2020 by Bryan Cockfield 20 Comments

In a perfect world, everything would be open source. Our current world, on the other hand, has a lot of malicious actors and people willing to exploit trade secrets if given the opportunity, so chip manufacturers take a lot of measures to protect their customers’ products’ firmware. These methods aren’t perfect, though, as [zapb] shows while taking a deeper look into an STM microcontroller.

The STM32F0 and F1 chips rely on various methods of protecting their firmware. The F0 has its debug interface permanently switched off, but the F1 still allows users access to this interface. It uses flash memory read-out protection instead, which has its own set of vulnerabilities. By generating exceptions and exploiting the intended functions of the chip during those exceptions, memory values can be read out of the processor despite the memory read-out protection.

This is a very detailed breakdown of this specific attack on theses controllers, but it isn’t “perfect”. It requires physical access to the debug interface, plus [zapb] was only able to extract about 94% of the internal memory. That being said, while it would be in STM’s best interests to fix the issue, it’s not the worst attack we’ve ever seen on a piece of hardware.

Open-Source ARM Development Simplified

March 17, 2020 by Bryan Cockfield 12 Comments

The ARM series of processors are an industry standard of sorts for a vast array of applications. Virtually anything requiring good power or heat management, or any embedded system which needs more computing power than an 8-bit microcontroller is a place where an ARM is likely found. While they do appear in various personal computers and laptops, [Pieter] felt that their documentation for embedded processors wasn’t quite as straightforward as it could be and created this development board which will hopefully help newbies to ARM learn the environment more easily.

Called the PX-HER0, it’s an ARM development board with an STM32 at its core and a small screen built in. The real work went in to the documentation for this board, though. Since it’s supposed to be a way to become more proficient in the platform, [Pieter] has gone to great lengths to make sure that all the hardware, software, and documentation are easily accessible. It also comes with the Command Line Interpreter (CLI) App which allows a user to operate the device in a Unix-like environment. The Arduino IDE is also available for use with some PX-HER0-specific examples.

[Pieter] has been around before, too. The CLI is based on work he did previously which gave an Arduino a Unix-like shell as well. Moving that to the STM32 is a useful tool to have for this board, and as a bonus everything is open source and available on his site including the hardware schematics and code.