Dhole's blog

Collapse Ready Operating Systems - FreeBSD

Sun, 21 Dec 2025 00:15:20 +0200

This post belongs to the Collapse Ready Operating System series. See this post for an introduction.

Prelude

My last post in this series was more than two years ago. When I started the series I had an initial plan to test the three most well known BSD operating systems, and after publishing articles for NetBSD and OpenBSD I soon started doing my homework with FreeBSD; unfortunately I had a lot of hiccups. I’ve made 4 different attempts at achieving the objectives in this series with FreeBSD, the last one being last week, and none of them were fully successful. The reason for trying several times instead of publishing the first result was to see if some of the issues I encountered were temporary or bugs of a particular release; but at the end I decided to publish the results I have.

First impressions on Hare language

Sat, 20 Jan 2024 14:45:38 +0100

Introduction

Hare is a new programming language that was announced in 2022 and which was started by Drew DeValut. It’s currently being developed openly by a community of contributors. Here’s a description of the language from the official website:

Hare is a systems programming language designed to be simple, stable, and robust. Hare uses a static type system, manual memory management, and a minimal runtime. It is well-suited to writing operating systems, system tools, compilers, networking software, and other low-level, high performance tasks.

Collapse Ready Operating Systems - NetBSD

Mon, 01 May 2023 12:00:20 +0200

This is a blog post in the Collapse Ready Operating System series. Read this post for an introduction.

NetBSD

This time I have chosen NetBSD. I have used NetBSD previously in my Raspberry Pi (the first version). I had a lot of fun building packages for ARM from the raspberry pi and trying them out (and finding bugs as well). I remember fondly the regular status reports made by Jun Ebihara along with raspberry pi images with many packages already installed. I also remember building a raspberry pi image myself from a Linux host on amd64 using cross-compilation: I was quite impressed with how easy the process was.

Collapse Ready Operating Systems - OpenBSD

Tue, 21 Feb 2023 00:15:20 +0200

This is a blog post in the Collapse Ready Operating System series. Read this post for an introduction.

OpenBSD

The OS analyzed in this post is OpenBSD. I’ve tried OpenBSD a few times in the past: once as a personal web server on an old PC, and then as a desktop in a laptop as a secondary system. That was a few years ago. My memories from it are that the system was very clean, everything worked as expected, the performance was significantly slower than linux and that I really appreciated all the care the developers put on the security side.

Collapse Ready Operating Systems - Intro

Mon, 13 Feb 2023 12:23:20 +0200

Introduction

Nowadays we live in a hyperconnected World that relies heavily on Internet connection for day to day tasks in all levels. I’m not very happy with this relience of assuming Internet access 24h for everything, as I think it disempowers the user.

For example, whereas people before used to buy and own media, now they buy a license to stream such media from the cloud. This means that the user only has access to the media as long as the platform exists, and we know that this is no guarantee for the future. It also means that the user can’t easily share the media with their friends, that the consumption of the media can only be done in authorized devices, etc.

CHIP-8 emulator in Rust: Embedded port. Part 2

Thu, 03 Jun 2021 10:23:20 +0200

This post is the continuation of CHIP-8 emulator in Rust. Part 1, please check it if you haven’t already!

In this second part I will explain how I ported the CHIP-8 emulator I built in Rust to an embedded ARM microcontroller. I will explain the hardware I chose to build this portable CHIP-8 device, the Rust libraries I used and I’ll give an overview of how the code is laid out. I excluded details about hardware diagrams and explicit mention of how the hardware is connected to each pin because I’m sure the astute reader will be able to figure this out from the code itself.

NFS server over WireGuard in Alpine

Fri, 21 May 2021 13:27:31 +0200

I have recently built a new storage server at home consisting of 6x2TB hard drives configured as RAID-Z2 with ZFS. For the operating system I have chosen Alpine Linux, which is a distribution that I really like for its lightweightness and its simplicity.

Previously I had a storage server running Debian which I was sharing via sshfs. sshfs is really easy to set up, as you just need to be running an ssh server, nevertheless it has some disadvantages:

CHIP-8 emulator in Rust. Part 1

Sun, 09 May 2021 17:23:20 +0200

I have been interested in the topic of emulation for many years; in particular, game console emulation. I started playing games under emulators when I was a teenager and I was fascinated by how a piece of software would let me play a game in a completely different architecture than the original one.

I’ve you’ve ever been interested in learning about emulation, maybe you’ve learned about the CHIP-8; a specification of a simple virtual machine designed to play 8bit 2D videogames in the mid 1970s. The connection between the CHIP-8 and emulation development is that the specification of the CHIP-8 is very simple and makes the perfect target for writing your first emulator. In fact, that’s what I did in 2014: I wrote my first emulator, targeting the CHIP-8 in C++. Please, don’t take that C++ code too seriously! I’ve never been experienced in C++, and I wasn’t very experienced in software development by then.

