DIGITAL LOGS & WRITE-UPS

Step-by-step Rocket.rs walkthrough wiring Argon2 password hashing with JWT auth guards for hardened APIs.

Practical guide for rendering dynamic HTML in Axum by integrating Tera templates, context injection, and routing.

A plain-language breakdown of Rust’s immutability defaults, safety guarantees, and when mutability makes sense.

Explains lifetime annotations, the borrow checker, and how they prevent dangling references.

Demonstrates using request guards as Rocket middleware for JWT verification and request-scoped context.

Shows how to hook into Rocket fairings to log incoming requests and outgoing responses cleanly.

Explains sudo privilege tuning to allow file reads without repeated password prompts.

Checklist for resolv.conf, systemd-resolved, and network restarts when DNS breaks.

Full-stack mail server setup with Postfix, Dovecot, and TLS hardening on Devuan.

A walkthrough of debugging and fixing intermittent USB-to-Ethernet adapter disconnects on Linux, including driver updates and power checks.

Compiles and runs the first XDP hook while explaining toolchains, clang flags, and bpftool usage.

A deep dive into a subtle eBPF bug caused by struct padding and ring buffer alignment, and how to fix it.

Deep dive into kernel verifier rejection errors: understanding clang compilation flags, instruction restrictions, and debugging eBPF verification failures.

A deep dive into how XDP programs parse raw packets from ctx->data, covering Ethernet, IPv4, IPv6, and next protocol headers with practical parsing patterns.

ElfOwl a compliance system to observe network, files I/O, process and capabilities using eBPF

Using Elfowl to find process and capability privilege escaltion in pods

A deep dive into ring buffers — how this compact, lock-free data structure enables high-throughput pipelines in kernels, networking, and real-time systems.

A deep dive into XDP hook points in the Linux kernel — where packets are actually intercepted and how that shapes what your eBPF program can and can't do.

A deep dive into eBPF maps — how they let programs store and share state across kernel and userspace, and the tradeoffs between different map types.

A deep dive into the eBPF verifier — how it walks every possible path through a program, tracks register and memory state, and rejects anything it can't prove is safe before the kernel lets it run.

A deep dive into eBPF tail calls — how they let a program jump into another without returning, and how chaining them together works around the instruction-count and complexity limits the verifier imposes on any single program.

HTTP/3 is here. Google Chrome uses it for sending request to Google. Firefox and Safari have it on by default for years. Your users are already negotiating it — and failing back to HTTP/2 when your server does not speak HTTP/3.

Building Spooky — a QUIC edge proxy that accepts HTTP/3 traffic and forwards it to existing HTTP/2 backends with load balancing and health checks.

Configures a Devuan gateway VM that NATs traffic for an isolated VirtualBox lab network.

IPv6 subnets and address ranges and how it is different from IPv4

Shows dnsmasq installation, zone files, and DHCP integration for a home lab DNS.

End-to-end VyOS build steps, ISO creation, and VirtualBox deployment process.

Screenshots and commands to get core routing services configured and persisted on VyOS.

Defines host-only adapters, DHCP ranges, and VM wiring to simulate a multi-node lab.

Debugging a USB Ethernet (r8152) TX deadlock on Linux — why link-up and DHCP can lie, and how to fix it.

Setting up the Wireguard VPN between 2 Hetzner servers

Explores why QUIC chose UDP as its transport layer instead of TCP, covering head-of-line blocking, connection migration, and the performance trade-offs.

Building self-defending capabilities into Impulse — an edge proxy with brownout mode, admission control, and circuit breakers to protect backends under load.

When software can't keep up with traffic, the bottleneck isn't always threads or hot paths — sometimes it's the NIC itself. A deep dive into receive queues, RSS, RPS, and RFS and why they matter for high-throughput Linux networking.

The bottleneck in Linux networking is often the per-packet cost, not the bandwidth. A walkthrough of how GRO, GSO, TSO, and LRO reduce that cost by coalescing and segmenting at the right layer.

Installs Redis from source, configures service files, and tests connectivity.

Covers slot allocation, cluster meet commands, and testing failover locally.

Uses upstream PPAs to install KeyDB on Bookworm with systemd service tuning.

Configures KeyDB active-active replication and verifies conflict resolution.

Shows how to insert Samaritan proxy in front of KeyDB instances for load balancing.

Bootstraps control nodes and managed hosts to practice Ansible playbooks locally.

Details CouchDB repository setup, clustering enablement, and admin user creation.

Configures Nginx server blocks, DNS records, and TLS for Debian 13 hosts.

A hands-on guide to simulating controlled network flood scenarios with hping3 for defensive testing, firewall validation, and infrastructure resilience analysis

Both nftables and NeuroWall (eBPF/XDP) blocked the attack — but the cost was not the same. A real benchmark under ~128K pkt/s SYN flood reveals what enforcing the same policy at different points in the Linux packet path actually costs.