Portrait of Ruddro Roy

Ruddro Roy

Electrical Engineer

From Circuits to Code: My Journey into Software

When I tell people that I started my journey in Electrical and Electronic Engineering, the typical response is surprise. However, once I explain the parallels between the jobs, the surprise dissipates, and it becomes more clear that it's not such a big step to make. Transitioning from a hardware to a software career is similar to learning a new dialect, spoken in the same language.

Continue reading

My university days were spent designing circuits, writing and debugging firmware for microcontrollers in assembly, and getting my blinking LEDs to work without frying the hardware. But it wasn't the physical hardware I was fascinated by. I was enamored by the logic and rules that governed everything. Every circuit schematic had its firmware, and I found myself working more and more in C, striving to make the code better, faster, and more efficient.

But it was a gradual process. First, I started automating some of my lab measurement tasks with Python. Then I built a data logger just out of curiosity and visualized that data. And while I was doing all this, I began to think about how the concepts I knew from hardware, such as state machines, concurrency, and memory management, mapped to the software world. It was in this time that I began to notice that my ability to think about hardware and software from both perspectives became a big advantage in my career. Being able to think at the transistor level helped me better understand why my code was optimized and also helped me solve some of the most complex bugs, particularly when they occurred only under specific electrical noise conditions.

While I did need to pick up some new concepts to truly make the transition to software, I found that there were some key skills from my hardware days that remained valuable. For example, systems-level thinking, rigorous debugging, and persistence in the face of adversity were all traits I picked up in the hardware laboratory. Software has different layers of abstraction than hardware, but the mindset and motivations are quite similar.

Even today, as an engineer, I use my electrical engineering intuition when thinking about race conditions, when breaking down network protocols to the byte level, and when appreciating the engineering that goes into making a simple screen blink.

Sindook v0.11.1Apache-2.0

Sindook seals files with hybrid post-quantum encryption.

A local Apache-2.0 CLI. X-Wing pairs X25519 with ML-KEM-768. The name is Bengali for strongbox.

11 references

The design is the argument.

Encrypted files tend to outlive the decisions that created them. The confidentiality expected of a backup today may still be required in twenty years, while the list of people allowed to open it can change next month.

Read the full argument

The literature treats these as distinct problems: an adversary can store ciphertext now and wait for quantum-capable attacks, which is the harvest-now, decrypt-later threat, and access-control changes create a separate operational need to update recipients without re-encrypting large payloads. Sindook therefore treats file encryption as a hybrid-encryption problem with a recipient-management layer above it: encrypt the payload once under a random file key, then encapsulate or wrap that key separately for each recipient (Herranz et al., 2010; Zhou et al., 2025).

This separation matches how the hybrid-encryption literature models public-key encryption: a key-encapsulation mechanism establishes shared key material, a data-encapsulation mechanism protects the payload, and the two can be analyzed independently (Herranz et al., 2010; Shibuya & Shikata, 2011). On that view, recipient updates touch only the metadata that carries wrapped keys rather than forcing payload re-encryption. The LUKS keyslot model is best understood as the implementation analogy for this slot-based key management, not the primary literature basis for it.

The case for a hybrid wrap layer is, in the literature, a migration trade-off. Hybrid KEMs are motivated as a transition strategy: they preserve compatibility with deployed classical infrastructure while adding post-quantum protection against future cryptanalytic advances (Liu et al., 2025; Zhou et al., 2025), and formal work on hybrid key exchange shows such combinations can be analyzed rigorously rather than treated as ad hoc redundancy (Chen et al., 2025; Zhou et al., 2025). The strongest support is for the general hybrid approach, not for the claim that any particular combiner forces an attacker to simply defeat both halves; that depends on the combiner and protocol details being instantiated and analyzed correctly (Cremers et al., 2024; Liu et al., 2025). Sindook's choice is X-Wing, X25519 combined with ML-KEM-768 through a SHA3-256 combiner, and the combiner results say the construction holds as long as either side does, which is the margin a decades-long archive needs.