Thinkpad Helix 2 with Linux

Tue, 03 Sep 2019 20:54:53 +0200

Preface

Recently I’ve bought a second hand Thinkpad Helix 2nd Gen with the intention of using it mainly as a tablet to read PDF documents and comics (although I may use it for Internet browsing and occasional development). I like running free software on my computers and so I decided to use GNU/Linux with this tablet/laptop. Here I will explain all the issues I encountered and how I solved them.

Pulseaudio for multi-user Linux

Mon, 27 Aug 2018 20:54:53 +0200

My setup

For some time I’ve been using several unix users for my daily work in my desktop computer. After trying out Qubes OS for some time (an OS that achieves security by compartmentalization: different kinds of activites are performed in a different VM, isolating the data of each activity from each other), I came back to GNU/Linux and realized that there’s already a security separation in Unix (albeit not as secure as virtualization as in Qubes): users.

Programming Game Boy Chinese cartridges with an STM32F4

Mon, 12 Mar 2018 00:33:57 +0100

Introduction

For the past few years I have been interested in the Game Boy: I’ve written an emulator in C (without sound), I developed a physical cartridge “emulator” using a microcontroller, and most recently I’ve built a project to interface my PC with the Game Link. I’ve also played a bit with Game Boy programming.

In the past I considered buying a Game Boy flashcart so that I could run demos and other scene ROMs on real hardware comfortably, but the price of such carts is a bit high. After some reading on reddit, I learned that Chinese manufacturers are selling unlicensed Game Boy cartridges at very cheap prices ($5). Not only that, but these cartridges use flash memory to store the ROM, and so have the potential to be reflashed! I confirmed this fact after learning about a commercial device called the jeoy-joebag, developed by BennVenn

Printing on the Game Boy Printer using an STM32F4

Sun, 25 Feb 2018 16:33:57 +0100

In this third and final part of the project about the Game Boy serial communication I will explain how I managed to print on the Game Boy Printer from my PC using an STM32F4 as the bridge between the two. The encoding of the image into Game Boy tiles will happen on the PC, which will send it to the STM32F4 following the packet format of the Game Boy Printer. The STM32F4 will only forward the data to the Game Boy Printer.

Virtual Game Boy Printer with an STM32F4

Fri, 23 Feb 2018 16:33:57 +0100

In this second part of the project about interfacing the Game Boy serial communication with an embedded development board I will explain how I built a Virtual Game Boy Printer. The embedded board will be simulating a real Game Boy Printer, replying to the Game Boy following the protocol used by the Game Boy Printer so that the Game Boy sends the entire data meant to be print. This data will then be forwarded to my computer which will construct a PNG image out of it.

Sniffing Game Boy serial traffic with an STM32F4

Wed, 14 Feb 2018 02:33:57 +0100

In these series of blog posts I will write about the Game Boy serial communication protocol and how to interact with it by using an embedded development board. The code for the development board will be written in C, and the code running on the computer will be written in Rust.

The first part will consist on understanding the Game Boy serial communication protocol, becoming familiar with embedded development using the libopencm3 free/libre library and finally building a serial communication sniffer to capture the transmission of data on the Game Link Cable.

Enabling LUKS on the PocketCHIP

Thu, 23 Nov 2017 14:35:56 -0800

Introduction

I’ve recently acquired a handheld ARM computer with screen and keyboard called the PocketCHIP. The main board on the device is called the CHIP, which is a tiny ARM computer capable of running Linux that is sold for $9.

After flashing it with the CHIP 4.4 GUI OS, a flavor of Debian released by Next Thing Co (the company that made the PocketCHIP) I noticed I wasn’t able to mount LUKS-encrypted partitions due to missing kernel modules. In this post I will explain what I had to do to build and install the missing modules without the need to replace the entire kernel. If you want to install a new and different kernel you will need to follow a more involved process because the WiFi and GPU drivers aren’t in the kernel sources and require you to build them apart (and also fiddle with the device tree).

Alpine Linux: Upgrading on Raspberry Pi

Mon, 26 Jun 2017 23:18:39 -0700

This post describes the upgrade procedure I follow to upgrade my Raspberry Pi Alpine Linux installation. Alpine Linux on the Raspberry Pi runs from ramfs and thus the upgrading is not straightforward. Most of the details are taken from the Alpine Linux Wiki. I’m not sure if Alpine Linux does any verification on the new downloaded release, so I’m doing that manually on another computer.

