2026-09-22T11:02:07+0000 https://pierrelouis.pakupaku.me Installing VoidLinux with BTRFS and FDE 2026-09-22T00:00:00+0000 https://pierrelouis.pakupaku.me/blog/voidlinux-install/ This file was lingering on my computer for a few months. It is at the sime time similar and different to <a href="../debian-root-cryptsetup-keyfile/">this previous post</a>. Note that the format is mostly a list of instructions without long detailed explanations. <h2 id="basic-installation">Basic Installation</h2> Let's assume the following disk layout: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># lsblk NAME MAJ:MIN RM SIZE RO TYPE MOUNTPOINTS vda 253:0 0 32G 0 disk ├─vda1 253:1 0 512M 0 part ├─vda2 253:2 0 1G 0 part └─vda3 253:4 0 30.5G 0 part</code></pre> We format as follows: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># mkfs.vfat -F32 /dev/vda1 # cryptsetup luksFormat --type luks1 /dev/vda2 # cryptsetup luksOpen /dev/vda2 cryptboot # mkfs.ext4 /dev/mapper/cryptboot # cryptsetup luksFormat --type luks2 /dev/vda3 # cryptsetup luksOpen /dev/vda3 cryptroot # mkfs.btrfs /dev/mapper/cryptroot</code></pre> Let's create the basic file system structure: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># mount /dev/mapper/cryptroot /mnt/ # btrfs subvolume create /mnt/@ # btrfs subvolume create /mnt/@home # btrfs subvolume create /mnt/@log # btrfs subvolume create /mnt/@cache # btrfs subvolume create /mnt/@snapshots # btrfs subvolume create /mnt/@vartmp # btrfs subvolume create /mnt/@swap # umount /mnt # mount -o subvol=@,compress=zstd /dev/mapper/cryptroot /mnt/ # mkdir -p /mnt/{.snapshots,home,var/log,var/cache,var/tmp,var/swap} # mount -o subvol=@home,compress=zstd /dev/mapper/cryptroot /mnt/home # mount -o subvol=@log,compress=zstd /dev/mapper/cryptroot /mnt/var/log # mount -o subvol=@cache,compress=zstd /dev/mapper/cryptroot /mnt/var/cache # mount -o subvol=@snapshots,compress=zstd /dev/mapper/cryptroot /mnt/.snapshots # mount -o subvol=@vartmp,compress=zstd /dev/mapper/cryptroot /mnt/var/tmp # mount -o subvol=@swap,compress=none /dev/mapper/cryptroot /mnt/var/swap # mkdir /mnt/boot/ # mount /dev/mapper/cryptboot /mnt/boot/ # mkdir /mnt/boot/efi # mount /dev/vda1 /mnt/boot/efi/</code></pre> And then install the base OS (VoidLinux, libc variant, xbps method): <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># export REPO=https://repo-default.voidlinux.org/current # export ARCH=x86_64 # mkdir -p /mnt/var/db/xbps/keys # cp /var/db/xbps/keys/* /mnt/var/db/xbps/keys/ # XBPS_ARCH=$ARCH xbps-install -S -r /mnt -R &quot;$REPO&quot; base-system \ grub-x86_64-efi linux snapper cryptsetup grub-btrfs btrfs-progs htop \ btop ripgrep neovim # btrfs filesystem mkswapfile --size 4G /mnt/var/swap/swapfile # swapon /mnt/var/swap/swapfile # xgenfstab -U /mnt/ &gt; /mnt/etc/fstab</code></pre> After which we chroot into our new installation: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># xchroot /mnt /bin/bash</code></pre> Let's configure the basic things first: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># echo HOSTNAME &gt; /etc/hostname # ln -sf /usr/share/zoneinfo/&lt;TIMEZONE&gt; /etc/localtime # nvim /etc/rc.conf # go through and check the options # nvim /etc/default/libc-locales # xbps-reconfigure -f glibc-locales # passwd # set root password</code></pre> Then let's deal with encryption. You can find the partition UUID with the <code>blkid /dev/vda&lt;X&gt;</code> command. <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># echo GRUB_ENABLE_CRYPTODISK=y &gt;&gt; /etc/default/grub # sed -i &#39;s/^GRUB_CMDLINE_LINUX_DEFAULT=&quot;.*&quot;/GRUB_CMDLINE_LINUX_DEFAULT=&quot;rd.luks.uuid=&lt;UUID-VDA4&gt; loglevel=4&quot;/&#39; /etc/default/grub # dd bs=1 count=64 if=/dev/urandom of=/boot/root.key # cryptsetup luksAddKey /dev/vda3 /boot/root.key # chmod 000 /boot/root.key # chmod -R g-rwx,o-rwx /boot/root.key # dd bs=1 count=64 if=/dev/urandom of=/boot.key # cryptsetup luksAddKey /dev/vda2 /boot.key # chmod 000 /boot.key # echo -e &#39;cryptboot /dev/disk/by-uuid/&lt;UUID-VDA2&gt; /boot.key luks,discard\ncryptroot /dev/disk/by-uuid/&lt;UUID-VDA4&gt; /boot/root.key luks,discard&#39; &gt;&gt; /etc/crypttab # echo -e &#39;install_items+=&quot; /boot/root.key /etc/crypttab &quot;&#39; &gt; /etc/dracut.conf.d/10-crypt.conf # grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=Void # xbps-reconfigure -fa # will generate the grub config</code></pre> You can now exit the chroot, unmount and close the different (encrypted) partitions, and reboot. <h3 id="btrfs-snapshots">Btrfs Snapshots</h3> https://wiki.archlinux.org/title/Snapper need dbus on voidlinux: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># ln -sf /etc/sv/dbus /var/service/ # reboot # sv start dbus fails: &quot;fail: dbus: unable to change to service directory: file does not exist&quot;</code></pre> Then: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># umount /.snapshots # rm -rf /.snapshots # snapper -c root create-config / # mount -a # remount /.snapshots # nvim /etc/snapper/configs/root # enable or disable auto-snapshotting, etc... # snapper -c root create --description &quot;initial snapshot of working system&quot;</code></pre> You can edit <code>/etc/snapper/configs/root</code> to configure automatic snapshots and other things. <h3 id="select-closer-mirrors">Select Closer Mirrors</h3> <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># xbps-install xmirror # xmirror</code></pre><h2 id="useful-services">Useful Services</h2> <h3 id="power-management">Power Management</h3> <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># xbps-install elogind polkit # ln -sf /etc/sv/dbus /var/service/ # if not done already # ln -sf /etc/sv/elogind /var/service/</code></pre><h3 id="ntp">NTP</h3> <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># xbps-install chrony # ln -sf /etc/sv/chronyd /var/service/</code></pre><h3 id="wireless">Wireless</h3> <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># xbps-install iwd # ln -sf /etc/sv/iwd /var/service/ # ln -sf /etc/sv/dhcpcd /var/service/ # usermod -aG network &lt;USERNAME&gt; # xbps-install impala</code></pre><h3 id="intel-microcode">Intel Microcode</h3> <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">xbps-install void-repo-nonfree xbps-install -S xbps-install intel-ucode</code></pre><h2 id="graphical-interface">Graphical Interface</h2> <h3 id="sway">Sway</h3> <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># xbps-install mesa-dri intel-media-driver seatd xorg-server-xwayland noto-fonts-ttf noto-fonts-cjk nerd-fonts dejavu-fonts-ttf xdg-desktop-portal-gtk sway swaylock swayidle swaybg ghostty fuzzel # ln -sf /etc/sv/seatd /var/service/ # usermod -aG _seatd &lt;USERNAME&gt;</code></pre> <code>ly</code> is not in the VoidLinux packages, so we need to compile it by ourselves: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">$ sudo xbps-install curl wget xz $ mkdir -p ~/workspace/voidlinux $ cd ~workspace/voidlinux $ wget https://ziglang.org/download/0.16.0/zig-x86_64-linux-0.16.0.tar.xz $ tar xf zig-x86_64-linux-0.16.0.tar.xz $ cd ~workspace/voidlinux $ sudo xbps-install git pam-devel brightnessctl libxcb libxcb-devel make gcc $ sudo usermod -aG input,plugdev,storage &lt;USERNAME&gt; $ git clone https://github.com/fairyglade/ly.git $ cd ly $ ../zig-x86_64-linux-0.16.0/zig build $ sudo zig build installexe -Dinit_system=runit $ sudo ln -sf /etc/sv/ly /var/service/ $ sudo rm /var/service/agetty-tty2</code></pre> Before finishing, let's get an initial sway configuration: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">$ mkdir -p .config/sway $ cp /etc/sway/config ~/.config/sway/</code></pre> We need to change the default terminal and menu applications: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">set $term ghostty set $menu fuzzel</code></pre> We can now login to sway via ly. <h3 id="sound">Sound</h3> <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># xbps-install pipewire wireplumber libjack-pipewire wiremix # mkdir -p /etc/pipewire/pipewire.conf.d # ln -s /usr/share/examples/wireplumber/10-wireplumber.conf /etc/pipewire/pipewire.conf.d/ # ln -s /usr/share/examples/pipewire/20-pipewire-pulse.conf /etc/pipewire/pipewire.conf.d/ # echo &quot;/usr/lib/pipewire-0.3/jack&quot; &gt; /etc/ld.so.conf.d/pipewire-jack.conf # reboot</code></pre> Start <code>pipewire</code> from your session manager so that it automatically start when you log-in. (Note that I don't have any sound via the jack plug...) <code>wiremix</code> is a TUI-based application to control the pipewire. <h3 id="bluetooth">Bluetooth</h3> <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># xbps-install libspa-bluetooth bluez bluetui # ln -sf /etc/sv/bluetoothd /var/service/</code></pre> <code>bluetui</code> is a TUI-based application written in Rust to control the Bluetooth. <h3 id="japanese-keyboard">Japanese Keyboard</h3> <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">sudo xbps-install fcitx5-mozc fcitx5-configtool fcitx5-configtool</code></pre> Edit Sway configuration to start fcitx on log-in. <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">exec fcitx5</code></pre><h2 id="post-installation">Post-Installation</h2> Install several useful applications: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">$ sudo xbps-install screen yazi rsync firefox vlc meld beancount fava baobab</code></pre> If you use the tridactyl extension, to navigate in Firefox with vim-like keybindings, and want smooth scrolling: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">:set smoothscroll true</code></pre> Install <code>marimo</code> (like jupyter notebooks but in Python): <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">$ sudo xbps-install uv $ mkdir ~/workspace/voidlinux/marimo-uv $ cd ~/workspace/voidlinux/marimo-uv $ uv init $ uv add &quot;marimo[recommended]&quot;</code></pre> To LLM or not to LLM 2026-05-30T00:00:00+0000 https://pierrelouis.pakupaku.me/blog/about-llm/ <h2 id="foreword">Foreword</h2> Whatever our opinions on the matter, Large-Language Models (LLM for short), dubbed "AI" by the layman, are around us and here to stay. After some time lurking on <a rel="external" href="https://lobste.rs">lobste.rs</a>, it feels like there are two distinct camps: (1) LLMs are great and we should embrace them; or (2) LLMs are bad and we should not use them, resist and ban them (one such example is <a rel="external" href="https://airesistlist.org/">airesistlist.org</a>). Actually, banned AI/Robots is a recurrent theme in Sci-Fi works: Dune, Asimov's universe, Blade Runner, Battlestar Galactica, Mass Effect, and so on. (Note that there are also works where sentient machines co-exist with humans, e.g., Star Wars). I've personally used LLMs a bit to generate text, simple scripts, or images. It can be helpful, but my current impression is this is the case only when the Human in the loop knows about the discussed subject; these systems are too prone to hallucination and too persuasive. As for generating images, my excuse is my skills are stuck at drawing stick figures. In this post I'd like to explore a few thoughts on this topic. <h2 id="who-created-the-output">Who Created the Output?</h2> A typical discussion about LLM and copyright can quickly turns into stating that LLMs have been fed with copyrighted material without any regard for the rules, whatever we might think about those rules. Going a bit further, we can ask ourselves who created the result the LLM produces. I clearly remember the first time I asked an LLM to write a scientific-looking text. I was just curious. While the text was not too bad, I didn't feel like I owned it. It was not my text; it was written by someone else. How could I claim this text is my contribution if I am not the one having written it? By analogy to books, I was the publisher while the LLM was the writer. Other criticisms I've read are: <ul> <li>the LLM can change the voice of the author, potentially cleverly integrating its creator's agenda due to training bias;</li> <li>one doesn't learn how to write, how to express himself, when asking an LLM to write text;</li> <li>why would one bother reading text that was not thoughtfully created?</li> </ul> <h2 id="the-artistic-nature-of-humankind">The Artistic Nature of Humankind</h2> Another topic that comes often in discussions is whether machines will replace humans or not. Looking in the (not too distant past), I'm pretty sure painters had similar questions at the dawn of photography. As we can observe, photography didn't replace paintings. Painters adapted their style to something more abstract, less realistic, because realistic painting didn't make sense anymore. It took some times to adapt, sure; there was a period of turmoil where no one knew what would come out of it, and I believe we are in the same situation at the time of writing this. Even more recently, digital photography and good cameras on smartphones didn't kill professional photographers. What they did was merely decreasing the cost of taking a picture, similar to photography decreasing the cost of saving an instant compared to painting. Some people also reflected on this situation and tried to make their pictures special, not just showing what something looked like, but how it felt. I'm thinking of street photography in particular: the photographer conveys emotions in addition to a visual copy of a given situation. Expressing emotions in photography was one of my reasons to get a new DSLR (it's expensive, I need reasons to justify the expense). My phone is for non-artistic pictures, for things I need to remember for later (the price of an object, the title of a book), while the DSLR is for artistic purposes. I cannot claim I am good at it; this is only the direction I aim for. Another analogy would be craftmanship vs mass production. On one side we have a unique product that takes time and skill to make; on the other side we have a bland, standardized product devoid of any human touch. Not that one is worse than the other (everyone nowadays possesses tons of mass produced products), they are just different. In short, after having industrialised labour in the past decades, LLMs industrialise creativity. I think both can co-exist the same way painting and photography, music concert and music players, or craftmanship and mass production. Depending on the task, person, and other factors, one can prefer one or the other. <h2 id="the-darkside-of-llms">The Darkside of LLMs</h2> Ideally, technology is neither good nor bad, it is the way we use it that makes it good or bad. However, I think there is something bad about the current state of LLMs: the current framework of our society. Which LLMs does the layman person know? The most famous ones are created and maintained by private companies who do not really have their users' best interests in mind: collection and use of data without users' consent, absence of guardrails to prevent misuses or disinformation, prioritize quick economic returns instead of long-term well-being, etc. If people would be less interested in their own personal gains, if there were more guardrails and regulations, more accountability, better education, and less pressure tactics from the people in control then maybe we could achieve a better society. <h2 id="about-the-environment">About the Environment</h2> There exists numerous complaints about the impact of LLMs on the environment. Some people claim that, well, the power consumption is not too bad, renewable energies are used when possible, the hardware is getting more efficient, etc. Well, bad news, doing a computation, whatever its efficiency is, consumes more energy than not doing it. For many things in life we seem to forget to ask whether it is worth it. It is not because we can do something that we should do it. I believe that mass adoption of LLMs is not worth the damage. Yes, LLMs and other technics under the AI/machine learning umbrella can be useful in some cases, but this is not something we should push in every corner of society for the sake of riding the buzzword train. We need to slow down and consider the long-term effects first. Homo Sapiens appeared ~300,000 years ago, writing is commonly recognized to having been invented ~5000 years ago, the industrial revolution was a couple of centuries ago, and the term "machine learning" appeared less than 70 years ago. We do not need to disrupt our lives every minute and rush towards destruction. Let's preserve what we have and consider the history of humanity as a marathon, not a sprint. What's the worst case? Long-term suffering on one hand, or not being able to get our dopamine rush in the next 5 seconds on the other hand. <h2 id="what-s-next">What's next</h2> Is the solution a total boycott of LLMs? I do not believe so because it is already too late and not realistic. Instead, we can reflect on our relationship with them and respect ourselves by making them ethical and safer. Instead of using closed-source models trained on unknown, potentially copyrighted content, we can use open-source ones. Instead of using the models of big, monopolistic corporations we can use the ones of companies that care for our privacy as well as the environment (LLMs run locally are also a solution to be considered). And, all-in-all, let's not forget that we are a social species; interaction with a program will never replace interaction with another real human. Leveraging Trusted Execution Environments to make Online Video Games Cheat-Resistant 2026-05-14T00:00:00+0000 https://pierrelouis.pakupaku.me/blog/gangi/ <h1 id="introduction">Introduction</h1> Even though video games have strong performance requirements, protecting online video games by leveraging TEEs is not a trivial task due to the inherent limitations of TEEs: (i) memory size limitation; (2) no direct access to I/O operations; and (3) non negligible performance overhead to ensure security properties of the TEE. The challenges of this research project are three-fold: 1) how to design an effective method to partition the game code into a secure and unsecure part, to keep the memory footprint small; 2) how to provide trusted I/O; and 3) how to ensure acceptable performance. <h1 id="projects">Projects</h1> <h2 id="gangi">Gangi</h2> The global online video game industry has become a more than one hundred billion dollar market. Cheating is one of the major issues in multiplayer online video games. Cheat prevention is challenging because of the unique threat model of online games. Because the cheaters physically possess their own game computers, they can install cheat tools at the user level and OS and can access the physical DRAM bus to tamper with the game process. We propose to efficiently prevent memory tampering cheats by leveraging a trusted execution environment (TEE), Intel Client SGX. It provides strong integrity protection against memory tampering. Unfortunately, its strong protection comes with a severe size limitation of the available enclave memory. Running the entire game process inside the enclave exceeds the memory limit. <img src="https://pierrelouis.pakupaku.me/blog/gangi/gangi.jpg" alt="Gangi architecture" title="Gangi architecture" /> We present Gangi (architecture depicted above), a library that efficiently protects the integrity-sensitive game state that exceeds the available enclave memory. Gangi places the game state outside the enclave to reduce memory consumption inside the enclave while ensuring the integrity of the game state by hash-based validation. Our benchmarking results show that a Gangi-protected game outperforms the EPC swapping approach with the entire game state being inside the enclave. <h2 id="hybrid-tee">Hybrid TEE</h2> With cyber threats on the rise, the security of computer applications is critical. One practical solution to secure applications is to employ a Trusted Execution Environments (TEE): a secure area within the processor that protects code and data against a strong attacker. A major issue faced by current architectures is the trade-off between guaranteeing freshness (i.e., data is up-to-date) and proposing a large secure memory. Without guaranteeing freshness, applications are vulnerable to unauthorized access or computing wrong results. Unfortunately, existing solutions either do not scale beyond a few hundred MB or weaken security. <img src="https://pierrelouis.pakupaku.me/blog/gangi/hybridtee.jpg" alt="Hybrid TEE achitecture" /> We propose a hybrid approach that combines both types of TEEs. Key challenges include: (i) application suitability; (ii) secure application partitioning; (iii) robust multi-TEE attestation; and (iv) efficient cross-TEE communication. We are currently addressing the above challenges via three use cases: a Database, Machine Learning, and Web applications. Implementation is under way on the Gem5 simulator with the RISC-V open-source architecture. <h2 id="secure-i-o">Secure I/O</h2> Protecting the integrity and confidentiality of user input (I/O) is a fundamental challenge in computer security. Modern systems remain vulnerable to a wide spectrum of attacks, ranging from physical hardware implants (e.g., hardware keyloggers) to kernel-level malware. While Trusted Execution Environments (TEEs) like Intel SGX have enabled isolated processing on the host, existing secure I/O solutions often assume the trustworthiness of the peripheral device and the integrity of the physical connection, failing to protect against "Evil Maid" attacks or compromised peripheral firmware. <img src="https://pierrelouis.pakupaku.me/blog/gangi/secureio.png" alt="Secure I/O achitecture" /> In this project we propose a novel architecture that establishes a distributed root of trust spanning both the I/O peripheral and the host (see figure above). By leveraging ARM TrustZone on both the client (Cortex-A) and the input device (Cortex-M), it becomes possible to create an authenticated, encrypted channel using DTLS over Ethernet-over-USB. This design bypasses vulnerable legacy USB stacks and operating system kernels. We propose a protocol for secure firmware updates, multi-application isolation via secure port switching, and mutual attestation verifiable via an out-of-band mobile application. An implementation on a Raspberry Pi 3 (leveraging the OP-TEE framework) and a Raspberry Pi Pico 2W, as well as a real keyboard, is currently in progress. Current results are promising (see below), we measured the communication throughput and latency of TCP, UDP and DTLS on a pair of Raspberry Pi3 connected via an ethernet cable (100Mpbs of bandwidth). First, UDP throughput (resp. latency) is higher (resp. lower) than TCP by 20% (resp. 17%), which strengthens our choice to base our protocol on DTLS instead of TLS. Second, DTLS overhead compared to UDP is less than 10%. Around 1400 scancodes can be sent and received every second, which is higher than the speed of high-end human interface peripherals, and higher than human reflexes. <img src="https://pierrelouis.pakupaku.me/blog/gangi/secureio_perf.png" alt="Secure I/O performance" /> <h2 id="secure-camera">Secure Camera</h2> The era of fake news is upon us. Manipulated images are a particular potent medium. Current state-of-the-art methods rely on image processing techniques, which is unfortunately not sufficient to detect manipulations. In this project we propose the Trusted Camera Framework, an alternative approach that aims at creating secure images by leveraging Trusted Execution Environments. It transparently embeds cryptographic signatures into the image file to prove its authenticity and to correctly detail which post-processing modifications have been applied. Our implementation leverages the PNG file format. An evaluation on several Raspberry Pi devices, with performance similar to recent smartphones, demonstrates they can create such secure images without compromising their image acquisition performance. <h1 id="outputs">Outputs</h1> <ul> <li>Terufumi Hata, Kenta Ishiguro, Pierre-Louis Aublin, Kenji Kono, Gangi: Preventing Memory Tampering Cheats in Online Games, Journal of Information Processing, 2025, 33 巻, p. 901-912, 公開日 2025/11/15, Online ISSN 1882-6652, <a rel="external" href="https://doi.org/10.2197/ipsjjip.33.901">doi</a>, <a rel="external" href="https://www.jstage.jst.go.jp/article/ipsjjip/33/0/33_901/_article/-char/ja">paper</a></li> <li>P.-L. Aublin, "What You See Is Not What You Get: Introducing the Trusted Camera Framework to Combat Fake News," 2025 IEEE Conference on Dependable, Autonomic and Secure Computing (DASC), Hakodate, Japan, 2025, pp. 15-22, <a rel="external" href="https://doi.org/10.1109/DASC68382.2025.00010">doi</a></li> <li>Bijun Li and Pierre-Louis Aublin. 2023. Transparent Management of BFT Systems with TEE. In Proceedings of the 6th Workshop on System Software for Trusted Execution (SysTEX '23). Association for Computing Machinery, New York, NY, USA, 17–19. <a rel="external" href="https://doi.org/10.1145/3578359.3593041">doi</a></li> <li>Aublin, Pierre-Louis, Mohammad Mahhouk, and Rüdiger Kapitza. "Towards TEEs with large secure memory and integrity protection against HW attacks." SysTEX’22: 5th Workshop on System Software for Trusted Execution, February 28, 2022, Lausanne, Switzerland. 2022, <a rel="external" href="https://systex22.github.io/papers/systex22-final15.pdf">paper</a></li> </ul> <h1 id="grant-details">Grant details</h1> <ul> <li>Grant number: <a href="https://kaken.nii.ac.jp/en/grant/KAKENHI-PROJECT-21K17726/">21K17726</a></li> <li>Type: JSPS KAKENHI Grant-in-Aid for Early-Career Scientists</li> <li>Timeline: FY 2021-2025 (April 2021 to March 2025)</li> <li>Budget: budget: ¥2.6M</li> </ul> Hacking the Bebird R1 camera device 2026-04-29T00:00:00+0000 https://pierrelouis.pakupaku.me/blog/bebird-camera/ <h2 id="introduction">Introduction</h2> I have a Bebird R1 "smart visual ear cleaner". It's a pen-like small device with a small camera at the end that can be introduced in various cavities such as the ears or nose to see details, and as advertised to clean them. Besides its primary goal it is also fun to see details invisible to the naked eyes on various surfaces: fabric (see the image below), screen pixels, etc. <img src="https://pierrelouis.pakupaku.me/blog/bebird-camera/bebirdr1.jpg" alt="Bebird R1" /> <img src="https://pierrelouis.pakupaku.me/blog/bebird-camera/fabric.jpg" alt="Bebird R1" /> It is ok to use, especially for its low price, but I have two complaints: <ol> <li>it requires using the official application for iOS/Android;</li> <li>the camera claims to be HD, yet the stream I receive on the application is not HD.</li> </ol> Below is a screenshot of the app interface on my tablet. You can see that it uses a small portion of the screen (in both portrait or landscape modes). <img src="https://pierrelouis.pakupaku.me/blog/bebird-camera/app.jpg" alt="App interface" /> So, let's explore how it works and whether we can lift these restrictions! <h2 id="getting-access-to-the-stream">Getting access to the stream</h2> The Bebird creates a Wifi access point when turned on (that could have been a third complaint; I prefer cables). Let's connect the PC to it and scan for open ports: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">$ arp -n Address HWtype HWaddress Flags Mask Iface 192.168.5.1 ether fc:58:4a:ea:ad:63 C wlan0 $ sudo nmap -sS -sU -p- -T4 192.168.5.1 Nmap scan report for 192.168.5.1 Host is up (0.0055s latency). Not shown: 65532 closed tcp ports (reset), 65530 closed udp ports (port-unreach) PORT STATE SERVICE 58050/tcp open unknown 58090/tcp open unknown 58098/tcp open unknown 53/udp open domain 67/udp open|filtered dhcps 58080/udp open|filtered unknown 58090/udp open|filtered unknown 58098/udp open|filtered unknown MAC Address: FC:58:4A:EA:AD:63 (xiamenshi c-chip technology)</code></pre> I tried to connect my browser to the various TCP port, which quickly led me to discover a web interface at <code>http://192.168.5.1:58050</code>. Hooray! <img src="https://pierrelouis.pakupaku.me/blog/bebird-camera/webinterface.png" alt="Web interface" /> Looking at the webpage source, I've also found the address of the MPEG stream, which I can then open in e.g., VLC: <code>http://192.168.5.1:58050/live</code>. However, this is only 480x480, not HD at all. <h2 id="hacking-the-application-protocol">Hacking the application protocol</h2> I can now access the camera from my computer, in fullscreen, but the stream quality is not very good (only 480x480 pixels). Maybe if I analyse the messages exchanged between the camera and the app I could find the HD stream address? <h3 id="communication-protocol-analysis">Communication Protocol Analysis</h3> To record the network packets exchanged between the application on my tablet and the bebird I use PCAPDroid (available on F-Droid). It can record a pcap file that can then be copied to the computer for further analysis in Wireshark. Here is a short version of the exchanged bytes: <svg id="mermaid-1777886773322-cft8x6ja8" width="100%" xmlns="http://www.w3.org/2000/svg" style="max-width: 784px;" viewBox="-50 -10 784 1012" role="graphics-document document" aria-roledescription="sequence"><rect x="64" y="832" fill="rgba(200, 0, 0, 0.9)" width="556" height="74" class="rect"></rect><rect x="64" y="267" fill="rgba(191, 223, 255, 0.7)" width="556" height="506" class="rect"></rect><rect x="64" y="75" fill="rgba(221, 201, 47, 0.7)" width="556" height="182" class="rect"></rect><g><rect x="534" y="926" fill="#eaeaea" stroke="#666" width="150" height="65" name="Camera" rx="3" ry="3" class="actor actor-bottom"></rect><text x="609" y="958.5" style="text-anchor: middle; font-size: 16px; font-weight: 400;" dominant-baseline="central" alignment-baseline="central" class="actor actor-box"><tspan x="609" dy="0">Camera</tspan></text></g><g><rect x="0" y="926" fill="#eaeaea" stroke="#666" width="150" height="65" name="App" rx="3" ry="3" class="actor actor-bottom"></rect><text x="75" y="958.5" style="text-anchor: middle; font-size: 16px; font-weight: 400;" dominant-baseline="central" alignment-baseline="central" class="actor actor-box"><tspan x="75" dy="0">App</tspan></text></g><g><line id="actor181" x1="609" y1="65" x2="609" y2="926" class="actor-line 200" stroke-width="0.5px" stroke="#999" name="Camera"></line><g id="root-181"><rect x="534" y="0" fill="#eaeaea" stroke="#666" width="150" height="65" name="Camera" rx="3" ry="3" class="actor actor-top"></rect><text x="609" y="32.5" style="text-anchor: middle; font-size: 16px; font-weight: 400;" dominant-baseline="central" alignment-baseline="central" class="actor actor-box"><tspan x="609" dy="0">Camera</tspan></text></g></g><g><line id="actor180" x1="75" y1="65" x2="75" y2="926" class="actor-line 200" stroke-width="0.5px" stroke="#999" name="App"></line><g id="root-180"><rect x="0" y="0" fill="#eaeaea" stroke="#666" width="150" height="65" name="App" rx="3" ry="3" class="actor actor-top"></rect><text x="75" y="32.5" style="text-anchor: middle; font-size: 16px; font-weight: 400;" dominant-baseline="central" alignment-baseline="central" class="actor actor-box"><tspan x="75" dy="0">App</tspan></text></g></g><style>#mermaid-1777886773322-cft8x6ja8{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;fill:#333;}@keyframes edge-animation-frame{from{stroke-dashoffset:0;}}@keyframes dash{to{stroke-dashoffset:0;}}#mermaid-1777886773322-cft8x6ja8 .edge-animation-slow{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 50s linear infinite;stroke-linecap:round;}#mermaid-1777886773322-cft8x6ja8 .edge-animation-fast{stroke-dasharray:9,5!important;stroke-dashoffset:900;animation:dash 20s linear infinite;stroke-linecap:round;}#mermaid-1777886773322-cft8x6ja8 .error-icon{fill:#552222;}#mermaid-1777886773322-cft8x6ja8 .error-text{fill:#552222;stroke:#552222;}#mermaid-1777886773322-cft8x6ja8 .edge-thickness-normal{stroke-width:1px;}#mermaid-1777886773322-cft8x6ja8 .edge-thickness-thick{stroke-width:3.5px;}#mermaid-1777886773322-cft8x6ja8 .edge-pattern-solid{stroke-dasharray:0;}#mermaid-1777886773322-cft8x6ja8 .edge-thickness-invisible{stroke-width:0;fill:none;}#mermaid-1777886773322-cft8x6ja8 .edge-pattern-dashed{stroke-dasharray:3;}#mermaid-1777886773322-cft8x6ja8 .edge-pattern-dotted{stroke-dasharray:2;}#mermaid-1777886773322-cft8x6ja8 .marker{fill:#333333;stroke:#333333;}#mermaid-1777886773322-cft8x6ja8 .marker.cross{stroke:#333333;}#mermaid-1777886773322-cft8x6ja8 svg{font-family:"trebuchet ms",verdana,arial,sans-serif;font-size:16px;}#mermaid-1777886773322-cft8x6ja8 p{margin:0;}#mermaid-1777886773322-cft8x6ja8 .actor{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-1777886773322-cft8x6ja8 text.actor&gt;tspan{fill:black;stroke:none;}#mermaid-1777886773322-cft8x6ja8 .actor-line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-1777886773322-cft8x6ja8 .innerArc{stroke-width:1.5;stroke-dasharray:none;}#mermaid-1777886773322-cft8x6ja8 .messageLine0{stroke-width:1.5;stroke-dasharray:none;stroke:#333;}#mermaid-1777886773322-cft8x6ja8 .messageLine1{stroke-width:1.5;stroke-dasharray:2,2;stroke:#333;}#mermaid-1777886773322-cft8x6ja8 #arrowhead path{fill:#333;stroke:#333;}#mermaid-1777886773322-cft8x6ja8 .sequenceNumber{fill:white;}#mermaid-1777886773322-cft8x6ja8 #sequencenumber{fill:#333;}#mermaid-1777886773322-cft8x6ja8 #crosshead path{fill:#333;stroke:#333;}#mermaid-1777886773322-cft8x6ja8 .messageText{fill:#333;stroke:none;}#mermaid-1777886773322-cft8x6ja8 .labelBox{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-1777886773322-cft8x6ja8 .labelText,#mermaid-1777886773322-cft8x6ja8 .labelText&gt;tspan{fill:black;stroke:none;}#mermaid-1777886773322-cft8x6ja8 .loopText,#mermaid-1777886773322-cft8x6ja8 .loopText&gt;tspan{fill:black;stroke:none;}#mermaid-1777886773322-cft8x6ja8 .loopLine{stroke-width:2px;stroke-dasharray:2,2;stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);}#mermaid-1777886773322-cft8x6ja8 .note{stroke:#aaaa33;fill:#fff5ad;}#mermaid-1777886773322-cft8x6ja8 .noteText,#mermaid-1777886773322-cft8x6ja8 .noteText&gt;tspan{fill:black;stroke:none;}#mermaid-1777886773322-cft8x6ja8 .activation0{fill:#f4f4f4;stroke:#666;}#mermaid-1777886773322-cft8x6ja8 .activation1{fill:#f4f4f4;stroke:#666;}#mermaid-1777886773322-cft8x6ja8 .activation2{fill:#f4f4f4;stroke:#666;}#mermaid-1777886773322-cft8x6ja8 .actorPopupMenu{position:absolute;}#mermaid-1777886773322-cft8x6ja8 .actorPopupMenuPanel{position:absolute;fill:#ECECFF;box-shadow:0px 8px 16px 0px rgba(0,0,0,0.2);filter:drop-shadow(3px 5px 2px rgb(0 0 0 / 0.4));}#mermaid-1777886773322-cft8x6ja8 .actor-man line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;}#mermaid-1777886773322-cft8x6ja8 .actor-man circle,#mermaid-1777886773322-cft8x6ja8 line{stroke:hsl(259.6261682243, 59.7765363128%, 87.9019607843%);fill:#ECECFF;stroke-width:2px;}#mermaid-1777886773322-cft8x6ja8 :root{--mermaid-font-family:"trebuchet ms",verdana,arial,sans-serif;}</style><g></g><defs><symbol id="computer" width="24" height="24"><path transform="scale(.5)" d="M2 2v13h20v-13h-20zm18 11h-16v-9h16v9zm-10.228 6l.466-1h3.524l.467 1h-4.457zm14.228 3h-24l2-6h2.104l-1.33 4h18.45l-1.297-4h2.073l2 6zm-5-10h-14v-7h14v7z"></path></symbol></defs><defs><symbol id="database" fill-rule="evenodd" clip-rule="evenodd"><path transform="scale(.5)" d="M12.258.001l.256.004.255.005.253.008.251.01.249.012.247.015.246.016.242.019.241.02.239.023.236.024.233.027.231.028.229.031.225.032.223.034.22.036.217.038.214.04.211.041.208.043.205.045.201.046.198.048.194.05.191.051.187.053.183.054.18.056.175.057.172.059.168.06.163.061.16.063.155.064.15.066.074.033.073.033.071.034.07.034.069.035.068.035.067.035.066.035.064.036.064.036.062.036.06.036.06.037.058.037.058.037.055.038.055.038.053.038.052.038.051.039.05.039.048.039.047.039.045.04.044.04.043.04.041.04.04.041.039.041.037.041.036.041.034.041.033.042.032.042.03.042.029.042.027.042.026.043.024.043.023.043.021.043.02.043.018.044.017.043.015.044.013.044.012.044.011.045.009.044.007.045.006.045.004.045.002.045.001.045v17l-.001.045-.002.045-.004.045-.006.045-.007.045-.009.044-.011.045-.012.044-.013.044-.015.044-.017.043-.018.044-.02.043-.021.043-.023.043-.024.043-.026.043-.027.042-.029.042-.03.042-.032.042-.033.042-.034.041-.036.041-.037.041-.039.041-.04.041-.041.04-.043.04-.044.04-.045.04-.047.039-.048.039-.05.039-.051.039-.052.038-.053.038-.055.038-.055.038-.058.037-.058.037-.06.037-.06.036-.062.036-.064.036-.064.036-.066.035-.067.035-.068.035-.069.035-.07.034-.071.034-.073.033-.074.033-.15.066-.155.064-.16.063-.163.061-.168.06-.172.059-.175.057-.18.056-.183.054-.187.053-.191.051-.194.05-.198.048-.201.046-.205.045-.208.043-.211.041-.214.04-.217.038-.22.036-.223.034-.225.032-.229.031-.231.028-.233.027-.236.024-.239.023-.241.02-.242.019-.246.016-.247.015-.249.012-.251.01-.253.008-.255.005-.256.004-.258.001-.258-.001-.256-.004-.255-.005-.253-.008-.251-.01-.249-.012-.247-.015-.245-.016-.243-.019-.241-.02-.238-.023-.236-.024-.234-.027-.231-.028-.228-.031-.226-.032-.223-.034-.22-.036-.217-.038-.214-.04-.211-.041-.208-.043-.204-.045-.201-.046-.198-.048-.195-.05-.19-.051-.187-.053-.184-.054-.179-.056-.176-.057-.172-.059-.167-.06-.164-.061-.159-.063-.155-.064-.151-.066-.074-.033-.072-.033-.072-.034-.07-.034-.069-.035-.068-.035-.067-.035-.066-.035-.064-.036-.063-.036-.062-.036-.061-.036-.06-.037-.058-.037-.057-.037-.056-.038-.055-.038-.053-.038-.052-.038-.051-.039-.049-.039-.049-.039-.046-.039-.046-.04-.044-.04-.043-.04-.041-.04-.04-.041-.039-.041-.037-.041-.036-.041-.034-.041-.033-.042-.032-.042-.03-.042-.029-.042-.027-.042-.026-.043-.024-.043-.023-.043-.021-.043-.02-.043-.018-.044-.017-.043-.015-.044-.013-.044-.012-.044-.011-.045-.009-.044-.007-.045-.006-.045-.004-.045-.002-.045-.001-.045v-17l.001-.045.002-.045.004-.045.006-.045.007-.045.009-.044.011-.045.012-.044.013-.044.015-.044.017-.043.018-.044.02-.043.021-.043.023-.043.024-.043.026-.043.027-.042.029-.042.03-.042.032-.042.033-.042.034-.041.036-.041.037-.041.039-.041.04-.041.041-.04.043-.04.044-.04.046-.04.046-.039.049-.039.049-.039.051-.039.052-.038.053-.038.055-.038.056-.038.057-.037.058-.037.06-.037.061-.036.062-.036.063-.036.064-.036.066-.035.067-.035.068-.035.069-.035.07-.034.072-.034.072-.033.074-.033.151-.066.155-.064.159-.063.164-.061.167-.06.172-.059.176-.057.179-.056.184-.054.187-.053.19-.051.195-.05.198-.048.201-.046.204-.045.208-.043.211-.041.214-.04.217-.038.22-.036.223-.034.226-.032.228-.031.231-.028.234-.027.236-.024.238-.023.241-.02.243-.019.245-.016.247-.015.249-.012.251-.01.253-.008.255-.005.256-.004.258-.001.258.001zm-9.258 20.499v.01l.001.021.003.021.004.022.005.021.006.022.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.023.018.024.019.024.021.024.022.025.023.024.024.025.052.049.056.05.061.051.066.051.07.051.075.051.079.052.084.052.088.052.092.052.097.052.102.051.105.052.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.048.144.049.147.047.152.047.155.047.16.045.163.045.167.043.171.043.176.041.178.041.183.039.187.039.19.037.194.035.197.035.202.033.204.031.209.03.212.029.216.027.219.025.222.024.226.021.23.02.233.018.236.016.24.015.243.012.246.01.249.008.253.005.256.004.259.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.021.224-.024.22-.026.216-.027.212-.028.21-.031.205-.031.202-.034.198-.034.194-.036.191-.037.187-.039.183-.04.179-.04.175-.042.172-.043.168-.044.163-.045.16-.046.155-.046.152-.047.148-.048.143-.049.139-.049.136-.05.131-.05.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.053.083-.051.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.05.023-.024.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.023.01-.022.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.127l-.077.055-.08.053-.083.054-.085.053-.087.052-.09.052-.093.051-.095.05-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.045-.118.044-.12.043-.122.042-.124.042-.126.041-.128.04-.13.04-.132.038-.134.038-.135.037-.138.037-.139.035-.142.035-.143.034-.144.033-.147.032-.148.031-.15.03-.151.03-.153.029-.154.027-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.01-.179.008-.179.008-.181.006-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.006-.179-.008-.179-.008-.178-.01-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.027-.153-.029-.151-.03-.15-.03-.148-.031-.146-.032-.145-.033-.143-.034-.141-.035-.14-.035-.137-.037-.136-.037-.134-.038-.132-.038-.13-.04-.128-.04-.126-.041-.124-.042-.122-.042-.12-.044-.117-.043-.116-.045-.113-.045-.112-.046-.109-.047-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.05-.093-.052-.09-.051-.087-.052-.085-.053-.083-.054-.08-.054-.077-.054v4.127zm0-5.654v.011l.001.021.003.021.004.021.005.022.006.022.007.022.009.022.01.022.011.023.012.023.013.023.015.024.016.023.017.024.018.024.019.024.021.024.022.024.023.025.024.024.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.052.11.051.114.051.119.052.123.05.127.051.131.05.135.049.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.044.171.042.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.022.23.02.233.018.236.016.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.012.241-.015.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.048.139-.05.136-.049.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.051.051-.049.023-.025.023-.024.021-.025.02-.024.019-.024.018-.024.017-.024.015-.023.014-.023.013-.024.012-.022.01-.023.01-.023.008-.022.006-.022.006-.022.004-.021.004-.022.001-.021.001-.021v-4.139l-.077.054-.08.054-.083.054-.085.052-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.049-.105.048-.106.047-.109.047-.111.046-.114.045-.115.044-.118.044-.12.044-.122.042-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.035-.143.033-.144.033-.147.033-.148.031-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.025-.161.024-.162.023-.163.022-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.011-.178.009-.179.009-.179.007-.181.007-.182.005-.182.004-.184.003-.184.002h-.37l-.184-.002-.184-.003-.182-.004-.182-.005-.181-.007-.179-.007-.179-.009-.178-.009-.176-.011-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.022-.162-.023-.161-.024-.159-.025-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.031-.146-.033-.145-.033-.143-.033-.141-.035-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.04-.126-.041-.124-.042-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.047-.105-.048-.102-.049-.1-.049-.097-.05-.095-.051-.093-.051-.09-.051-.087-.053-.085-.052-.083-.054-.08-.054-.077-.054v4.139zm0-5.666v.011l.001.02.003.022.004.021.005.022.006.021.007.022.009.023.01.022.011.023.012.023.013.023.015.023.016.024.017.024.018.023.019.024.021.025.022.024.023.024.024.025.052.05.056.05.061.05.066.051.07.051.075.052.079.051.084.052.088.052.092.052.097.052.102.052.105.051.11.052.114.051.119.051.123.051.127.05.131.05.135.05.139.049.144.048.147.048.152.047.155.046.16.045.163.045.167.043.171.043.176.042.178.04.183.04.187.038.19.037.194.036.197.034.202.033.204.032.209.03.212.028.216.027.219.025.222.024.226.021.23.02.233.018.236.017.24.014.243.012.246.01.249.008.253.006.256.003.259.001.26-.001.257-.003.254-.006.25-.008.247-.01.244-.013.241-.014.237-.016.233-.018.231-.02.226-.022.224-.024.22-.025.216-.027.212-.029.21-.03.205-.032.202-.033.198-.035.194-.036.191-.037.187-.039.183-.039.179-.041.175-.042.172-.043.168-.044.163-.045.16-.045.155-.047.152-.047.148-.048.143-.049.139-.049.136-.049.131-.051.126-.05.123-.051.118-.052.114-.051.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.052.07-.051.065-.051.06-.051.056-.05.051-.049.023-.025.023-.025.021-.024.02-.024.019-.024.018-.024.017-.024.015-.023.014-.024.013-.023.012-.023.01-.022.01-.023.008-.022.006-.022.006-.022.004-.022.004-.021.001-.021.001-.021v-4.153l-.077.054-.08.054-.083.053-.085.053-.087.053-.09.051-.093.051-.095.051-.097.05-.1.049-.102.048-.105.048-.106.048-.109.046-.111.046-.114.046-.115.044-.118.044-.12.043-.122.043-.124.042-.126.041-.128.04-.13.039-.132.039-.134.038-.135.037-.138.036-.139.036-.142.034-.143.034-.144.033-.147.032-.148.032-.15.03-.151.03-.153.028-.154.028-.156.027-.158.026-.159.024-.161.024-.162.023-.163.023-.165.021-.166.02-.167.019-.169.018-.169.017-.171.016-.173.015-.173.014-.175.013-.175.012-.177.01-.178.01-.179.009-.179.007-.181.006-.182.006-.182.004-.184.003-.184.001-.185.001-.185-.001-.184-.001-.184-.003-.182-.004-.182-.006-.181-.006-.179-.007-.179-.009-.178-.01-.176-.01-.176-.012-.175-.013-.173-.014-.172-.015-.171-.016-.17-.017-.169-.018-.167-.019-.166-.02-.165-.021-.163-.023-.162-.023-.161-.024-.159-.024-.157-.026-.156-.027-.155-.028-.153-.028-.151-.03-.15-.03-.148-.032-.146-.032-.145-.033-.143-.034-.141-.034-.14-.036-.137-.036-.136-.037-.134-.038-.132-.039-.13-.039-.128-.041-.126-.041-.124-.041-.122-.043-.12-.043-.117-.044-.116-.044-.113-.046-.112-.046-.109-.046-.106-.048-.105-.048-.102-.048-.1-.05-.097-.049-.095-.051-.093-.051-.09-.052-.087-.052-.085-.053-.083-.053-.08-.054-.077-.054v4.153zm8.74-8.179l-.257.004-.254.005-.25.008-.247.011-.244.012-.241.014-.237.016-.233.018-.231.021-.226.022-.224.023-.22.026-.216.027-.212.028-.21.031-.205.032-.202.033-.198.034-.194.036-.191.038-.187.038-.183.04-.179.041-.175.042-.172.043-.168.043-.163.045-.16.046-.155.046-.152.048-.148.048-.143.048-.139.049-.136.05-.131.05-.126.051-.123.051-.118.051-.114.052-.11.052-.106.052-.101.052-.096.052-.092.052-.088.052-.083.052-.079.052-.074.051-.07.052-.065.051-.06.05-.056.05-.051.05-.023.025-.023.024-.021.024-.02.025-.019.024-.018.024-.017.023-.015.024-.014.023-.013.023-.012.023-.01.023-.01.022-.008.022-.006.023-.006.021-.004.022-.004.021-.001.021-.001.021.001.021.001.021.004.021.004.022.006.021.006.023.008.022.01.022.01.023.012.023.013.023.014.023.015.024.017.023.018.024.019.024.02.025.021.024.023.024.023.025.051.05.056.05.06.05.065.051.07.052.074.051.079.052.083.052.088.052.092.052.096.052.101.052.106.052.11.052.114.052.118.051.123.051.126.051.131.05.136.05.139.049.143.048.148.048.152.048.155.046.16.046.163.045.168.043.172.043.175.042.179.041.183.04.187.038.191.038.194.036.198.034.202.033.205.032.21.031.212.028.216.027.22.026.224.023.226.022.231.021.233.018.237.016.241.014.244.012.247.011.25.008.254.005.257.004.26.001.26-.001.257-.004.254-.005.25-.008.247-.011.244-.012.241-.014.237-.016.233-.018.231-.021.226-.022.224-.023.22-.026.216-.027.212-.028.21-.031.205-.032.202-.033.198-.034.194-.036.191-.038.187-.038.183-.04.179-.041.175-.042.172-.043.168-.043.163-.045.16-.046.155-.046.152-.048.148-.048.143-.048.139-.049.136-.05.131-.05.126-.051.123-.051.118-.051.114-.052.11-.052.106-.052.101-.052.096-.052.092-.052.088-.052.083-.052.079-.052.074-.051.07-.052.065-.051.06-.05.056-.05.051-.05.023-.025.023-.024.021-.024.02-.025.019-.024.018-.024.017-.023.015-.024.014-.023.013-.023.012-.023.01-.023.01-.022.008-.022.006-.023.006-.021.004-.022.004-.021.001-.021.001-.021-.001-.021-.001-.021-.004-.021-.004-.022-.006-.021-.006-.023-.008-.022-.01-.022-.01-.023-.012-.023-.013-.023-.014-.023-.015-.024-.017-.023-.018-.024-.019-.024-.02-.025-.021-.024-.023-.024-.023-.025-.051-.05-.056-.05-.06-.05-.065-.051-.07-.052-.074-.051-.079-.052-.083-.052-.088-.052-.092-.052-.096-.052-.101-.052-.106-.052-.11-.052-.114-.052-.118-.051-.123-.051-.126-.051-.131-.05-.136-.05-.139-.049-.143-.048-.148-.048-.152-.048-.155-.046-.16-.046-.163-.045-.168-.043-.172-.043-.175-.042-.179-.041-.183-.04-.187-.038-.191-.038-.194-.036-.198-.034-.202-.033-.205-.032-.21-.031-.212-.028-.216-.027-.22-.026-.224-.023-.226-.022-.231-.021-.233-.018-.237-.016-.241-.014-.244-.012-.247-.011-.25-.008-.254-.005-.257-.004-.26-.001-.26.001z"></path></symbol></defs><defs><symbol id="clock" width="24" height="24"><path transform="scale(.5)" d="M12 2c5.514 0 10 4.486 10 10s-4.486 10-10 10-10-4.486-10-10 4.486-10 10-10zm0-2c-6.627 0-12 5.373-12 12s5.373 12 12 12 12-5.373 12-12-5.373-12-12-12zm5.848 12.459c.202.038.202.333.001.372-1.907.361-6.045 1.111-6.547 1.111-.719 0-1.301-.582-1.301-1.301 0-.512.77-5.447 1.125-7.445.034-.192.312-.181.343.014l.985 6.238 5.394 1.011z"></path></symbol></defs><defs><marker id="arrowhead" refX="7.9" refY="5" markerUnits="userSpaceOnUse" markerWidth="12" markerHeight="12" orient="auto-start-reverse"><path d="M -1 0 L 10 5 L 0 10 z"></path></marker></defs><defs><marker id="crosshead" markerWidth="15" markerHeight="8" orient="auto" refX="4" refY="4.5"><path fill="none" stroke="#000000" style="stroke-dasharray: 0px, 0px;" stroke-width="1pt" d="M 1,2 L 6,7 M 6,2 L 1,7"></path></marker></defs><defs><marker id="filled-head" refX="15.5" refY="7" markerWidth="20" markerHeight="28" orient="auto"><path d="M 18,7 L9,13 L14,7 L9,1 Z"></path></marker></defs><defs><marker id="sequencenumber" refX="15" refY="15" markerWidth="60" markerHeight="40" orient="auto"><circle cx="15" cy="15" r="6"></circle></marker></defs><g><rect x="50" y="783" fill="#EDF2AE" stroke="#666" width="584" height="39" class="note"></rect><text x="342" y="788" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" style="font-size: 16px; font-weight: 400;" class="noteText" dy="1em"><tspan x="342">The above block repeats until the stream is disconnected</tspan></text></g><text x="341" y="100" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" style="font-size: 16px; font-weight: 400;" class="messageText" dy="1em">66 3a (UDP port 58090)</text><line x1="76" y1="139" x2="605" y2="139" class="messageLine0" stroke-width="2" stroke="none" style="fill: none;" marker-end="url(#arrowhead)"></line><text x="344" y="154" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" style="font-size: 16px; font-weight: 400;" class="messageText" dy="1em">00 02 00 64</text><line x1="608" y1="193" x2="79" y2="193" class="messageLine0" stroke-width="2" stroke="none" style="fill: none;" marker-end="url(#arrowhead)"></line><text x="341" y="208" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" style="font-size: 16px; font-weight: 400;" class="messageText" dy="1em">20 36 (UDP port 58080)</text><line x1="76" y1="247" x2="605" y2="247" class="messageLine0" stroke-width="2" stroke="none" style="fill: none;" marker-end="url(#arrowhead)"></line><text x="344" y="292" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" style="font-size: 16px; font-weight: 400;" class="messageText" dy="1em">00 00 01 08 ff d8 ff e0 00 10 4a 46 49 46 00 01... (1468 bytes)</text><line x1="608" y1="331" x2="79" y2="331" class="messageLine0" stroke-width="2" stroke="none" style="fill: none;" marker-end="url(#arrowhead)"></line><text x="344" y="346" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" style="font-size: 16px; font-weight: 400;" class="messageText" dy="1em">00 00 02 08 a3 14 00 b8 a3 14 84 26 29 d8 a0 03... (1468 bytes)</text><line x1="608" y1="385" x2="79" y2="385" class="messageLine0" stroke-width="2" stroke="none" style="fill: none;" marker-end="url(#arrowhead)"></line><text x="344" y="400" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" style="font-size: 16px; font-weight: 400;" class="messageText" dy="1em">00 00 03 08 00 51 40 05 14 80 28 a6 21 40 a5 a4... (1468 bytes)</text><line x1="608" y1="439" x2="79" y2="439" class="messageLine0" stroke-width="2" stroke="none" style="fill: none;" marker-end="url(#arrowhead)"></line><text x="344" y="454" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" style="font-size: 16px; font-weight: 400;" class="messageText" dy="1em">00 00 04 08 98 0a 6a 16 34 00 94 53 10 a3 93 4f... (1468 bytes)</text><line x1="608" y1="493" x2="79" y2="493" class="messageLine0" stroke-width="2" stroke="none" style="fill: none;" marker-end="url(#arrowhead)"></line><text x="344" y="508" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" style="font-size: 16px; font-weight: 400;" class="messageText" dy="1em">00 00 05 08 f2 a0 63 0d a4 27 a2 91 f4 26 9a d6... (1468 bytes)</text><line x1="608" y1="547" x2="79" y2="547" class="messageLine0" stroke-width="2" stroke="none" style="fill: none;" marker-end="url(#arrowhead)"></line><text x="344" y="562" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" style="font-size: 16px; font-weight: 400;" class="messageText" dy="1em">00 00 06 08 26 59 b4 19 95 9b b0 5f e7 57 2a 84... (1468 bytes)</text><line x1="608" y1="601" x2="79" y2="601" class="messageLine0" stroke-width="2" stroke="none" style="fill: none;" marker-end="url(#arrowhead)"></line><text x="344" y="616" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" style="font-size: 16px; font-weight: 400;" class="messageText" dy="1em">00 00 07 08 00 14 50 06 6f 51 8f 4a 63 1c 1c 0f... (1468 bytes)</text><line x1="608" y1="655" x2="79" y2="655" class="messageLine0" stroke-width="2" stroke="none" style="fill: none;" marker-end="url(#arrowhead)"></line><text x="344" y="670" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" style="font-size: 16px; font-weight: 400;" class="messageText" dy="1em">00 02 08 02 83 4c 44 aa 2a 40 28 01 71 52 44 bb... (288 bytes)</text><line x1="608" y1="709" x2="79" y2="709" class="messageLine0" stroke-width="2" stroke="none" style="fill: none;" marker-end="url(#arrowhead)"></line><text x="341" y="724" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" style="font-size: 16px; font-weight: 400;" class="messageText" dy="1em">99 99 17 10 74 07 00 00 00 00 00 00 00 00 00 00... (24 bytes)</text><line x1="76" y1="763" x2="605" y2="763" class="messageLine0" stroke-width="2" stroke="none" style="fill: none;" marker-end="url(#arrowhead)"></line><text x="341" y="857" text-anchor="middle" dominant-baseline="middle" alignment-baseline="middle" style="font-size: 16px; font-weight: 400;" class="messageText" dy="1em">86 06 00 (UDP port 58098)</text><line x1="76" y1="896" x2="605" y2="896" class="messageLine0" stroke-width="2" stroke="none" style="fill: none;" marker-end="url(#arrowhead)"></line></svg>  The first block of messages seems to be some control data. I believe the first pair of messages is the app asking the camera its status (name, battery charge): the app shows "Bebird R1" as well as the battery charge on the first screen. Then, the third message might be asking the camera to start the video stream. The second block of message is a single video frame. Due to UDP maximum packet length of 1500 bytes it needs to be split into several packets, but when recollecting them we obtain a single JPG image of size 11kB and 480x480 pixels. <img src="https://pierrelouis.pakupaku.me/blog/bebird-camera/packet.jpg" alt="Single frame" /> How to know it is JPG? The first packet contains <code>ff d8 ff</code>, which signifies the start of a JPG image, and then <code>4a 46 49 46</code>, which reads as <code>JFIF</code>, stands for JPEG File Interchange Format. In the second block, the last message sent by the app is probably an acknowledgement. In my tests I did not need to send it. Finally, once the application disconnects, it sends <code>86 06 00</code> to the camera. <h3 id="simulating-the-application">Simulating the application</h3> Now that we understand a bit more the communication protocol between the application and the camera we can try to re-create it and see if we can unlock an HD stream. Here is the Python script I used: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="python">import io import socket import sys import threading import time from PIL import Image # Configuration CAMERA_IP = &quot;192.168.5.1&quot; LOCAL_IP = &quot;192.168.5.100&quot; PACKET_1_LOCAL_PORT = 38516 PACKET_1_REMOTE_PORT = 58090 PACKET_2_LOCAL_PORT = 54717 PACKET_2_REMOTE_PORT = 58080 def get_video_feed(): &quot;&quot;&quot;Sends the &#39;66 3a&#39; command&quot;&quot;&quot; sock1 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock1.bind((LOCAL_IP, PACKET_1_LOCAL_PORT)) cmd = bytes.fromhex(&quot;66 36&quot;) print(f&quot;Sending 1st command to {CAMERA_IP}:{PACKET_1_REMOTE_PORT}...&quot;) sock1.sendto(cmd, (CAMERA_IP, PACKET_1_REMOTE_PORT)) &quot;&quot;&quot;Sends the &#39;20 36&#39; command&quot;&quot;&quot; sock2 = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) sock2.bind((LOCAL_IP, PACKET_2_LOCAL_PORT)) sock2.settimeout(1.0) cmd = bytes.fromhex(&quot;20 36&quot;) print(f&quot;Sending 2nd command to {CAMERA_IP}:{PACKET_2_REMOTE_PORT}...&quot;) sock2.sendto(cmd, (CAMERA_IP, PACKET_2_REMOTE_PORT)) &quot;&quot;&quot;Listens for UDP packets and extract JPEG frames&quot;&quot;&quot; print( f&quot;Listens for UDP packets from {CAMERA_IP}:{PACKET_2_REMOTE_PORT} to {LOCAL_IP}:{PACKET_2_LOCAL_PORT}...&quot; ) # Buffer to store incoming UDP data udp_buffer = bytearray() while True: try: data, _addr = sock2.recvfrom(65536) except socket.timeout: break udp_buffer.extend(data) # print(&quot;Received packet of length {}&quot;, len(data)) # Look for Start of Image (FFD8) and End of Image (FFD9) start_index = udp_buffer.find(b&quot;\xff\xd8&quot;) end_index = udp_buffer.find(b&quot;\xff\xd9&quot;, start_index) if start_index != -1 and end_index != -1 and end_index &gt; start_index: # Extract the complete JPEG frame # We slice from the start of the FOUND frame to the end frame_data = bytes(udp_buffer[start_index : end_index + 2]) # Clear buffer up to this point to prevent memory growth # But keep any partial data after the end just in case udp_buffer = bytearray(udp_buffer[end_index + 2 :]) try: img = Image.open(io.BytesIO(frame_data)) print( f&quot;Received Image: {img.width}x{img.height} (Size: {len(frame_data)} bytes)&quot; ) except Exception as e: print(f&quot;Corrupt frame data: {e}&quot;) if __name__ == &quot;__main__&quot;: get_video_feed()</code></pre> With this script I could confirm the received image size and change the control bytes sent at the beginning to see if there is a way to get an HD stream. Unfortunately, it didn't work. <h2 id="taking-screenshots">Taking Screenshots</h2> The app and webpage provide a button to take a screenshot. The webpage contains the following Javascript function, which simply takes a screenshot of the displayed canvas, so 480x480 pixels. <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="javascript">function Ee() { var z; // 1. Get the hidden &lt;a&gt; tag with id=&quot;save&quot; const N = document.getElementById(&quot;save&quot;), E = document.createElement(&quot;canvas&quot;), S = document.querySelector(&quot;.ears-view&quot;); // Selects the &lt;img&gt; tag showing the stream // 2. Match canvas size to the video stream size E.width = S == null ? void 0 : S.width, E.height = S == null ? void 0 : S.height, document.body.appendChild(E); // 3. Draw the current frame from the &lt;img&gt; onto the canvas const j = E.getContext(&quot;2d&quot;); j == null || j.drawImage(S, 0, 0, S == null ? void 0 : S.naturalWidth, S == null ? void 0 : S.naturalHeight, 0, 0, E.width, E.height); try { // 4. Convert canvas to a Data URL (Base64 JPEG) const $ = E.toDataURL(); N.href = $; // 5. Generate a timestamped filename and trigger download const re = new Date; N.download = re.getFullYear() + (&quot;0&quot; + (re.getMonth() + 1)).slice(-2) + (&quot;0&quot; + re.getDate()).slice(-2) + (&quot;0&quot; + re.getHours()).slice(-2) + (&quot;0&quot; + re.getMinutes()).slice(-2) + (&quot;0&quot; + re.getSeconds()).slice(-2) + &quot;.png&quot; } catch ($) { console.error($) } // 6. Cleanup: Remove the temporary canvas (z = E == null ? void 0 : E.parentNode) == null || z.removeChild(E) }</code></pre> When taking a screenshot from the app, it sends a special command to the camera which then returns a JPG file. What happens is probably that the camera stops the stream, takes a full-resolution image from its sensor, and then sends it back to the app. But then something weird happens: the image saved by the app is 1.36MB, with a resolution of 2828x3258 pixels (8.9 megapixels). It looks like the app is doing interpolation, upscaling the image (because why not I guess). <h2 id="findings-summary">Findings Summary</h2> This fun adventure hacking the Bebird camera is at least half a success: from now on I can use it without the proprietary smartphone/tablet application. However, there is no such thing as a HD stream. I could fake an HD stream by repeatedly taking screenshots in my python script, but the result would be a very laggy video stream. In retrospect, the <a rel="external" href="https://bebird.com/products/earsight-r1-earwax-removal-tool">official product description</a> feels more like marketing information than real technical details that make sense: <ul> <li>1080P HD Vision with 6 LED Lights</li> <li>3-megapixel high-precision lens</li> <li>Maximum framerate of 30fps</li> <li>Image transmission of 20fps</li> </ul> 20 or 30fps? 1080P is around 2MP, not 3. The reviews are also all great, but with definitely not HD images. One final thing I checked is information about the network device (xiamenshi c-chip technology) found in the <code>nmap</code> output. According to <a rel="external" href="https://manuals.plus/m/fd734e69f3e7d9af4d5d65780279fcbe15b052acba33338328a2e9ce700c4826_optim">the manual</a>, it supports Wifi 802.11 b/g/n with a maximum transmission rate of 72.2 Mbps, so should be enough for full HD which requires less than 10Mbps. What I think happens is that while the Wifi chip and camera sensors might be able to do full HD, the embedded CPU in the camera is probably not powerful enough. So, to ensure a smooth and stable stream and avoid overheating (the device already gets warm when being used), the software does not allow more than 480p streaming. Further investigating this claim would necessitate opening the device, which I do not really want to do as I am using it. <h2 id="acknowledgements">Acknowledgements</h2> I have used the <a rel="external" href="https://euria.infomaniak.com/">Euria</a> LLM to guide me through the hack. Euria is provided by <a rel="external" href="https://www.infomaniak.com/en">Infomaniak</a>, a Swiss-based company that focuses on privacy, security, and sustainable solutions. Nonetheless this article has been written by myself without LLM assistance. Software Setup — 2026 Edition 2026-03-04T00:00:00+0000 https://pierrelouis.pakupaku.me/blog/software-setup/ Stopping a Mouse Infestation: A Keyboard-Only Haven <h1 id="introduction">Introduction</h1> For some years I have been trying to reduce my usage of the mouse. My precision is not very good and using it for extended periods leads to discomfort (moving the hand off the keyboard, clicking, moving the cursor across the screen). Last year I have also done some research and experiments with custom (mechanical, split, ortholinear) keyboards and layouts. Many designs consider the mouse as a second-class citizen, minimizing the need to divert attention from typing. As a side note, <a rel="external" href="https://www.justinmklam.com/posts/2026/02/beginners-guide-split-keyboards/">this article</a> about split keyboards is a good read. I have made some small experiments in the past (e.g., with <code>vimperator</code>, or using a tiling window manager), yet never really dedicated time to get rid of the mouse. Nevertheless, one thing that has been true forever is I largely prefer a command-line application over a GUI. This post is a response to the problem. Besides listing softwares that can be controlled mostly with the keyboard, it also aims at being a tutorial/basic reference for a daily use. It is broken down into multiple parts: <ul> <li><a href="https://pierrelouis.pakupaku.me/blog/software-setup/#part-0-the-foundation">Part 0: The Foundation</a></li> </ul> <h1 id="a-small-note-on-hardware">A Small Note on Hardware</h1> Summarizing which hardware I use can help to understand some choices. I use laptops, mainly (old) Thinkpads from 2015 to 2021, ranging from 12" to 14", with at least 8GB of RAM and 2-cores (4 threads). They all run GNU/Linux (Arch, Debian, Fedora) or FreeBSD. They work very well for my usages despite their age, and given the current state-of-the-world (price hikes, climate change), I believe it is better to <a rel="external" href="https://xn--gckvb8fzb.com/hold-on-to-your-hardware/">hold on them as long as possible</a>. When using an external screen, it is either a 16:9 1440p or an ultra-wide 3440x1440. I also have a bunch of custom keyboards, 34-keys split Chocofi, 58-keys split Lily58, 48-keys ortholinear Planck, and a Keychron K3 Pro. This has several implications for the software side: <ul> <li>need to unify the configuration;</li> <li>need to minimize memory usage;</li> <li>need to minimize mouse movements on the ultra-wide screen.</li> </ul> <h1 id="part-0-the-foundation">Part 0: The Foundation</h1> <h2 id="window-manager-i3-sway">Window Manager: i3/Sway</h2> My window manager of choice is <a rel="external" href="https://i3wm.org/">i3</a> (on X) or <a rel="external" href="https://swaywm.org/">Sway</a> (on Wayland). Sway is designed to be compatible with i3, meaning I can switch from one to the other with minimal configuration changes. I tend to have one or two applications at most per workspace, having windows side-by-side, and dedicating a workspace to a particular task. <h2 id="terminal-emulator-ghostty">Terminal Emulator: Ghostty</h2> I recently moved from <a rel="external" href="https://alacritty.org/">Alacritty</a> to <a rel="external" href="https://ghostty.org/">Ghostty</a>, mainly for the possibility to split the window (useful when starting a new terminal would mess up with my current window layout) and for being able to display images in the terminal. <a rel="external" href="https://ricoberger.de/cheat-sheets/ghostty/">Cheat sheets</a> are a precious tool to learn how to use it. <a href="https://pierrelouis.pakupaku.me/blog/software-setup/ghostty-cheat-sheet.png"><img src="https://pierrelouis.pakupaku.me/blog/software-setup/ghostty-cheat-sheet.png" alt="Ghostty cheat sheet" /></a> I've added the following to the configuration (<code>~/.config/ghostty/config</code>) so that new windows open in the home directory instead of the directory of the previously opened window. <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">gtk-single-instance = false working-directory = home window-inherit-working-directory = true</code></pre> One important feature for a mouse-less environment is to be able to select text in the terminal window via the keyboard only. There is no easy way to do this in Ghostty. The simplest solution I've found is to follow this procedure: <ol> <li>Type the name of your text editor of choice (nvim, vi, vim...)</li> <li>Press <code>super+ctrl+shift+j</code> to save the screen content to a file and copy the file path to the clipboard</li> <li>Press <code>ctrl+shift+v</code> to paste the screen file path to the terminal</li> <li>Type <code>enter</code>. You are now in your editor, where you can do whatever you want, e.g., copy text</li> <li>Exit your editor and paste the text into the command line</li> </ol> This makes a great transition to discuss about my text editor. <h2 id="text-editor-neovim">Text editor: Neovim</h2> I install <a rel="external" href="https://neovim.io/">neovim</a> everywhere I need a text editor, and I use it for every kind of text, be it a todo list, code, etc. The rationale includes: similarities with vi (installed almost anywhere), does not need a GUI, no superfluous functionalities, no crazy shortcuts to run some commands (thinking of Emacs here). In short, it does the job. The main plugins I have installed are: <ul> <li><a rel="external" href="https://github.com/nvim-telescope/telescope.nvim">telescope</a>, used to search for a string in many files; useful for browsing through code. The main shortcuts are (I should look at the documentation and add useful ones): <ul> <li><code>&lt;leader&gt;ff</code>: find files</li> <li><code>&lt;leader&gt;fg</code>: search for a string across the current working directory</li> <li><code>&lt;leader&gt;fb</code>: list opened buffers</li> </ul> </li> <li><a rel="external" href="https://github.com/jannis-baum/vivify">vivify</a> to preview markdown files while editing</li> <li>LSP for Rust, C, markdown, LaTeX, Python</li> </ul> And my <code>&lt;leader&gt;</code> key is <code>space</code>, because why not, it's easily accessible. <h2 id="file-explorer-yazi">File Explorer: Yazi</h2> While I mostly use the standard UNIX tools to manage files (<code>mv</code>, <code>cp</code>, <code>cd</code>, and so on), if I need a file-explorer then it is the TUI-based <a rel="external" href="https://yazi-rs.github.io/">Yazi</a>. One use-case for Yazi over the terminal is when searching for some image or document: the built-in preview makes it simpler than opening files until I find the right one. Yazi supports plugins. An interesting one is <a rel="external" href="https://github.com/yazi-rs/plugins/tree/main/mount.yazi">a mount manager</a> (does not seem to support *BSD at the time of writing). <a rel="external" href="https://ricoberger.de/cheat-sheets/yazi/">Here</a> is Yazi cheat sheet: <a href="https://pierrelouis.pakupaku.me/blog/software-setup/yazi-cheat-sheet.png"><img src="https://pierrelouis.pakupaku.me/blog/software-setup/yazi-cheat-sheet.png" alt="Yazi cheat sheet" /></a> <h2 id="wifi-and-bluetooth-managers">Wifi and Bluetooth Managers</h2> <a rel="external" href="https://github.com/pythops/bluetui">bluetui</a> and <a rel="external" href="https://github.com/pythops/impala">impala</a> are both TUI manager for respectively Bluetooth and Wifi. Unfortunately they do not run on FreeBSD, where I need to do everything by hand. Unlock Debian encrypted root partition with a keyfile 2025-09-05T00:00:00+0000 https://pierrelouis.pakupaku.me/blog/debian-root-cryptsetup-keyfile/ <h2 id="introduction">Introduction</h2> A common method for securing the root partition of a system is through encryption using a passphrase. While effective, this approach requires manual input every time the machine starts, which poses a challenge for headless machines that lack a keyboard or screen. To address this, we can store the keyfile on a USB key, allowing the system to automatically access the encryption key during boot. Alternatively, the keyfile can be stored on the network, providing a convenient solution for multiple machines, but we will see that one day, maybe. (Edit 2026-01-26: <a rel="external" href="https://jyn.dev/remotely-unlocking-an-encrypted-hard-disk/">Modifying the <code>initramfs</code></a> seems to be a good starting point.) In this blog post we will install Debian 13 using debootstrap without setting up a passphrase. Although we could run the installer, which supports LUKS encryption with a passphrase, and add the keyfile later, where would be the fun? <h2 id="debian-installation">Debian Installation</h2> First, grab (a tea and) a live version of Debian, install it on a usb key (it's 2025, who still burns Linux distributions to CDs?), boot on it, and open a terminal. We need to install a few packages: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">sudo apt update sudo apt install debootstrap arch-install-scripts</code></pre> Let's assume you have the following setup: <ul> <li><code>sda</code> is the disk where we are going to install the system (with its partitions being efi, boot and root, in that order);</li> <li><code>sdb</code> is the live usb key;</li> <li><code>sdc</code> is the usb key where we will install the keyfile.</li> </ul> <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">NAME SIZE RO TYPE UUID sda 1T 0 disk ├─sda1 1G 0 part 00a1 ├─sda2 1G 0 part 00a2 └─sda3 958G 0 part 00a3 sdb 7.6G 0 disk ├─sdb1 3.5G 0 part └─sdb2 3.2M 0 part sdc 8G 0 disk ├─sdc1 8G 0 part 00c1</code></pre> We will start with creating a 64B keyfile. You can adjust the command to your liking, e.g., if you want a larger key, or if you want it to contain text, an image, etc.: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">mkdir /tmp/usbkey sudo mount /dev/sdc1 /tmp/usbkey dd if=/dev/urandom of=/tmp/usbkey/luks-keyfile bs=1 count=64</code></pre> We can now create our new filesystem: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">sudo mkfs.vfat -F32 /dev/sda1 sudo mkfs.ext4 /dev/sda2 sudo cryptsetup luksFormat /dev/sda3 --key-file /tmp/usbkey/luks-keyfile sudo cryptsetup open /dev/sda3 cryptroot --key-file /tmp/usbkey/luks-keyfile sudo mkfs.ext4 /dev/mapper/cryptroot sudo umount /tmp/usbkey</code></pre> And mount it: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">sudo mount /dev/mapper/cryptroot /mnt sudo mkdir /mnt/boot sudo mount /dev/sda2 /mnt/boot sudo mkdir /mnt/boot/efi sudo mount /dev/sda1 /mnt/boot/efi</code></pre> And install a basic Debian system: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">sudo debootstrap stable /mnt http://deb.debian.org/debian</code></pre> Let's also generate a few files (if the usb key with the keyfile is still plugged in, you might want to remove it from <code>/mnt/etc/fstab</code>): <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">sudo bash -c &#39;genfstab -U /mnt &gt; /mnt/etc/fstab&#39;</code></pre><h2 id="chroot-to-the-new-system"><code>chroot</code> to the new system</h2> To enter our new system: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">sudo arch-chroot /mnt</code></pre> <code>arch-chroot</code> is provided by the <code>arch-install-scripts</code> package installed earlier. It is a quicker and more convenient way to mount the required file systems needed in the chroot and then chroot. <h3 id="new-installation-setup">New installation setup</h3> Install a few necessary tools: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">apt update apt install neovim grub-efi openssh-server cryptsetup-initramfs \ linux-image-amd64 linux-headers-amd64 initramfs-tools efibootmgr locales</code></pre> Configure a few necessary things: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript"># root password passwd # hostname echo my-encrypted-host &gt; /etc/hostname sed -i &#39;s/debian/my-encrypted-host/&#39; /etc/hosts # setting the time &amp; locales dpkg-reconfigure tzdata dpkg-reconfigure locales # setting up the network cat &lt;&lt; EOF &gt; /etc/systemd/network/&lt;interface-name&gt;.network [Match] Name=&lt;interface-name&gt; [Network] DHCP=yes EOF</code></pre> You might also want to allow password authentication for root via ssh, just at the beginning for debug purposes: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">nvim /etc/ssh/sshd_config ... PermitRootLogin yes ...</code></pre> We can now enable the services: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">systemctl enable sshd systemctl enable systemd-networkd</code></pre><h3 id="encrypted-root-configuration">Encrypted root configuration</h3> Add a new entry in <code>/etc/crypttab</code>: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">cryptroot /dev/sda3 /dev/disk/by-uuid/00c1:/luks-keyfile luks,discard,keyscript=/lib/cryptsetup/scripts/passdev</code></pre> Also add a few modules in <code>/etc/initramfs-tools/modules</code> <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">ext4 # this is because our root partition uses ext4 nls_cp437 nls_ascii</code></pre> Update Initramfs: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">update-initramfs -u -k all</code></pre> Install the bootloader: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">grub-install --target=x86_64-efi --efi-directory=/boot/efi update-grub</code></pre> Et voilà! You can now exit the chroot, unmount the different disks, and reboot. Note: please properly close the cryptroot mapping after unmounting <code>/mnt</code>: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="shellscript">sudo cryptsetup close /dev/mapper/cryptroot</code></pre><h2 id="some-references">Some references</h2> <ul> <li><a rel="external" href="https://semjonov.de/posts/2021-09/minimal-ubuntu-installation-with-debootstrap/">install ubuntu with debootstrap</a></li> <li><a rel="external" href="https://www.reddit.com/r/debian/comments/se1a3e/having_a_ton_of_trouble_setting_up_encrypted_lvm/">reddit</a></li> </ul> Fault-Tolerance for LLM Inference 2024-11-15T00:00:00+0000 https://pierrelouis.pakupaku.me/blog/llm-inference/ <h2 id="introduction">Introduction</h2> Large Language Models (LLM) are becoming increasingly popular for numerous tasks, including chatbots, content generation (text, images or videos), translation, etc. LLM users interact with such systems by sending a prompt, a text describing their request. The LLM then generates the answer by leveraging a set of GPUs in a process called inference, after which they send back the answer to the user. Compared to previous machine learning systems, state-of-the-art LLMs require hundreds of GB of GPU memory, while high-end GPUs such as the NVIDIA A100 possess only 80GB of RAM. This requires splitting the model on multiple GPUs. Unfortunately, large-scale GPU deployments are prone to failures, as demonstrated by <a rel="external" href="https://www.usenix.org/conference/nsdi22/presentation/eisenman">Eisenman et al.</a> and <a rel="external" href="https://semianalysis.com/2024/09/04/multi-datacenter-training-openais/?utm_source=post-email-title&amp;publication_id=329241&amp;post_id=148471080&amp;utm_campaign=email-post-title&amp;isFreemail=true&amp;r=3ks5kd&amp;triedRedirect=true&amp;utm_medium=email">Patel et al.</a>. When a failure occurs during inference, the user request needs to be recomputed from the beginning, which incurs additional latency and computation. Some researchers are thus making LLM inference fault-tolerant. In this post we will detail the LLM inference mechanism, present some experiments done on A100 GPUs, and finally describe the DéjàVu system for fault-tolerant LLM inference. <h2 id="llm-inference-in-a-nutshell">LLM inference in a nutshell</h2> LLM inference is a multi-phases process, as shown in the below figure with a user sending the prompt "Tokyo is". <img src="https://pierrelouis.pakupaku.me/blog/llm-inference/llm_inference.png" alt="LLM Inference process" /> The model first tokenizes it and outputs a set of numerical values, called tokens, understandable only by the model. The tokens are then processed by the LLM for one iteration. These two computations define the prompt processing phase. This phase outputs both a context, saved in a Key-Value cache (KV cache), and a new token. The second phase of inference is the token generation phase, where all the remaining tokens of the answer are computed. A single LLM iteration computes one new token, with the previous context (stored in the KV cache) and token as inputs. It outputs the new context that will be saved in the KV cache and a new token. Finally, the LLM translates the tokens to human readable output in a process similar to accessing a lookup table. This output ("Tokyo is the capital of Japan" in the above figure) is sent back to the client. To tolerate faults, one idea is to persist the KV cache so that the request can be recomputed from its latest state before the failure rather than from the beginning. <h2 id="our-experiments">Our experiments</h2> We run several experiments on two A100 GPUs (each having 80GB of RAM) with the <a rel="external" href="https://huggingface.co/facebook/opt-13b">OPT-13B</a> model. Loading the model allocates 40GB of memory per GPU. Batch size is set to 8. The goal is to evaluate the potential latency gain by implementing a persistent KV cache. In a first experiment we measure the average processing time of each inference stages average processing time. The experiment stops after having generated a total of 2000 tokens (including the 40 tokens of the prompt). As can be observed in the figure below prompt processing takes 1.7s while a single token generation takes 2.4s. A single failure during inference thus leads to several seconds of delay. <img src="https://pierrelouis.pakupaku.me/blog/llm-inference/processing_time.png" alt="Inference processing time" /> In a second experiment we replay the <a rel="external" href="https://github.com/Azure/AzurePublicDataset/blob/master/AzureLLMInferenceDataset2023.md">Microsoft Azure code trace</a> while introducing failures. A given percentage of requests fails, that is to say the GPU has to recompute it from the start. Results are reported in the figure below. Without failures, the entire trace is replayed in 253 minutes (a bit over 4 hours). When introducing failures, this execution time increases: 277 minutes with 10% of failed requests, 303 minutes with 20%, and so on, up to 507 minutes with 100% of failed requests (i.e., all requests need to be executed twice). This represents an increase from 9% (10% failures) to 100% (100% failures). <img src="https://pierrelouis.pakupaku.me/blog/llm-inference/faults.png" alt="Inference under failures" /> <h2 id="dejavu">DéjàVu</h2> <a rel="external" href="https://proceedings.mlr.press/v235/strati24a.html">DéjàVu</a> is a fault-tolerant system for LLM inference system is a system presented by Strati et al. at the 41st International Conference on Machine Learning (2024). The figure below, taken from the research paper, describes its architecture. <img src="https://pierrelouis.pakupaku.me/blog/llm-inference/dejavu_arch.png" alt="DéjàVu architecture" /> DéjàVu replicates the KV cache in persistent storage or main memory. In case of failures, the KV cache can be restored from the latest available backup instead of having to redo the inference from zero. To be able to detect a failure, GPUs periodically send heartbeat messages to a central controller component. If he does not receive a heartbeat from a particular GPU after a given period of time, then it assumes the GPU to be faulty. To efficiently stream (i.e., send) the KV cache to the host CPU, DéjàVu aggregates KV cache updates in a single continuous area of the GPU memory. This makes GPU transfers more efficient, as they can use the full GPU bandwidth, compared to transferring small and non-contiguous GPU memory areas one at a time. DéjàVu proposes other optimisations, such as executing prompt processing and token generation on different sets of GPUs to avoid conflicts between these two tasks. DéjàVu has been evaluated on real hardware, with A100 GPUs. The authors show that, in the fault-free case, it outperforms FasterTransformer (the baseline) by 2x while providing low latency (see below). <img src="https://pierrelouis.pakupaku.me/blog/llm-inference/dejavu_faultfree.png" alt="DéjàVu performance in the fault-free case" /> In the faulty case, DéjàVu is able to finish execution 16% faster than the baseline thanks to its fault-tolerant replicated KV cache (see figure below). <img src="https://pierrelouis.pakupaku.me/blog/llm-inference/dejavu_faulty.png" alt="DéjàVu performance under failures" /> <h2 id="conclusion">Conclusion</h2> In this post we have argued that failures during the LLM inference process is a problem, as requests need to be re-executed from zero, which increases the latency perceived by the client. We ran several experiments on two A100 GPUs, increasing the percentage of faulty requests (i.e., requests that need to be re-executed). A low percentage of failures such as 10% already means that executing the entire set of requests will take 10% more time. Finally, we presented DéjàVu, a system that brings fault-tolerance to LLM inference by smartly replicating the KV cache, storing the intermediate state of the LLM inference process. As a result, requests can be restarted from a point close to the GPU failure instead of from zero. <h2 id="acknowledgements">Acknowledgements</h2> We are grateful to IIJ Cloud Division for giving us access to their GPUs. Toward Trusted Pictures to Combat Fake News 2024-07-05T00:00:00+0000 https://pierrelouis.pakupaku.me/blog/trusted-pictures/ <h2 id="introduction">Introduction</h2> Fake news, i.e. the forgery of news information, can have dramatic consequences, from personal harm and legal issues to societal unrest, health risks, financial losses, and threats to democratic processes, to the extent that governments are considering new legislation to combat this threat, e.g., <a rel="external" href="https://www.msn.com/en-us/news/technology/over-300-global-experts-urge-governments-to-tackle-deepfake-threats/ar-BB1iFZPY">here</a> or <a rel="external" href="https://www.weforum.org/agenda/2024/02/ai-deepfakes-legislation-trust/">there</a>. Manipulated images are a particular potent medium, where an image is taken out-of-context, with its original message altered to suit one agenda. Current state-of-the-art methods rely on image processing techniques, which, as we will show in this article, are unfortunately not sufficient to detect manipulations. Fortunately, several actors are working on this problem. We will present two such solutions: <a rel="external" href="https://contentauthenticity.org/">CAI</a> and <a rel="external" href="https://www.serelay.com/">Serelay</a> Before diving into the details, one might ask why an ISP such as IIJ should care about these fake news. Internet actors are already filtering attacks over the network such as spam, viruses, or Denial-of-Service. We believe they also have some responsibility to stop the dissemination of fake news. <h2 id="the-problem-of-detecting-manipulated-images">The problem of detecting manipulated images</h2> There exists a lot of tools to detect fake images: <a rel="external" href="https://fake-inversion.github.io/">fake-inversion</a>, <a rel="external" href="https://fotoforensics.com/">fotoforensics</a>, <a rel="external" href="https://www.invid-project.eu/tools-and-services/invid-verification-plugin/">invid plugin</a>, <a rel="external" href="https://www.fakeimagedetector.com/">fakeimagedetector</a>, etc. They either rely on pixels analysis via machine learning, image processing techniques, or search for similar images over the Internet to find the origin of an image. Unfortunately, these tools are not sufficient, as we show with the following three images: <img src="https://pierrelouis.pakupaku.me/blog/trusted-pictures/wwf.jpg" alt="WWF deforestation" /> <img src="https://pierrelouis.pakupaku.me/blog/trusted-pictures/kissin.jpg" alt="Kiss-in protest" /> <img src="https://pierrelouis.pakupaku.me/blog/trusted-pictures/rheinII.jpg" alt="Rhein II" /> The first image originates from a <a rel="external" href="https://twitter.com/climateconco/status/1087550447005646849/photo/1">WWF contest in 2019</a>. It shows the extent of deforestation in the Amazon forest by comparing the same forest over a ten years period. The second image has been presented on some social medias as an <a rel="external" href="https://www.dw.com/en/fact-check-no-anti-vaxxer-kiss-in-in-germany/a-60062668">anti-vaccine protest in Germany in 2021</a>. The third image, named <a rel="external" href="https://www.theguardian.com/artanddesign/2011/nov/11/andreas-gursky-rhine-ii-photograph">"Rhein II"</a>, was taken by Andreas Gursky in 1999. The artist then edited the image to remove unnecessary details to create this simple and abstract composition. We ran these images on the <a rel="external" href="https://www.fakeimagedetector.com/">fakeimagedetector</a> tool. This tool uses <a rel="external" href="https://en.wikipedia.org/wiki/Error_level_analysis">Error Level Analysis (ELA)</a> to detect pixel manipulations. The results are quite surprising: the first image looks authentic, while the second and third ones are deemed computer generated or modified. Actually, the first image does not show the same spot over a ten years period: <a rel="external" href="https://www.huffpost.com/archive/qc/entry/10yearschallenge-defenseurs-environnement-defi_qc_5cccd7c5e4b089f526c7704c">both sides come from the same image</a>. While deforestation is a real problem, such forgeries might make more harm than good and damage the reputation of associations fighting for the climate. Regarding the second image, it is authentic, but was taken in <a rel="external" href="https://actipedia.org/project/chilean-kiss">Chile in 2011 during some students protest</a>, not in Germany in 2021. It is easy to reuse an image for one's own agenda without having access to additional metadata on the image, such as the time when this image was taken or GPS coordinates. The third image is also authentic, but was indeed slightly post-processed by its author. The point we make in this third example is that the difference between AI-generated and real images is now very thin, with <a rel="external" href="https://scitechdaily.com/unmasking-the-illusion-ai-generated-faces-challenge-perceptions/">people believing AI-generated images to be real</a>. Without any authenticity record it would be very easy to deceive someone by pretending an image is AI-generated or not. One may think the <a rel="external" href="https://archive.org/details/exif-specs-3.0-dc-008-translation-2023-e/mode/2up">Exif metadata</a> could help to detect these manipulations by showing detailed information to the viewer about the situation in which they have been taken (camera model, GPS location, time and date, etc.). Unfortunately, there are several problems. First, there are no mandatory fields. Camera manufacturers can decide what metadata will be (or not) embedded into the file, and users can modify some settings prior to taking an image. Second, this metadata can be modified or removed by any editing software. Third, image file formats are not secure: they do not embed any signature or similar mechanism to prove their authenticity, keep their integrity against unauthorized modifications, or store confidential information that could prove the image authenticity (e.g., the GPS location of an image taken during a conflict). To summarize, image processing techniques can detect if the pixels of an image have been manipulated (e.g., part of the image have been modified), but cannot detect whether an image and its associated message are misleading the viewer, for example by pretending an image has been taken at a different place or different time. Part of the problem is the lack of any secure metadata (e.g., when and where the image has been taken) in current image formats: it is relatively easy to remove or alter the Exif metadata. <h2 id="existing-solutions">Existing solutions</h2> We now present two existing solutions to build trusted images, that is to say images whose provenance and history can be certified. <h3 id="content-authenticity-initiative">Content Authenticity Initiative</h3> The <a rel="external" href="https://contentauthenticity.org/">Content Authenticity Initiative (CAI)</a> was co-founded by Adobe, The New York Times and Twitter in 2019. Its goal is to promote an industry standard for provenance metadata. Since its inception, new actors have joined this initiative, in particular the BBC, ARM, Qualcomm, or even Nikon. CAI proposes an end-to-end system that adds secure metadata to an image at different stages of its creation, when it is taken by the camera and when it is post-processed (see image below). This secure metadata contains additional information regarding the provenance of the image: when it was taken, who took it, who published it, how it was altered, etc.) This additional information is then secured with hashes and digital signatures. When a user views the image, he can then check the authenticity and provenance of the metadata, effectively increasing his trust in the image. <img src="https://pierrelouis.pakupaku.me/blog/trusted-pictures/cai.png" alt="CAI file structure" /> By embedding secure metadata into the image format instead of storing the secure metadata in another place (a server or another file), this system is transparent to users: they do not need to contact a remote server, thus not needing an Internet connection to check for an image authenticity, and they do not need to store or exchange another file alongside the image. One downside of this approach is the need for a secure camera. If the image is taken by a normal camera, its authenticity cannot be asserted. Fortunately, smartphones and camera manufacturers are working on new devices compatible with CAI, e.g., <a rel="external" href="https://leica-camera.com/en-US/photography/content-credentials#">Leica</a>, <a rel="external" href="https://contentauthenticity.org/secure-mode-enabled">Qualcomm</a>, or <a rel="external" href="https://www.nikon.com/company/news/2022/1019_exhibition_01.html">Nikon</a>. <h3 id="serelay">Serelay</h3> <a rel="external" href="https://www.serelay.com/">Serelay</a> proposes two phone applications to take secure images and an SDK to verify the authenticity of an image. When taking an image, Serelay application performs dozens of checks to make sure the photographer is not trying to spoof the device location or time, by leveraging GPS coordinates, nearby wifi networks, timezone, as well as analyzing the image to detect for example whether the user is taking an image of another (two-dimensional) image instead of a real scene. The application then extracts and sends hundreds of datapoints from the image to Serelay servers (which amount to 15kB only according to them). By leveraging their SDK, other users can then check the image authenticity. The figure below shows one such example. <img src="https://pierrelouis.pakupaku.me/blog/trusted-pictures/serelay.jpg" alt="Serelay dashboard" /> Similarly to CAI, users need to take images with a special camera (in this case, Serelay smartphones application). However, Serelay does not embed the secure metadata with the image, but instead relies on its own servers. <h2 id="summary">Summary</h2> Existing image processing techniques are not sufficient to detect images manipulated to alter their message. This is a problem in the fight against fake news. Fortunately, several solutions are being developed. These solutions aim at building trust into the image from the moment it is taken by the camera, and then associate additional, secure metadata to the image to prove its authenticity. Development on a SiFive HiFive1 RevB in 2024 2024-06-01T00:00:00+0000 https://pierrelouis.pakupaku.me/blog/hifive1b/ <h2 id="introduction">Introduction</h2> My local electronic shop was selling a bunch of SiFive HiFive1 RevB at a 85% discount, so even before asking whether I need one, I bought one. No way I'd pass the opportunity to try a RISC-V board! The board, released around March 2019, is Arduino compatible and embeds a micro-B USB connection, JTAG capabilities, a WiFi and Bluetooth module (needs an external module), I/O headers, a SiFive FE310-G0002 microcontroller, and more. The processor inside the board microcontroller is a E31 RISC-V RV32IMAC CPU. This is a 32-bit processor running at 320MHz with 16kB of SRAM, 16kB of L1 instruction cache, and 32Mb of flash memory. Many resources can be found online, including code and documentation. However, the main issue I encountered is the lack of code updates in the recent years: the Freedom Studio or Freedom E SDK (which I will use below) github repositories, necessary to develop for the board, have not been updated since 2021. I also had the problem of the documentation being for Ubuntu while I use ArchLinux. <h2 id="getting-started">Getting started</h2> The first thing to do is read the <a rel="external" href="https://www.starfivetech.com/uploads/hifive1b-getting-started-guide_v1.2.pdf">Getting Started guide</a>. Software development can be done either via <a rel="external" href="https://github.com/sifive/freedom-studio">Freedom Studio</a>, an Eclipse-based IDE plus all the tools necessary for development, or a bit more manually with the <a rel="external" href="https://github.com/sifive/freedom-e-sdk">Freedom E SDK</a>. <h2 id="update">Update</h2> My solution in the next sections was more complicated than necessary. Thanks to Python support for virtual environments, we can easily use the board on a modern system. First, let's download a few packages: <code>jlink-software-and-documentation</code> and <code>python38</code>. Two remarks: <ul> <li>with Python3.9 the compilation of one package installed by <code>pip</code> fails, so I stick to 3.8 (it's the same version I had in the Docker container);</li> <li>there seems to be something missing when using <code>riscv64-unknown-elf-gcc</code> (<code>ld</code> fails, unable to find <code>-lc</code> and <code>-lgloss</code>), so I instead use the one of FreedomStudio.</li> </ul> Then, we need the Freedom tools. <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">$ cd &lt;BASE_DIR&gt; # where you install the board tools $ mkdir FreedomStudio &amp;&amp; cd FreedomStudio $ wget &quot;https://static.dev.sifive.com/dev-tools/FreedomStudio/2019.03.4/FreedomStudio-4.7.2.2019-03-4-linux.gtk.x86_64.tar.gz&quot; $ tar -xf FreedomStudio-4.7.2.2019-03-4-linux.gtk.x86_64.tar.gz $ cd .. $ git clone --recursive https://github.com/sifive/freedom-e-sdk.git</code></pre> We'll now tell the SDK to build the virtual environment with Python 3.8 intead of the latest one in Arch repos: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">$ cd &lt;BASE_DIR&gt;/freedom-e-sdk $ sed --in-place &#39;s/python3 -m venv/python3.8 -m venv/&#39; scripts/virtualenv.mk</code></pre> It's now time to compile and run some code. <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">$ export RISCV_PATH=&lt;BASE_DIR&gt;/FreedomStudio/SiFive/toolchain/riscv64-unknown-elf-gcc-8.2.0-2019.02.0 $ cd &lt;BASE_DIR&gt;/freedom-e-sdk $ make BSP=metal PROGRAM=hello TARGET=sifive-hifive1-revb software upload</code></pre> Et voilà ! <h2 id="unefficient-solution">Unefficient Solution</h2> <h3 id="first-try-on-archlinux">First try on ArchLinux</h3> Innocently, I tried to follow the guide while running on ArchLinux, installing the two following packages for the prerequisite: <code>jlink-software-and-documentation</code> and <code>riscv64-unknown-elf-gcc</code>. Most of it went fine, until the <code>make</code> command to build one of the Freedom E SDK examples. More specifically, the Makefile runs a Python script that tries to import the <code>distutils</code> module, deprecated since Python 3.10, while I have Python 3.12 installed. Maybe there is a simple solution to this problem, but I could not find one, so I switched to Ubuntu (in a Docker container). <h3 id="successful-try-on-ubuntu-in-docker">Successful try on Ubuntu (in Docker)</h3> Last code update on github is around 2021? Let's install Ubuntu 20.04 LTS then! I do not want to remove my ArchLinux, and a virtual machine would be too cumbersome (especially since I need to be able to access the board from the Ubuntu installation), so I created a new Docker container. The first step is to install Docker: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">$ paru -S docker $ sudo systemctl enable docker $ sudo systemctl start docker</code></pre> Then we can get the Ubuntu 20.04 image and install some packages: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">$ sudo docker pull ubuntu:20.04 $ sudo docker run -ti --rm ubuntu:20.04 /bin/bash # # inside the container from this point # apt update &amp;&amp; apt upgrade &amp;&amp; apt install build-essential screen git ... # do NOT exit the container before the next step!</code></pre> Once done, we will create a new image from the container, so that we do not need to do the above steps each time we want to run the container (the container ID will be different in your case). After this step it is safe to exit the container. Note that you need to redo the commit everytime you install a new software. <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">$ sudo docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 0b79278c9c68 ubuntu:20.04 &quot;/bin/bash&quot; 2 hours ago Up 2 hours great_khayyam $ sudo docker commit -p 0b79278c9c68 ubuntu20.04_hifive1b_dev</code></pre><h3 id="compiling-and-running-the-hello-example">Compiling and running the hello example</h3> Let's connect the board to the computer! You need to connect the board before running the container, otherwise the container will not be able to access it via <code>/dev/</code>. Another solution, not tried, would be to copy the compiled application to the board from the host. This should be possible as the board appears to the host as a USB device. You can run the container again. As I do not want to put the SDK and my code inside the image -- that would increase its size beyond something acceptable -- I am mounting a local folder inside the container. And I also need to pass the <code>--privileged</code> flag to the <code>docker run</code> command to access the board serial console (in <code>/dev/ttyACM0</code>). The new command is: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">$ sudo docker run --privileged -ti -v /absolute/path/to/local/folder/shared/with/container:/data ubuntu20.04_hifive1b_dev /bin/bash</code></pre> From inside the container, for some reason installing the RISC-V toolchain was stalling. And I'm not sure how to install the required JLink tools. So I changed my strategy: I downloaded and extracted <a rel="external" href="https://static.dev.sifive.com/dev-tools/FreedomStudio/2019.03.4/FreedomStudio-4.7.2.2019-03-4-linux.gtk.x86_64.tar.gz">Freedom Studio</a> inside the shared folder. It already contains the RISC-V toolchain and JLink tools, quite convenient! As I did on ArchLinux, I also downloaded the Freedom E SDK. Once done, we need to tell the SDK where to find the tools: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">export PATH=/data/FreedomStudio-4.7.2/SiFive/jlink/jlink-6.44.0-2019.03.0:${PATH} export RISCV_PATH=/data/FreedomStudio-4.7.2/SiFive/toolchain/riscv64-unknown-elf-gcc-8.2.0-2019.02.0</code></pre> To access the board serial console (from the container or host), run the following command (we'll use it to check whether our application runs correctly): <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">$ sudo screen /dev/ttyACM0 115200 # remove sudo if already root</code></pre> Finally, we can build the code (here the <code>hello</code> example from the SDK) and <code>upload</code> it to the board in one command: <pre class="giallo" style="color: #EBDBB2; background-color: #282828;" ><code data-lang="plain">make BSP=metal PROGRAM=hello TARGET=sifive-hifive1-revb software upload</code></pre> Just press the <code>RESET</code> button on the board to restart it with the new program, and voilà! You should see <code>Hello, World!</code> appearing in the serial console. Now the fun begins. I think I'll try to <a rel="external" href="https://github.com/rustbox/rustbox-hifive1-revb">write an OS in Rust</a>. Making Internet Applications Trustworthy 2024-04-08T00:00:00+0000 https://pierrelouis.pakupaku.me/blog/trustworthyinternet/ <h2 id="context-and-motivation">Context and motivation</h2> "The Internet’s potential is unlimited. As a worldwide resource, the Internet supports commerce, recreation, research, education, entertainment, and everything in between. But with different stakeholders and competing demands of the network, safeguarding the future of the Internet can seem like an impossible task." -- <a rel="external" href="https://www.internetsociety.org/wp-content/uploads/2021/11/Enablers-of-OGST-EN.pdf">The Internet Society</a> One important aspect to enable the above vision is trustworthiness. This can be enabled at various levels of the Internet infrastructure, from the low-level routing infrastructure to the high-level Internet applications. In this project we are concerned only with the later, high-level Internet applications: with this project, our goal is is to make Internet applications trustworthy. <h2 id="a-definition-of-trustworthy">A definition of Trustworthy</h2> In this context, what does trustworthy mean? The Internet Society teaches us that "a trustworthy Internet meets the expectations of its users by offering a resilient and reliable base for applications and services". Trustworthy encompasses several concepts: <ul> <li>reliability: the service is delivered as promised (e.g., a messaging application correctly delivers messages between the participants);</li> <li>resilience: the application continues to deliver its service even in the presence of errors or malicious behaviours;</li> <li>availability: the application is ready to answer users' requests;</li> <li>accountability: application operators and users can be identified and held responsible for their actions;</li> <li>privacy: users can control and understand what information about them is collected, how it is collected, and can control how this information is used and shared with others. Users might also prefer to remain anonymous. As an example, the <a rel="external" href="https://gdpr-info.eu/">GDPR</a> is a good example of a regulation aimed at protecting users' privacy on the Internet;</li> <li>confidentiality: eavesdroppers and attackers cannot observe sensitive data, both in transit and at rest;</li> <li>integrity: while confidentiality prevents malicious entities to learn something, integrity prevents them to alter it, for example a malicious cloud storage provider could replace a valid encrypted file with another, valid, encrypted file.</li> </ul> <h2 id="this-project">This project</h2> <h3 id="purpose">Purpose</h3> There are different levels where practitioners should increase the trust users have in the Internet infrastructure, from the low-level routing infrastructure to the high-level Internet applications. In this project we are concerned only with the later, high-level Internet applications (web server, database, file sharing service, etc.). Our goal is is to make Internet applications trustworthy, i.e., <ul> <li>Internet users have guarantees (security, fault tolerance, provided service, ...) on the applications they use (e.g., web server, storage service, streaming);</li> <li>companies running such applications are accountable for their behaviour;</li> <li>the Internet is a secure and resilient place without any single point of failure or single controlling entity. The Internet has started as a decentralized platform, and we want to keep it that way. Centralization not only creates single points of failure, but it also enable some companies or governments to use everyone's data for their own benefits.</li> </ul> <h3 id="approach">Approach</h3> Our approach is based on our previous knowledge in fault-tolerance and security. More precisely, we are working on improving the fault-tolerance and security of existing Internet applications, both on the server and client side. Nevertheless, our aim is to empower Internet users: our solutions should benefits users more than for the companies providing such services. Security and fault-tolerance are generally costly techniques that can decrease the performance of an application. We are exploring practical solutions that minimize this overhead so that practitioners can deploy our solutions on the real Internet without losing their customers. We are also considering the sustainability of our solutions. With climate change and international conflicts, it is not absurd to consider a <a rel="external" href="https://en.wikipedia.org/wiki/2020%E2%80%932023_global_chip_shortage">shortage of electronic components</a>, an <a rel="external" href="https://www.zdnet.com/article/as-moores-law-slows-high-end-applications-may-feel-the-effect-mit-scientist-warns/">innovation slowdown</a> or <a rel="external" href="https://news.mit.edu/2022/how-can-we-reduce-carbon-footprint-global-computing-0428">increasing demand on environmental-friendly solutions</a>. <h2 id="past-results">Past results</h2> My past research works have addressed this project goal in several ways, as can be seen in the figure below. <img src="https://pierrelouis.pakupaku.me/blog/trustworthyinternet/pastresearch.jpg" alt="Past research" /> Notable projects are: <ul> <li>RBFT, Next 700 are Byzantine Fault tolerant protocols designed to ensure good performance even in the presence of faults, where research works usually focuses on improving the performance in the best case scenario where no faults occur. The next 700 also empowers clients, as they are able to change the behaviour of the protocol if they suspect a fault;</li> <li>FullReview makes distributed systems accountable even in the presence of selfish participants, i.e., participants that want to maximise their benefits without contributing their fare share into the system;</li> <li>LibSEAL is a SEcure Auditing Library for internet services. It allows to detect integrity violations of internet services without the need to trust the service operator, by leveraging a Trusted Execution Environment;</li> <li>Endbox is a scalable and secure middlebox framework. It executes middlebox functions inside a Trusted Execution Environment on client machines. Despite its decentralised model, EndBox's middlebox functions remain maintainable, practical and scalable.</li> </ul> <h2 id="what-s-next">What's next?</h2> Making Internet Applications Trustworthy is a never ending endeavour. We tackle it one step at a time. Here is a non-exhaustive list of potential sub-projects: <ul> <li>making Byzantine Fault-Tolerance more practical;</li> <li>fault-tolerance for AI systems;</li> <li>decentralized and secure Internet;</li> <li>securing input devices (keyboard, mouse, etc.) against attacks (<a rel="external" href="https://en.wikipedia.org/wiki/BadUSB">badUSB</a>, <a rel="external" href="https://counterespionage.com/malicious-usb-cables/">malicious cables</a>, <a rel="external" href="https://en.wikipedia.org/wiki/Keystroke_logging">keyloggers</a>);</li> <li>novel Trusted Execution Environments;</li> <li>combat fake news;</li> <li>etc.</li> </ul> Please do not hesitate to <a href="../../about">contact me</a> if you are interested in such projects! Hardware timestamping 2023-10-30T00:00:00+0000 https://pierrelouis.pakupaku.me/blog/hardware-timestamping/ Network interfaces become smarter and smarter, being able to execute functionalities traditionaly managed by the OS. When wanting to develop such a functionality, a natural question is, "how much latency can I save ?". Hardware timestamping, an obscure functionality of (recent? Not too old?) NICs, inserts in a received network packet the current hardware timestamp. If the NIC clock and host CPU clock are synchronised, it becomes possible to measure the time it took from the NIC receiving the packet to the OS/application receiving it, ultimately answering how much latency one can save by offloading a functionality to the NIC. With <a rel="external" href="https://sys.cs.fau.de/person/vogel">Arne Vogel</a>, a PhD student from FAU Erlangen in Germany with whom I have been working this summer, we have written a blog article so that everyone can make use of this functionality: <ul> <li><a rel="external" href="https://eng-blog.iij.ad.jp/archives/21198">In English</a></li> <li><a rel="external" href="https://eng-blog.iij.ad.jp/archives/21208">In Japanese</a></li> </ul> An appendix of this article can be found <a rel="external" href="https://www.arnevogel.com/network-latency-measurements/">here</a>. SmartNetStack: Network Stack Offloading on SoC-based smartNIC 2021-06-01T00:00:00+0000 https://pierrelouis.pakupaku.me/blog/smartnetstack/ PI: <a rel="external" href="https://www.iijlab.net/en/members/pierrelouis.html">Pierre Louis Aublin</a>, IIJ Research Laboratory In today's architectures, cloud applications (such as web servers, key-value stores or databases) execute both the application logic and the network stack on the host CPU. As network speeds increase to more than 100Gbps, this becomes inefficient: when executing the Redis key-value store on a 40Gbps network, more than 38% of the CPU cycles are dedicated to TCP/IP processing [MOON20]; this increases as the network speed increases. Network vendors now propose smartNICs, special network cards that embed additional hardware functionalities for custom packet processing, cryptographic operations, checksum computation, and so on. Recent smartNICs, such as the SoC-based Mellanox BlueField smartNICs, are drawing the attention of researchers [KIM20, LIU21] thanks to their flexibility and ease-of-programming. Researchers have successfully offloaded parts of the network stack to the smartNIC [LE17, KIM20, MOON20]. However, offloading the entire network stack is believed to be impractical due to hardware limitations, performance and security issues, and so on [MOGUL03, PISMENNY21]. In this project we would like to challenge this assumption and explore the performance of cloud applications when the entire network stack is offloaded to the smartNIC, in particular the TCP/IP stack. The benefits are multiple: better CPU utilization by the application logic, lower network latency, better DMA bandwidth utilization, and better energy efficiency. This project is divided into three steps: (i) measure the design and performance characteristics of user-level network stacks such as DPDK-ANS [ANS21], mTCP [JEONG14] or lwIP [DUNKELS01]; (ii) develop a fast DMA library to efficiently send application payload between the smartNIC and the host application; and (iii) propose a novel programming interface for applications to make efficient use of this architecture. In the first step we will extend the analysis performed by Liu et al. [LIU21] on BlueField-2 smartNICs by measuring the design and performance characteristics of user-level network stacks such as DPDK-ANS [ANS21], mTCP [JEONG14] or lwIP [DUNKELS01]. Liu et al.'s network analysis focused only on the Linux kernel network stack, which is inefficient as it involves expensive system calls. In a second step, we will develop a fast DMA library to efficiently send application payload between the smartNIC and the host application. As the network stack is entirely executed on the smartNIC, the application payload can be directly sent to the application. This removes metadata (such as the IP and TCP headers), increases the data transferred size (as small network packets are aggregated on the smartNIC), and improves the DMA bandwidth utilization. Finally, we will propose a novel programming interface for applications to make efficient use of this architecture. Application developers do not need to rely on the socket API anymore. In particular network-related code (for example to manage connections or re-transmit messages) is moved to the smartNIC, with the application only receiving and sending its specific payload to the smartNIC. This project will leverage the BlueField-2 smartNICs available at CloudLab. We will first focus on one applications: the Nginx web server [NGINX21]. We will measure the application performance, network throughput, latency (including average and tail latency), CPU usage, DMA bandwidth, and so on. Extensions to this work are multiple: optimizing the performance of other types of applications (key-value store, databases, machine learning, etc.); offloading additional network functionalities (in particular TLS), etc. <h2 id="publications">Publications</h2> <ul> <li>A Secure Network Stack for the Untrusted Cloud. Keita Aihara, Pierre-Louis Aublin, and Kenji Kono. In the Fifteen European Conference on Computer Systems (EuroSys). April 2020.</li> <li>secureTCP: Securing the TCP/IP stack using a Trusted Execution Environment. Keita Aihara, Pierre-Louis Aublin, and Kenji Kono. In the Information Processing Society of Japan System Software and Operating System conference (ComSys). December 2019.</li> </ul> <h2 id="references">References</h2> <ul> <li>[ANS21] ANS team, "ANS: DPDK Native Accelerated Network Stack," 2021. Available: http://www.ansyun.com/</li> <li>[DUNKELS01] Dunkels, Adam. "Design and Implementation of the lwIP TCP/IP Stack." Swedish Institute of Computer Science 2.77 (2001).</li> <li>[JEONG14] Jeong, EunYoung, et al. "mtcp: a highly scalable user-level {TCP} stack for multicore systems." 11th {USENIX} Symposium on Networked Systems Design and Implementation ({NSDI} 14). 2014.</li> <li>[KIM20] Kim, Duckwoo, SeungEon Lee, and KyoungSoo Park. "A Case for SmartNIC-accelerated Private Communication." 4th Asia-Pacific Workshop on Networking. 2020.</li> <li>[LE17] Le, Yanfang, et al. "UNO: Uniflying host and smart NIC offload for flexible packet processing." Proceedings of the 2017 Symposium on Cloud Computing. 2017.</li> <li>[LIU21] Liu, Jianshen, et al. "Performance Characteristics of the BlueField-2 SmartNIC." arXiv preprint arXiv:2105.06619 (2021).</li> <li>[MEMCACHED21] Memcached team, "High-performance, distributed memory object caching system." 2021. Available: https://memcached.org/</li> <li>[MOGUL03] Mogul, Jeffrey C. "TCP Offload Is a Dumb Idea Whose Time Has Come." HotOS. 2003.</li> <li>[MOON20] Moon, YoungGyoun, et al. "Acceltcp: Accelerating network applications with stateful TCP offloading." 17th USENIX Symposium on Networked Systems Design and Implementation (NSDI 20). 2020.</li> <li>[NGINX21] Nginx team, "Nginx: High performance Load Balancer, Web Server &amp; Reverse Proxy." 2021. Available: https://www.nginx.com/</li> <li>[PISMENNY21] Pismenny, Boris, et al. "Autonomous NIC offloads." Proceedings of the 26th ACM International Conference on Architectural Support for Programming Languages and Operating Systems. 2021.</li> </ul>