The payload uses a standard AEAD pattern: one random 256-bit file key encrypts the file in 64 KiB chunks, and per-chunk metadata is authenticated as associated data rather than left unauthenticated (Rogaway, 2002). Binding the chunk counter and a final-chunk indicator into the nonce follows the literature showing that protection against reordering, replay, truncation, and drop attacks requires explicit sequencing information beyond basic forgery resistance (Boyd et al., 2016). Each slot derives a distinct wrap key through HKDF-SHA-256 salted by the file nonce, and the associated data binds the slot to the file and to its own KDF parameters. AEAD exists precisely to authenticate unencrypted context such as headers and parameters (Rogaway, 2002), and subtle AEAD design differences can materially affect protocol security when context binding is weak (Cremers et al., 2023), so the claim that a slot cannot be transplanted or downgraded should be read as contingent on correct domain separation and complete metadata authentication, not as an automatic consequence of using AEAD. A MAC keyed by the file key authenticates the whole header, so any slot added, removed, or reordered without the key fails verification before the payload is read; the key-wrap literature makes the same point, that wrapping and metadata protection need authenticated, context-binding constructions rather than bare encryption (Rogaway & Shrimpton, 2006).

This design earns its complexity where files are long-lived, recipients rotate, or ciphertext may be collected by an observer. Cold backups, offsite archives, team documents, and anything crossing email all fit. If a file's secrecy horizon is measured in days, or re-encryption is cheap, the slot machinery buys less. That is the honest boundary of the design.

Two things are deliberately absent. Proxy re-encryption assumes an untrusted party that must transform ciphertext without seeing plaintext; a local tool already holds the key, so the machinery adds nothing. And slots carry no recipient identifiers, which keeps metadata small but means inventory and removing a recipient whose key you do not hold will need a future format version. Both trade-offs are written down in the repository's design documents.

Install v0.11.1

The Homebrew tap is ruddro-roy/sindook. The curl and PowerShell scripts work without Homebrew.

Homebrew

brew install ruddro-roy/sindook/sindook

Linux or macOS

curl -fsSL https://raw.githubusercontent.com/ruddro-roy/sindook/main/scripts/install.sh | sh

Windows PowerShell

irm https://raw.githubusercontent.com/ruddro-roy/sindook/main/scripts/install.ps1 | iex

Go 1.26.6 or newer

go install github.com/ruddro-roy/sindook/cmd/sindook@v0.11.1

After install, this is enough.

sindook init
sindook seal report.pdf
sindook open report.pdf.sindook

Commands

init
Creates your identity.
seal
Encrypts a file.
open
Decrypts a sealed file.
verify
Checks a sealed file without writing plaintext.
scan
Audits TLS endpoints and local key files for weak or quantum-vulnerable crypto.
inspect
Reads metadata without credentials.
rewrap
Rotates recipients without rewriting the payload.
rotate
Retires one identity across every file it can open.
contacts
Stores named public keys.
doctor
Checks the install.
selftest
Runs the built-in checks.

Limits

This is pre-1.0. Nobody has independently audited it. X-Wing is still an IETF draft. I am the only maintainer.

The CLI stays free. I am not selling a hosted version.

Journal

All writing →
Journal4 min read

The perennial software dilemma: build for learning or ship for use.

A few years ago, I spent months on deep dives into security and privacy tools that would consume most of my attention. I did a lot of experimentation, and each experiment taught me a new piece of software or way of thinking. Whether it was understanding how encryption worked, or how network sniffing was used, how to harden a system, or to think through potential threats, each experiment was steeped in rich lessons. The exception was that none of them ever crystallized into something I ended up shipping into the world. I simply lost interest in the tools, and they faded away within weeks or months. The pattern established the rule that building for learning never routes into shipping for use.

Read more
Journal10 min read

Why Every AI Lab Is Building Its Own GPU

Across the AI industry, labs are building custom silicon. You'll see billions spent on the design of chips, and accelerators these days are not commodity products but specialized, custom devices designed for a specific AI workload. If you were to ask me why I'm somewhat surprised, given how well NVIDIA has played this game and how much they've built out their software ecosystem, I'd say because it represents a change in how we think about AI performance today.

Read more