rink.nu

On my migration from GitHub to Codeberg

Sat, 01 Aug 2026 00:00:00 +0000

I think my first introduction to Codeberg was about 1.5 years ago, when it was mentioned by a CCC talk. If I remember correctly, the presenter was mainly concerned with Microsoft’s acquisiting and involvement of GitHub. Having used GitHub since 2015, before it became part of Microsoft, I did not see an immediate need to act: it suited my purposes just fine and I did not feel that strongly about the politics involved.

Just in case though, I decided to make a Codeberg account. My main motivation at the time was to ensure my GitHub handle was secure, but as time went on I decided to experiment a little. I was amazed with the speed of the website: it all felt very snappy! I was well-used to GitHub by then, having used it for the last decade or so, and this new experience was quite nice. I decided to use it for a small private repository, just to see how that went.

First steps in Zig (0.15.2)

Mon, 16 Feb 2026 12:00:00 +0000

Introduction

A few weeks ago, I was replaying an old ‘90-ies adventure game and… I got stuck. I decided to look up online hints, and remembered the https://www.uhs-hints.com website (back in the early 2000s, this used to be a very relevant resource). Unfortunately, the game I was playing didn’t have the hints available online.

Installing NetWare 3.12 in QEMU

Sun, 24 Aug 2025 12:00:00 +0000

Why?

This is a let’s turn my notes into a post writing. I like to pick up NetWare-related reverse engineering endeavors every now and then, and most of these involve having a NetWare 3.12 server available somewhere. In current day and age, that means a VM or emulator. I like to use QEMU, so I’ll be using that.

[Contributed] How to: get root on a Foscam FI9831W (2017)

Sun, 17 Nov 2024 12:00:00 +0000

Note: this is a contributed post by Jens Heine binbash@gmx.net – please reach out to him if there any questions or comments! And a big “thank you” from me (Rink) for your contribution!

This firmware modification is mainly inspired from another HOWTO from Rink’s blog where he hacked a FI9853EP.

First get access to a TTY console on the mainboard of the cam. There are 4 contacts in the picture: RX, GND, TX.

Implementing a std::function<>-like wrapper in C++, part 3: using a static storage buffer

Mon, 08 Jul 2024 12:00:00 +0000

Previously, we’ve made our version of std::move_only_function<> generic so that it can be used to store any function signature, regardless of the number of parameters or return type. The implementation we’ve ended up with is the following:

cpp

template<typename ReturnType, typename... Args>
struct MyFunctionInterface
{
    virtual ~MyFunctionInterface() = default;
    virtual ReturnType operator()(Args...) = 0;
};

template<typename Fn, typename ReturnType, typename... Args>
class MyFunctionImpl : public MyFunctionInterface<ReturnType, Args...>
{
    Fn fn;

public:
    MyFunctionImpl(Fn fn) : fn(std::move(fn)) { }

    ReturnType operator()(Args... args) override
    {
        return fn(std::forward<Args>(args)...);
    }
};

template<typename ReturnType, typename... Args>
class MyFunction;

template<typename ReturnType, typename... Args>
class MyFunction<ReturnType(Args...)>
{
    std::unique_ptr<MyFunctionInterface<ReturnType, Args...>> fn;

public:
    template<typename Func>
    MyFunction(Func function)
    {
        fn = std::make_unique<MyFunctionImpl<Func, ReturnType, Args...>>(
                          std::move(function));
    }

    ReturnType operator()(Args... args)
    {
        return fn->operator()(std::forward<Args>(args)...);
    }
};

template<typename ReturnType, typename... Args>
struct MyFunctionInterface
{
    virtual ~MyFunctionInterface() = default;
    virtual ReturnType operator()(Args...) = 0;
};

template<typename Fn, typename ReturnType, typename... Args>
class MyFunctionImpl : public MyFunctionInterface<ReturnType, Args...>
{
    Fn fn;

public:
    MyFunctionImpl(Fn fn) : fn(std::move(fn)) { }

    ReturnType operator()(Args... args) override
    {
        return fn(std::forward<Args>(args)...);
    }
};

template<typename ReturnType, typename... Args>
class MyFunction;

template<typename ReturnType, typename... Args>
class MyFunction<ReturnType(Args...)>
{
    std::unique_ptr<MyFunctionInterface<ReturnType, Args...>> fn;

public:
    template<typename Func>
    MyFunction(Func function)
    {
        fn = std::make_unique<MyFunctionImpl<Func, ReturnType, Args...>>(
                          std::move(function));
    }

    ReturnType operator()(Args... args)
    {
        return fn->operator()(std::forward<Args>(args)...);
    }
};

This works for any movable function, for example:

Implementing a std::function<>-like wrapper in C++, part 2: generalizing the return type and arguments