Upgrading

First of all, replace the repository confiration to point to the new version:

rdiff-backup-1.2.8 in Alpine

Tue, 01 Nov 2016 01:17:17 -0700

Introduction

A few days ago I wanted to start doing incremental backups from my laptop to my Raspberry Pi 2 running Alpine Linux. I’ve had used rdiff-backup for some years now and I’m really happy with it. rdiff-backup is similar to rsync, in the sense that lets you synchronize folders over the network, but it has two added nice features: when synchronizing, only the differences between the files that have changed are sent; and after every synchronization, the differences between the old version of the files and the new ones is kept. In other words, it keeps backwards in time incremental backups, allowing you to revert the files in time.

Raspberry Pi: git server (cgit with lighttpd)

Fri, 21 Oct 2016 15:14:27 -0700

Introduction

In this post I will explain what’s required to set up a git server. We’ll use cgit to provide a web interface and also allow cloning/pulling through HTTP. ssh will also be available for cloning/pulling and pushing.

We’ll setup two groups of repositories: a public and a private one.

Cgit

First of all, we’ll create a git user and move it’s home to the encrypted partition. For convenience we’ll also link that home directory to /git. This will be useful to have nice paths for our repositories.

Raspberry Pi: setting up alpine, lighttpd and letsencrypt

Fri, 21 Oct 2016 15:14:27 -0700

Introduction

In this post I will explain how to set up Alpine Linux for the RPi, with the necessary configuration for the RPi to power a USB hard drive, how to install lighttpd and configure automatic renewal of TLS certificates with lestencrypt.

Alpine Linux

Alpine Linux can be installed on te RPi following the wiki guide.

After instalation, we add a new user which we will use for logging in:

adduser green

After logging in with our new user (using password) we’ll add some ssh public keys for future logins:

Raspberry Pi 2 I/O benchmarks

Thu, 20 Oct 2016 15:03:12 -0700

Introduction

I’m currently setting up a Raspberry Pi 2 as a home server for various services. I’m gonna write a series of blog posts about how I configured my Raspberry Pi to achieve my goals, which will be mainly setting up a git server and a backup server.

Choice of distribution

I discovered Alpine Linux while searching lightweight distributions for the Raspberry Pi. This is a lovely small Linux distribution: one of the first things I noticed is how fast it runs on the RPi due to using a ram filesystem by default; this is specially noticeable in the RPi because usualy the operating system resides in the micro-SD card, which usually offers really slow read and write operations. Another really nice feature is that it’s security-oriented, and as such the kernel is patched with grsecurity/PaX and the userland binaries (I understand that means all packages- too) are compiled with hardening features: Position Independent Executables (PIE) and stack smashing protection. This distribution uses musl libc instead of glib and busybox to provide all the basic utilities, decisions that help making it small and lightweight. I should also mention that OpenRC is used for the init system (instead of following the current trend of switching to systemd).

No more unencrypted emails to gpg contacts

Sat, 04 Jun 2016 00:13:28 +0200

I have been using mutt for about half a year already and I’m very happy with it. The previous email client I used was Thunderbird (with the Enigmail extension to handle GPG). There were two main reasons that made me switch.

The first one was that I often would like to check my email while I’m offline, and it seems that Thunderbird is not very good at this. Sometimes not all my email would have been downloaded (just the headers), and I also found it frustrating that after marking more than 50 emails as read while offline, they would be marked as unread again once I went back online. With mutt I’m using mbsync (which apparently is faster than offlineimap) to sync my email to a local folder with a cron job. I couldn’t be happier.

Reproducible builds on Debian for GSoC 2015, 1st update

Thu, 06 Aug 2015 20:12:15 +0200

This is the second blog post I’m writing about my experiences contributing to Debian for Google Summer of Code 2015 (check my first post)

Status update

First month

It’s been two months and a few days since the GSoC started. During the first month I worked on fixing specific packages, mainly concerning issues with timestamps, which is a very common source of unreproducibility. In many cases, during the build process files are compressed into gzip or zip archives, which store the creation time of files in the metadata. This can lead to unreproducible results when there is timezone variation between builds (easily fixed setting the timezone to UTC before the compression happens). In some cases the compressed files are generated during the build, and thus add build times in the metadata of compressed files (in this case the creation date of the files needs to be normalized somehow).

Reproducible builds on Debian for GSoC 2015

Sun, 10 May 2015 17:14:05 +0200

This is the first blog post of a series I will be writing about my experiences contributing to Debian for Google Summer of Code 2015.

A bit about myself

