DEV Community: conjurer

PGP decryption and signing

conjurer — Wed, 18 Feb 2026 06:16:34 +0000

Here's what we skip sometimes: when you receive an encrypted + signed PGP message, you can't see the signature until you decrypt it.

PGP signs first, then encrypts. The signature is sealed inside.

What's acTually insIde

The outer layer is encryption. Your private key unlocks it. Only then can you see:

who signed it (signer's key id)
actual content
the sign itself

The 2 pHase floW

Decrypt -> reveals the signer's key id
Verify -> confirms the signature

The gotCha that cost me hoUrs

After decrypting, I tried parsing the content- extract the parts, do some processing, pass to verification.

Signature verification failed. Every time.

Here's why:
PGP libraries use streaming parsers. When you parse a packet, you get the header, but the body is still in the stream- waiting to be read. If you serialize what you parsed, the body is missing.

The fix:
Read raw bytes first, before parsing. Those bytes are the complete signed message. Pass them directly to verification.

Quik referEnce

Encrypted Message
├── Session Key (encrypted for you)
└── Encrypted Blob
    └── [after decryption]
        ├── Signer's Key ID  ← now you know who!
        ├── Content
        └── Signature

Epoch time

conjurer — Mon, 16 Jun 2025 17:20:46 +0000

Epoch time, also known as Unix time or POSIX time, is just:

The number of seconds since 1970-01-01 00:00:00 UTC

(ignoring leap seconds)

🧠 Why use it?

Simple, universal way to represent time
Great for timestamps, logs, caching, or versioning
Timezone-neutral

🔢 Example:

Human Time (UTC)	Unix Time
1970-01-01 00:00:00	0
2000-01-01 00:00:00	946684800
2025-06-16 18:00:00	1755405600

⚙️ Get current Unix time:

date +%s (Linux/macOS)


import time
print(int(time.time()))

API Throttling 🏎️

conjurer — Fri, 30 May 2025 05:34:00 +0000

Throttle in a car

The throttle (aka accelerator pedal) controls how much fuel enters the engine.
More fuel → more power → more speed.

Push the pedal, the car zooms. Release it, the car eases up.

API

or Application Programming Interface
is the middleman between user and application. Every tap, swipe, or click you make sends a request through an API.

Now imagine millions of users doing that all at once.
Boom 💥 — a flood of requests. Servers can get overwhelmed.

Throttling is how we control that flood. It sets limits on how many requests can be sent over a period — just like how a car throttle limits speed.

Why throttling

If an app has large user-base, users with blazing fast connection could hog all the server bandwidth.

Slower users might be refrained from usage (talking legally haha).

Heard of DDos attack right? The one where person D sends tsunami of requests to crash the app.

How-to throttle

Leaky bucket

Requests filling a bucket at random speeds, but leaking (processing) at a fixed rate.

if queue (bucket) is full
  "429 Too Many Requests";
else 
  queue.push(request);

Issue: starvation; newer requests get dumped if current processes are long-running tasks.

Fixed window

Requests are counted in fixed intervals (like per second/minute).

while (each interval) {
  process min (incoming_requests, requests_per_interval);
}

Issue: bursts; too many users at the start of the window can overwhelm the system before the second is up.

Sliding window

Smarter cousin of fixed window. It smooths out request bursts by calculating usage over a rolling time window.

On each request:
  if user_requests_in_last_x_seconds < limit
    process user_requests_in_last_x_seconds;
  else "429";

Like checking speed over the last interval instead of just the current one.

Misc.

Retry strategy - don't keep honking, wait a little longer after each response failure
Many APIs tell a user's closeness to rate limit, use them
429 = server saying Have a Break, Have a KitKat

From Gnutella to DHT: Smarter Sharing

conjurer — Sun, 20 Apr 2025 11:50:57 +0000

You click Download on a Linux ISO or that obscure open-source game, and somehow—bits of it start flowing in from all over the globe. Not from a single server, but from a swarm of strangers. Cool! But… how?

🧩 Step 1: Not All P2P Is Structured Chaos

Before we get to BitTorrent, let’s back up a bit.

Gnutella: A Swarm Without a Map

Gnutella was one of the earliest P2P protocols. It didn’t care about structure. A node looking for a file would just yell into the void:
Hey, neighbors — got this file?
If they didn’t, the request would ripple outward.

It worked… kind of. But the inefficiency grew fast—lots of messages flying around, lots of nodes just forwarding them.
Imagine finding a book in a giant library by just asking random people.

🧱 Step 2: Structure Comes In – Enter DHT

Structured networks introduced Distributed Hash Tables (DHTs). These are like well-organized directories: instead of shouting into a crowd, you navigate through a small number of connections—like Six Degrees of Kevin Bacon, but with hex IDs.

Each node is assigned a key (a long hex string), and each file is also hashed to a key. Nodes store file pointers close to that file’s hash.

So how do nodes find each other?
They maintain a routing table. It’s like a sparse map:

Each row in this table corresponds to a longer prefix match with the node’s ID. Each column represents a possible hex digit at that position. Over time, it learns good "directions" for routing toward any key.

So instead of broadcasting everywhere, you hop from node to node, getting closer and closer to the file’s hash.

🧪 Step 3: BitTorrent – Efficient Chaos

Now—BitTorrent. It’s a peer-to-peer protocol, but it takes it further:
Files are split into pieces.

You can download different pieces from different peers simultaneously. Once you have a piece, you can serve it to others.

Each group of people sharing a file is called a swarm. A tracker keeps track of peers in a swarm and who has what. But there’s a twist…

Trackerless Torrents (DHT-powered swarms)

BitTorrent introduced a DHT-based approach for peer discovery. Instead of relying on a tracker (which can fail), nodes use DHT to:

Store: Hey, I have file X (hash: abcd...)—if anyone needs it, here’s my IP.
Find: I’m looking for file X—who has it?

And the routing table magic we talked about? That’s what powers this.

🕸️ Finder Networks: Meta-Swarm Mechanics

Sometimes, you don’t connect to a swarm directly. You connect to a peer finder. These finders form a kind of meta-overlay, a network where each node relays partial knowledge of finders to other finders connected to the swarm (reversing the swarm - finder role haha).

When you search for a file:

You ask your local finder node.

If it doesn’t know the answer, it forwards the request to a connected finder.

The search continues until a finder can:

Directly connect you to the swarm, or

Connect to another finder who knows more.

Each finder keeps a table of IDs and their approximate location in the overlay—so your request isn’t random, it’s guided by proximity in hash space.

Turn the Wi-Fi on!

conjurer — Sat, 05 Apr 2025 15:39:48 +0000

Ever walked into your house, turned on the light switch, and nothing happened—only to realize the main power was off?

Booted up the Linux machine and Wi-Fi wasn’t working!

Step 1: Check if the "Power Supply" (NetworkManager) is ON

NetworkManager is like house's electrical panel—it manages which appliances (Wi-Fi, Ethernet, etc.) get power (internet).

systemctl status NetworkManager

Output:

Active: inactive (dead)
NetworkManager.service: Job NetworkManager.service/start failed with result 'dependency'.

The main switch was off.

Turn the Power Back On

sudo systemctl restart NetworkManager

Now it showed:

Active: active (running)

Lights are back on! 💡 But wait…

Step 2: Check if the Devices Are Plugged In

Let’s see if the Wi-Fi adapter is even recognized (like checking if the lamp is plugged in).

ip link show
nmcli device

Looks good! The adapter was visible and marked connected, but internet wasn’t quite there yet…

Step 3: Check Device Connection

ip a | grep inet

A proper IP address (getting electricity at the socket). A quick:

ping -c 4 8.8.8.8

Returned successfully—so the raw connectivity was fine!

Step 4: DNS - the Culprit

aka, the Address Book Was Missing

Even though the connection was up, websites still weren’t loading.

Like having electricity, but the smart speaker doesn’t know how to play music—because the Wi-Fi password is gone, or here, the DNS resolver was missing.

Fix it by adding Google's DNS server:

sudo vi /etc/resolv.conf
nameserver 8.8.8.8

Step 5: Restart Network Services

Just like you'd reboot your Wi-Fi router when things get weird, restart the services:

sudo systemctl restart NetworkManager
sudo systemctl restart wpa_supplicant.service

🎉 And finally—it worked. Back online!

TL;DR:

NetworkManager = Power switch
WiFi Adapter = Device plugged in
IP Address = Electricity flow
Restarting services = Rebooting the system

Linux Package Management: A Gourmet Guide

conjurer — Mon, 16 Sep 2024 06:21:26 +0000

Restaurant Analogy

Downloading and installing software on Linux ~ ordering a meal

Aim: bring meal (software) to the table (computer)

There are different ways to get a software, whether it's a package from the official repository or an external source (restro), or compiling from source (diy cooking).

Let'see how this works!

The Menu: Repositories and Packages

Choosing

Different distributions (or restaurants) have their own repositories, just like how some restaurants serve Italian food while others serve sushi.
For example, view the available packages:

sudo apt update

Ordering

sudo apt install <package-name>

The waiter communicates with the kitchen (package manager).

This process downloads the package, along with any dependencies needed to make sure the meal works perfectly.

The Kitchen: Installing the Software

Prep

Kitchen starts unpacking all the ingredients (the software files and dependencies).

The package manager (chef) ensures everything is compatible and fits perfectly on the system. Missing dependencies are fetched and added.

And done!
(this was the external source installation)

DIY

Instead of using pre-packaged ingredients, you’re starting with raw materials (grabbing the source code) and cooking it on your system using:

./configure
make
sudo make install

++ Can customize according to user needs!
++ Made from scratch!

Redux: Town of Magical Order

conjurer — Sun, 15 Sep 2024 04:48:34 +0000

An interesting approach!

The Magical Town of "Redux" 🏰

This town had one amazing feature: no matter what happened, everyone in town always knew the exact state of everything going on. No confusion, no chaos—everything was magically managed! How?!

Let's see.

The Requests (Actions) ✉️

If someone wants something to happen in the town, they fill out a request form called an Action.

An Action is a simple document that says:

What you want to do (Adopt a dragon).
Any extra details (Adopt a fire-breathing dragon).

Example actions:

Action Type: "ADOPT_DRAGON"
Details: Fire-breathing dragon

These requests are super important because they let the town make changes in a predictable way. No one can just go rogue!

The Messengers (Dispatch) 🏃‍♂️

Now how do people submit their requests? They use messengers. The townspeople call this process Dispatching an Action.

When a resident wants to make a change, they dispatch an Action (request) to the Mayor.

The Mayor (Store) 👨‍💼

In Redux, there’s a Mayor who keeps track of everything happening in the town. He knows:

How many houses are built.
What’s in everyone’s fridge.
How many unicorns are running around!

The Magical Scroll (State) 📜

This scroll holds the entire truth of the town. The scroll updates whenever something official happens, and every resident trusts the scroll.

A reference:

The Wizards (Reducers) 🧙‍♂️

Now, who handles these dispatched requests? The Wizards in town! These Wizards are known as Reducers.

Whenever the Mayor receives an Action (request), he sends it over to the Reducers, who are magical beings. Their job is to take the current State (the magical scroll) and the Action, then figure out what the new State should be.

For example:
If the Action is to adopt a dragon, the Wizard makes sure there’s room for a dragon and updates the scroll.

Rule: Wizards can’t change the scroll directly. They always make a copy of the current scroll, make the necessary changes on the copy, and send that back to the Mayor.

The Town Criers (Subscribers) 📢

Finally, Redux has this special group. These are creatures who like to stay updated with everything that happens. Whenever the State (magical scroll) changes, the Town Criers immediately announce the new State to everyone who cares to listen.

Why Is Redux Awesome? 🎩

Single Source of Truth: Everything about the town (the State) is written down in one place (the magical scroll).
Predictability: The Reducers handle all changes in the town in a controlled, predictable way.
Structure: No random changes, no chaos. Everything is handled through Actions, which ensures order.

DNS: More Than Just a Web Directory

conjurer — Wed, 11 Sep 2024 06:04:59 +0000

Domain Name System

Laziness led to Domain = D here.

It's not just 1 system that caches all the millions of sites, something deeper.
It consists of 3 servers:

So, the Auth servers (3rd) store the Ds with their IP addresses. The text instructions to determine the IP address for a specific D are DNS records or zone files.

Let's see some!

A | AAAA : resolve D to IPv4 | IPv6
PTR : reverse of 1, check email spams
CNAME : aka another domain (when typing www.instagram.com, it leads to instagram.com)
MX : the server to send email to
NS : name of auth server
SRV : get service and port number
TXT : text info about D

Web scraping- Interesting!

conjurer — Fri, 06 Sep 2024 04:20:12 +0000

A cool term:
CRON = programming technique that schedules tasks automatically at specified intervals

Web what?

When researching projects etc., we usually write info from various sites- be it in a diary / excel / doc etc.
We are scraping the web and extracting data manually.

Web scraping is automating this.

Example

When googling say sneakers online, it shows a list of websites with products and prices. On the shopping tab is a more detailed record right?
Google just scraped websites for you to show sneakers from different sites.
This techinque is used by almost all big companies for their businesses since data has been increasing exponentially.

Web Crawler

This is a technique that although fetches information but differs from scraping in the sense that it searches for the best websites and indexes them whereas scraping is done in a single website.

It's used for SEO analysis (scraping - gathering data).

Famous web scraping technologies:

Issues!

Notice it's not a user making requests to get the info from site, it's the code written! If the websites know this task is automated, they will quickly block the IP address.
And this check has given rise to

Captchas
Rate limiting
Dynamic content

Goal: simulate how humans work!

Bright data automates the job. It even rotates IPs to make the user unknown and unblocks sites (paid version!) for the user.

Shoutout to JSM for the wonderful explanation.
Ps:

Lol!

Geometric art | C++

conjurer — Wed, 04 Sep 2024 14:42:44 +0000

Some geometric art today!
Just some clicks and voila! A great pattern!

Libraries

SDL2
iostream
vector

int main()

User can choose between 2 modes, hence type.

main while(1)

Detect if user wants to quit and exit;

Detect a left click on the screen to add edges in the vector, and hence on the screen. Event handler sets the coordinates (x, y).

Mouse movements are tracked on screen for location pointers.

On keypress:

c : clear
m : connect 2 most recent clicks (type 1)
l : connect every point to every other point in vector (type 0)
u : undo the last line(s)

Types of connections

Set bg, drawing colors.
Decide pattern according to type.
Update the screen on render.
Wait 1s before returning.

Output

The Builder rocks it!

Rotating cube | C++

conjurer — Mon, 02 Sep 2024 13:20:37 +0000

A quick and cool code!
SDL2 is a library designed to provide low level access to audio, graphics hardware etc.
Supports C++, lessgoo!

Setup - screen.h

Initialised the event handler, window and render pointers, and basic data members.

Requirements

Show pixels on screen
Clear the screen
Check if quit activity detected by user

Solution

A vector that stores all points to be rendered on screen. Looped to render them. Cleared the vector to clear the screen.
Quit if user wants to exit.

The Cube

Some structs and functions for 3d geometry

On the screen | int main()

Initialised the cube with vertices and edges, and a centroid for easy translations

Brought each point to the origin, rotated it along the axes, translated it back.

Show time!

Thanks to The Builder for sharing the amazing tutorial!

Deadlock | Valorant

conjurer — Sun, 01 Sep 2024 05:50:44 +0000

Program | Process

Program = some instructions a computer follows to execute / perform a task. It's stored in the secondary memory (eg. disk) and can have many processes.
Process = an instance of a program, or a file under execution.
(Yes running the .exe after compiling a .cpp)

A program becomes a process when loaded into RAM.

Deadlock

Like when two or more processes in a computer are waiting for each other to make a move, and no one’s budging.

Imagine two processes are holding onto resources the other needs, but neither can proceed without the other letting go first. It’s the ultimate stalemate, and nothing moves forward.
Like 2 programmers waiting for each other's code to merge first.

Deadlock’s Barrier Mesh

If you’ve played Deadlock in Valorant, you know her Barrier Mesh (e) ability throws out a net that creates four interconnected nodes.
Now, picture this: each of those four nodes represents a process dependent on each other. The dependence can be seen by the fifth central node.
That’s what happens in a computer science deadlock: multiple processes are trapped, stuck in a loop of dependencies where each one waits for the other to release its hold of the requested resource.

Breaking the Barrier: Resolving the Deadlock

A few options in Valorant: destroy the nodes or wait it out.
Similarly, in programming, breaking a deadlock means forcing one process to release its hold or finding a workaround.
Timeouts, resource ordering, or other techniques can be used to force a process to back down, freeing up the system.

Whether it’s a game or a server, breaking the deadlock takes action and strategy — but once it happens, everything flows smoothly again.

Thanks to the Valo devs for the easter egg!