Sun, 10 Mar 2024 12:00:00 +0000

Introduction

Previously, we’ve seen a way to implement our own version of std::move_only_function<>. The implementation we ended up with is as follows:

Implementing a std::function<>-like wrapper in C++, part 1: type erasing

Sat, 24 Feb 2024 12:00:00 +0000

Introduction

Recently, a chat with a friend peeked my interested: how would you store an arbitrary function and call it, similar to std::function<>. It turned out a plain C function pointer would suffice for this specific use-case, but I got triggered: let’s implement a generic, move-only function wrapper in C++!

Hacking into a Foscam FI9853EP camera, part 2

Sun, 12 Mar 2023 12:00:00 +0000

In my last post, I examined how to get U-Boot access and obtain the flash data from a Foscam FI9853EP camera. Whereas this data is very useful for offline analysis, I wanted to get a root shell so I can poke around in the system and run commands manually.

Extracting the root filesystem

Last time, we extracted a file called kernel.mtd, which contains an U-Boot uImage with the kernel itself. There will likely be an initrd (a root filesystem) embedded within this kernel, as it contains necessary files such as /sbin/init, the password file, startup scripts etc. This will be our initial target, but how do we get to it?

Hacking into a Foscam FI9853EP camera, part 1

Sun, 26 Feb 2023 12:00:00 +0000

I have a Foscam FI9853EP, which was introduced in 2014 and has long since been obsoleted. One of the things that stands out, is that all firmware is encrypted:

1
2

$ file FosIPC_B_patch_ver2.x.2.31_3_20190718_150013.bin
FosIPC_B_patch_ver2.x.2.31_3_20190718_150013.bin: openssl enc'd data with salted password

1
2

$ file FosIPC_B_patch_ver2.x.2.31_3_20190718_150013.bin
FosIPC_B_patch_ver2.x.2.31_3_20190718_150013.bin: openssl enc'd data with salted password

I was curious: what could be in the firmware that needs this amount of protection? Usually, firmwares are plaintext but signed so that you can’t installed any unauthorized software in your device.

Behind the magic of magic_enum

Sun, 12 Feb 2023 12:00:00 +0000

Recently, a coworker pointed me towards a C++17 library to convert enumeration values to strings and vice versa. The library called (magic_enum)[https://github.com/Neargye/magic_enum] and it indeed feels like magic. I was immediately curious: how did they pull this off?

The code I am presenting here can be seen as a massively down-scaled version of magic_enum: the approach taken is exactly the same. I’ve mainly tried to simplify for purposes of readability and understandability. Thus, consider the code presented here licensed using MIT, the same license which governs magic_enum – just will less features and more comments. You can find my re-implementation at https://gist.github.com/zhmu/9ac375706ffbafa5d24693f8475abd79.

On NetWare 3.x password hashing

Fri, 03 Feb 2023 12:00:00 +0000

Way back when, I was involved in trying to obtain passwords for a Novell NetWare 3.12 server. I won’t go into details here, suffice to say that the topic has always interested me – sufficiently to return to it 30-ish years later and write down an algorithm description.

The research presented here is based on my independent disassembly of the embedded server.nlm in NetWare 3.12. I have compared these findings to ncpfs 2.2.0, mars_nwe-0.99.p121 and itsme’s sources, and believe the information as presented here to be correct. However, if you spot mistakes or omissions please let me know!

Reverse Engineering the Netware 386 Filesystem

Sat, 21 Jan 2023 12:00:00 +0000

I decided to take a look into the NetWare 386 filesystem, which was used in NetWare 3.x and 4.x and perhaps later versions as well. This post serves to give a high-level background on the design and layout. Tools to analyze and extract content from such a filesystem can be found at https://github.com/zhmu/nwfs386

If you have any corrections, additional information or questions, please reach out to me by email at rink@rink.nu. I’ll try to update this post as necessary. I also accept pull requests on Github!

Creating a binutils/gcc toolchain for your OS

Fri, 23 Dec 2022 12:00:00 +0000

I wanted to update the binutils/gcc-based compiler toolchain of my Dogfood operating system. This entry describes some concepts and the changes that needed to be made in order to add this target to binutils 2.39 and gcc 12.2.0.

Configuration targets

Most of the GNU autotools work with configuration targets, which have the form <cpu>-<vendor>-<os>, where <os> can be <system> or <kernel>-<system>. For example, my Debian installation is x86_64-pc-linux-gnu, which decodes to a x86_64 cpu, vendor pc with a linux kernel and a gnu system.

Mon, 01 Jan 0001 00:00:00 +0000

Hello world!

Hi, I’m Rink and I like to tinker with technology in my spare time. Feel free to check out my Codeberg repositories where I publish most of my work these days.