I’m a Spanish student doing a master’s in Computer Science in Barcelona. I graduated on Electrical Engineering (we call it Telecommunications here). I’ve always been interested in computing and programming and I have worked on several projects on my own using C, python and go. My main interests in the field are programming languages, security, cryptography, distributed and decentralized systems and embedded systems.

Full disk encryption on Samsung Chromebook with Arch Linux

Fri, 01 May 2015 23:58:40 +0200

In this post I will explain the procedure I followed to have an Arch Linux install on a Samsung Chromebook 1 (XE303C12-A01US) with full disk encryption using kernel 3.8.

Kernel compilation and preparing SD card

Install dependencies

Install the necessary depdendencies (In my case I was running ubuntu). Mainly you need the tools for crosscompiling the kernel, configure u-boot and partition the SD card with a GPT partition table.

sudo apt-get install u-boot-tools gcc-arm-linux-gnueabihf \
    binutils-arm-linux-gnueabihf cgpt device-tree-compiler

Set up some directories and download arch and kernel sources

TMP_PATH=$(pwd)/chromeos
mkdir -p $TMP_PATH
cd $TMP_PATH
mkdir -p root
mkdir -p mnt

Download my custom files

Booting the GameBoy with a custom logo

Thu, 25 Dec 2014 01:35:42 +0100

With the cartridge emulator implemented on an STM32F4 we can do some cool stuff. For example, we can make the GameBoy boot with our own custom logo!

Bootstrap ROM

When the GameBoy boots, an intenral Bootstrap ROM is mapped to the beginning of the memory and execution begins. This bios is in charge of initializing the hardware as well as scrolling the Nintendo logo and checking that the cartridge i valid. The logo shown on screen is actually read from the cartridge; that’s the reason why a black rectangle appears when no cartridge is inserted, or garbage appears when the cartridge pins fail. If the Nintendo logo doesn’t match the copy stored in the bios, the GameBoy locks itself. But there is a trick we can do! The GameBoy reads the logo from the cartridge two times, the first one to draw it on screen and the second one to check if it’s valid. We can thus send first a custom logo and later the original one in order to let the GameBoy boot properly.

Emulating a GameBoy Cartridge with an STM32F4. Part 2

Wed, 24 Dec 2014 19:46:07 +0100

This post is a continuation of Emulating a GameBoy Cartridge with an STM32F4. Part 1

We have analyzed the memory bus of the GameBoy in order to obtain the timing information of the different signals involved in the read and write operations happening on the cartridge. We will now proceed to develop a system to emulate the behaviour of the cartridge with the STM32F4.

About voltage levels

As we noticed in the previous post, the GameBoy works at 5V whereas the STM32F4 works at 3.3V. We saw that most of the GPIOs of the STM32F4 are 5V tolerant, but they still output 3.3V, so we need to make sure that the GameBoy will detect the high levels properly. Luckily for us, the GameBoy works at TTL level: source. This means that a 3.3V signal will be read as a logic 1 by the GameBoy.

Emulating a GameBoy Cartridge with an STM32F4. Part 1

Wed, 24 Dec 2014 03:33:57 +0100

Introduction

The following project consists on emulating the functionality of a GameBoy cartridge with the development board STM32F4. The system is fully functional and is able to emulate real cartridges (as well as homebrew games) of the type ROM Only and MBC1 (Memory Block Controller 1). In this post I will explain how I managed to achieve this.

Motivation

Current flashcart systems commonly use a design consisting on a FPGA or CPLD controlling the logic of the emulated cartridge (memory banking, RAM access, etc.), a media storage (flash chip or SD card) and an SDRAM chip.

Welcome

Sat, 08 Nov 2014 17:04:11 +0100

I had been planning on creating a blog to write about the stuff I do on my free time for a while. In this blog I plan to write about the projects I develop as well as talking about interesting things I lean about technology, hardware, security, embedded systems, programming languages and more.

My first thought was to use a WordPress hosted at wordpress.com, but I didn’t want the adds. I searched on the net for alternatives and found out about the static website generators, which allow you to host the content in a static web server such as your github personal page. Right now this blog is posted in my server, but I may move it to github if there is some traffic.

About

Fri, 07 Nov 2014 02:35:08 +0100

I’m a Computer Science student from Barcelona with interests in embedded devices, hardware hacking, security and cryptography among others.

I’ve been using Linux for nearly 10 years and tried some *BSD along the way. The main programming languages I use are C, python and lately Go. I enjoy learning about new programming languages and stuff in general.

My github: https://github.com/Dhole
My email: dhole at posteo dot net

Get my PGP public key at dhole.asc or http://pgp.mit.edu/pks/lookup?op=get&search=0x4FA457A18514CC63