cybersecurity, in plain english

the tools that make you harder to hack.

every command from the reels, explained: what it does, why it matters, and the fix. no fluff, no gatekeeping.

andres@arch ~
the command library

every tool, one page away.

every reel, broken down: the command, the plain-english explanation, and how to defend. dual-use tools get the concept and the defense, never a download.

Privacy & tools
audit chrome extensions with <all_urls> access

shows how to find browser extensions that can read every page you visit by grepping their manifest f

audit your android phone from your laptop in 5 minutes
$ getprop ro.build.version.security_patch

this checks your android's security patch date and walks you through reviewing installed apps, their

back up your bitlocker recovery key before it locks you out
$ manage-bde -protectors -get C: -Type RecoveryPassword

this shows your bitlocker recovery password so you can save it before something like a bios update l

build a clean terminal with zsh and starship

gives the exact steps to set up a fast, themed, syntax highlighted terminal with zsh and starship.

check a suspicious link before you ever click it
$ curl -sIL <link>

this follows a link's redirects, checks domain age with whois, and resolves hosting with dig, all be

check if your VPN is leaking your DNS in 30 seconds
$ dig +short whoami.akamai.net

this reveals which DNS resolver actually answered your query, exposing whether your ISP is seeing yo

complexity rules make weaker passwords, not stronger ones
$ echo -n 'P@ssw0rd!' | wc -c; echo -n 'correct horse battery staple' | wc -c

this compares the character length of a short complex password against a long passphrase to show whi

DELETED isn't gone.
$ photorec /log /dev/sdb1

You emptied the recycle bin.

EVERY PASSWORD saved in Chrome.
concept + defense
$ python3 chrome_decrypt.py

Every password you save in Chrome can be dumped in plaintext with one command, on your own machine.

EVERYONE on your Wi-Fi.
$ nmap -sn 192.168.1.0/24

You think you know what's connected to your home wifi.

find out what's slowing your linux boot
$ systemd-analyze blame | head

this command lists which services took the longest to start during boot, ranked slowest first.

five terminal commands that feel illegal to know

teases five terminal tricks that reveal hidden system info without naming them.

google drive isn't a backup, restic is
$ restic -r b2:mybucket snapshots | tail -1

this shows the latest snapshot in a restic backup repository stored on backblaze b2.

INCOGNITO hides nothing from these 3.
$ ipconfig /displaydns | findstr Record

You browse in incognito thinking it's private.

lockdown mode: the mac setting for when it really matters
$ System Settings > Privacy & Security > Lockdown Mode

this shows how to enable lockdown mode on mac, which blocks most message attachments, link previews,

LOSE THIS USB, a thief gets nothing.
$ cryptsetup luksFormat /dev/sdb

Lose an encrypted USB stick, and a thief gets absolutely nothing.

most people don't need a vpn, check what you're actually leaking first
$ curl -s ipinfo.io | jq '{city,org}'

this pulls your public ip's city and isp/org info straight from the terminal to show what sites can

ONE PHOTO.
$ exiftool photo.jpg; reverse-image-search

Give a stranger one photo, and even with no GPS data, they can often find your neighborhood.

pihole blocks ads and trackers for every device on the network
$ docker run -d --name pihole -e TZ=UTC -p 53:53/udp -p 80:80 pihole/pihole

runs a dns server that refuses to resolve ad and tracker domains so they never load on any device wi

rclone crypt: a cloud backup the cloud can't read
$ rclone sync ~/Documents secret:

this wraps a cloud remote in an rclone crypt layer so file names and contents are encrypted before t

see which of your apps phone home, for free
$ brew install --cask lulu

installs a free outbound firewall that alerts you every time an app tries to connect to the internet

self-host github with forgejo for $0 in one container
$ docker run -d --name forgejo -p 3000:3000 codeberg.org/forgejo/forgejo:latest

spins up a self-hosted git server you fully control, with registration disabled and access locked to

self-host Paperless-ngx: turn paper into a searchable, private archive
$ docker compose up -d

this runs paperless-ngx in docker so scanned documents dropped into a consume folder get ocr'd, date

self-host your photo library with Immich
$ docker compose up -d

this spins up Immich, a self-hosted Google Photos alternative, on your own hardware for phone backup

Syncthing: your own Dropbox with no cloud in the middle
$ docker run syncthing/syncthing

this shows how to self host Syncthing in Docker to sync files directly between your own devices, enc

THAT ISP BOX is a full Linux computer.
$ ssh admin@192.168.1.1

That box your internet provider gave you?

THAT OLD LAPTOP is a home server.
$ curl -fsSL get.docker.com | sh && docker ps

Don't throw out that old laptop in your drawer.

THIS LOGIN PAGE is fake.
$ read-the-domain right-to-left

This login page looks real.

Vaultwarden self hosts your own Bitwarden vault
$ docker compose up -d

shows how to run vaultwarden in docker so your password vault lives on your own hardware instead of

why a windows hello pin beats your password

this explains that a windows hello pin, biometric, or passkey is tied to one device and cannot be ph

wipe a drive properly before you sell it
$ shred -v -n 1 -z

this shows how to securely erase an hdd or ssd before selling or disposing of a drive, using shred f

your encrypted mac means nothing if the backup drive isn't
$ tmutil destinationinfo

this checks which drive your time machine backups are going to, then diskutil info reveals if fileva

your laptop // remembers everywhere you've been
$ netsh wlan show profiles

Your laptop keeps a list of every wifi network it has ever joined, the coffee shop, the airport, the

your linux distro matters less than reddit thinks
$ grep ^ID= /etc/os-release

this command quickly shows which linux distribution you're running by reading the os-release file

YOUR PASSWORD is probably already leaked.
$ curl https://api.pwnedpasswords.com/range/21BD1

There's a good chance your password is already for sale online.

your pc // knows every wifi password
concept + defense
$ netsh wlan show profile name="HomeNet" key=clear | findstr Key

Your computer remembers every wifi password you've ever typed, in plaintext, one command away.

YOUR PHOTOS know exactly where you were.
$ exiftool IMG_4471.jpg | grep -i gps

Every photo you post might be telling strangers exactly where you live.

your public ip is not anonymous
$ curl -s ipinfo.io | jq '{city,region,org}'

this command queries an ip info service and prints your public ip's city, region, and hosting org.

YOUR SMART TV is watching you back.
$ tshark -i eth0 -f 'host 192.168.1.22'

Your smart TV is sending data out constantly, even when you're not watching.

Digital forensics
a first pass DFIR triage flow using free tools
$ sha256sum evidence.img

chains sha256sum, mmls, fls, icat, exiftool, volatility, and strings to start a disk and memory inve

a word macro claimed harmless, olevba proved otherwise
$ olevba invoice.docm

shows how to statically analyze an office macro to reveal an autoopen downloader and decode its base

amcache proves a deleted exe once existed
$ AmcacheParser.exe -f C:\Windows\AppCompat\Programs\Amcache.hve --csv .

parses the windows amcache hive with amcacheparser to recover the name, hash, and first-seen time of

autoruns, catching malware hiding in startup items
$ autorunsc.exe -a * -h -c -nobanner > autoruns.csv

uses autoruns to list every persistence point on a system then filters out microsoft signed entries

build a super timeline with The Sleuth Kit
$ fls -m / disk.img > body; mactime -b body > timeline.csv

shows how to use fls and mactime to turn disk artifacts into a readable, court grade incident timeli

capa reveals malware capabilities without running it
$ capa suspicious.exe

shows how capa statically analyzes a suspicious binary and maps its capabilities to mitre attack tec

catch data exfiltration hiding in your traffic

it explains how to spot data theft through large outbound transfers, dns tunneling, and cloud upload

container compromised? your first 5 commands
$ docker commit

this shows the first five docker commands to run when a container is compromised, in order to inspec

count failed ssh logins hiding in auth.log
$ grep -c 'Failed password' /var/log/auth.log

this command counts how many failed ssh password attempts are recorded in your linux auth log

cron persistence hides in six spots, check them all
$ for u in $(cut -f1 -d: /etc/passwd); do crontab -l -u $u 2>/dev/null; done

shows how to hunt every linux cron location, including per user crontabs and dot file jobs, for hidd

deleted files leave a receipt in the ntfs mft
$ MFTECmd.exe -f C:\$MFT --csv C:\out

it shows how the master file table keeps deleted file records and timestamp mismatches that reveal w

dns exfiltration, the tunnel nobody watches
$ tshark -r cap.pcap -Y 'dns.qry.type==16' -T fields -e dns.qry.name

it shows how attackers hide stolen data in dns txt queries and how to spot the abnormal volume of lo

emptying the recycle bin doesn't actually delete anything
$ dir C:\$Recycle.Bin -Force -Recurse | select Name -First 2

this command lists the hidden contents still sitting inside windows' recycle bin folder even after y

find recently modified files after an incident
$ find /etc /usr/bin -mtime -1 -type f 2>/dev/null

this lists files in /etc and /usr/bin that were modified in the last day

finding malware hiding inside a trusted process's memory
$ vol -f mem.raw windows.malfind

this uses volatility's malfind to spot injected code in a memory dump by flagging private, writable,

five windows event ids that tell the whole incident

it explains how event ids for failed logons, process creation, new accounts, and cleared logs reveal

honeypot fired, do this before you isolate anything
$ ss -tnp

checks live connections, recent logins, and attacker traffic first so you understand the intrusion b

hunt attacker persistence before they come back tomorrow

covers the windows and linux spots attackers plant persistence and how comparing to a known good bas

hunt systemd persistence hiding as a fake service
$ systemctl list-unit-files --type=service --state=enabled

shows how attackers hide persistence in systemd services and how to spot and inspect a malicious one

hunting web shells on your own server
$ find /var/www -name '*.php' -mtime -7

this shows how to spot recently modified php files, uploads-folder scripts, and suspicious eval or b

jump lists remember more than the user does
$ JLECmd.exe -d "C:\Users\<u>\...\AutomaticDestinations" --csv .

it parses windows jump list files to tie a program to the exact files, shares, and usb drives it ope

linux log triage, the logs told you first

walks through checking linux auth logs for failed then successful logins, new users, sudo abuse, and

live response on linux, capture before you reboot
$ ps

it walks through checking processes, sockets, deleted binaries, logins, and persistence on a live li

lsof: see every live network connection on a linux box
$ lsof -i -nP | grep ESTABLISHED | head

this lists all currently open files and, with the -i flag, every established network connection on t

memory forensics with Volatility 3
$ vol.py -f memory.img windows.pslist

uses volatility 3 modules like pslist, netscan, malfind, and cmdline to find hidden processes, conne

osquery turns any os into a sql database for threat hunting
$ osqueryi "SELECT name,path,pid FROM processes WHERE on_disk=0;"

shows how osquery finds processes running from deleted binaries, a classic self delete trick, across

phishing forensics, read headers before you click

it explains how to trace received headers, check spf dkim dmarc, and safely detonate urls and attach

powershell history file exposes every command typed
$ gc "$env:APPDATA\Microsoft\Windows\PowerShell\PSReadLine\ConsoleHost_history.txt"

reads the psreadline history file to reveal every powershell command a user typed, including downloa

prefetch proves the file was opened, three times
$ PECmd.exe -f C:\Windows\Prefetch\INVOICE.EXE-A1B2C3D4.pf

this shows how parsing a windows prefetch file reveals run count, last run time, and the folder an e

ransomware first response, contain before you touch anything

it explains why you should isolate the host, find patient zero, and capture memory before rebooting

reading email headers exposes a phishing attempt
$ grep -iE '^(from|return-path|reply-to)' phish.eml

shows checking email headers, spf, dkim, dmarc, and domain age to spot a spoofed phishing email.

reconstruct what someone did from their browser data

explains how browser history, cache, cookies and sqlite files can be used to reconstruct a user's se

replay every login on a linux box with last
$ last -5

the last command shows a history of user logins, including who logged in, from where, and when.

see how much your shell secretly remembers
$ wc -l ~/.bash_history

this counts how many commands are stored in plaintext inside your bash history file

shellbags prove what folders someone browsed
$ SBECmd.exe -d C:\Users\<user>\...\UsrClass.dat --csv .

parses windows shellbags to show folder paths and timestamps that survive even after the drive or us

shimcache proves a file existed, not that it ran
$ AppCompatCacheParser.exe --csv . -c 1

it explains how shimcache records paths and timestamps of executables windows has seen, which is use

spot a backdoor suid binary by comparing timestamps
$ find / -perm -4000 -type f -newer /etc/hostname 2>/dev/null

shows how to find a planted suid root binary by listing suid files newer than the original system in

srum logs 30 to 60 days of per app network usage on windows
$ SrumECmd.exe -f C:\Windows\System32\sru\SRUDB.dat --csv .

it parses the srum database to reveal which process sent the most bytes without needing a packet cap

strings before you reverse: spot hidden urls and secrets fast
$ strings -n 8 ./suspicious.bin | grep -iE 'http|key|pass'

this scans a binary for readable text strings at least 8 characters long and filters for urls, keys,

the usn journal logs every ntfs file change
$ MFTECmd.exe -f "C:\$Extend\$J" --csv .

parses the ntfs usn journal to reveal file creations, renames, and deletions an attacker tried to hi

threat hunting a pcap with tshark

uses tshark to spot top talkers, dga beacons, suspicious user agents, and stream contents inside a p

three windows artifacts that prove a USB was plugged in
$ reg query HKLM\SYSTEM\CurrentControlSet\Enum\USBSTOR /s

shows how usbstor, setupapi.dev.log, and portable devices registry keys corroborate that a specific

triage a suspicious file safely, never execute it
$ file

it walks through hashing, string extraction, and file type checks before ever detonating a suspiciou

triage web attacks in your access.log in 5 minutes
$ grep -E '\.\./|union select|<script>' access.log

this shows how to spot suspicious ip's, 404 scanning patterns, and injection attempts in web server

userassist registry key proves what a user launched
$ reg query "HKCU\...\Explorer\UserAssist\{CEBFF5CD-...}\Count"

queries the userassist registry key to reveal every gui launched program with its run count and last

velociraptor answers how many machines are infected
$ velociraptor query "SELECT Name,Pid,Exe FROM pslist() WHERE Exe =~ 'Temp'"

queries endpoints like a database and dispatches a hunt to scope an entire breach across all machine

windows // knows every file you opened
$ reg query "HKCU\...\Explorer\RecentDocs" /s | findstr /i .docx

Windows keeps a running list of the files you've recently opened, sorted by type, in a registry key

windows jump lists remember more than you think
$ dir $env:APPDATA\Microsoft\Windows\Recent\AutomaticDestinations

this command lists the AutomaticDestinations folder where windows stores jump list files tied to rec

windows prefetch: proof apps ran, even after deletion
$ (dir C:\Windows\Prefetch\*.pf).Count

counts the .pf files in the windows prefetch folder, which windows creates to help apps launch faste

windows registry artifacts every investigator checks

lists key windows registry locations like run keys, usbstor, shimcache and recentdocs used to recons

windows remembers every usb drive you've ever plugged in
$ reg query HKLM\SYSTEM\CurrentControlSet\Enum\USBSTOR /s | findstr FriendlyName

this command pulls the make, model, and serial number of every usb storage device windows has ever s

wtmp and btmp reveal every login and every failed attempt
$ last -f /var/log/wtmp -i

shows how reading linux login success and failure logs together can reveal a brute force attack that

yara: write one rule, scan a file or a whole host

explains how to write a yara rule with strings and conditions to scan a file or directory for known

your mac // logs everything you do
$ log show --last 1h --predicate 'eventMessage CONTAINS "LAUNCH"' | tail -3

macOS keeps a unified log of almost everything that happens on your machine, including every single

Attack paths
a fast, repeatable recon flow in Kali Linux
$ nmap -sn

runs a recon sequence with nmap, whatweb and searchsploit to map live hosts, services and known issu

a jwt with alg none tricked the server into admin access
$ jwt.decode(tok, key, options={'verify_signature': False})

shows how trusting a jwt's own header let an attacker forge admin rights, and how pinning the algori

a single quote becomes admin access via sql injection
$ sqlmap -u https://site/login --form

shows how unparameterized queries allow sql injection and how parameterized queries fix it.

arp spoofing, become the gateway and the victim

shows how arp has no authentication so an attacker can spoof both sides of a connection to intercept

bloodhound maps the shortest path to domain admin
$ bloodhound-python -d corp.local -u user -p pass -c all -ns 10.0.0.10

collects active directory users, groups, and permissions to reveal attack paths to domain admins.

build a safe hacking lab with kali and virtualbox

sets up an isolated virtualbox lab with kali linux and a vulnerable target so you can practice attac

burp suite for web app testing, the practical version

it shows how to use burp's proxy, repeater, intruder, and scanner to find logic flaws and injection

crack passwords with hashcat masks and hybrid attacks
$ hashcat -m 1000 hashes -a 3 '?u?l?l?l?l?d?d?d' --increment

demonstrates mask and hybrid hashcat attacks that target predictable human password patterns instead

docker group membership is basically root
concept + defense
$ id

checks which groups your user belongs to, including whether you're in the docker group

domain admin plus one command dumps every hash in the domain
$ impacket-secretsdump corp.local/admin:'Pass'@10.0.0.10 -just-dc

shows how a domain admin credential lets an attacker pull every hash including krbtgt from a domain

enumeration is where engagements are actually won
$ nmap --script vuln

uses nmap, enum4linux, gobuster, and nikto to enumerate a target and reveal the foothold before expl

evil-winrm turns stolen creds into a full shell
$ evil-winrm -i 10.0.0.20 -u administrator -p 'Summer2026!'

shows using evil-winrm with valid windows credentials to get an interactive shell over winrm.

exposed .env in web root leaks every secret you own
$ curl -s -o /dev/null -w '%{http_code}' https://site/.env

it demonstrates how a publicly reachable .env file leaks credentials and how to verify and lock it d

exposed .git folders leak your entire source code
$ git-dumper https://site/.git/ loot/

shows how an exposed git folder on a web server lets anyone rebuild the full source and commit histo

ffuf brute forces hidden paths and apis
$ ffuf -u https://target/FUZZ -w raft-medium.txt -mc 200,301,403 -c

shows using ffuf to discover hidden directories, backup folders, and apis on a target site.

find linux capabilities with getcap
concept + defense
$ getcap -r / 2>/dev/null

this scans the filesystem for files that have linux capabilities assigned instead of full root permi

find sudo rules that let you run as root, no password
concept + defense
$ sudo -l

lists the commands your account is allowed to run with sudo, including any that need no password

gtfobins turns an allowed sudo rule into full root
$ sudo tar -cf /dev/null /dev/null --checkpoint=1 --checkpoint-action=exec=/bin/sh

this shows how a misconfigured sudo permission on a normal binary like tar can be abused to spawn a

how a wifi network actually gets cracked

walks through monitor mode, handshake capture, and offline wordlist attacks to show why a long rando

idor: one changed digit exposes someone else's invoice
$ inv = get_object_or_404(Invoice, id=request.GET['id'], user=request.user)

shows how insecure direct object references leak data and how scoping the query to the logged in use

journey // one port to shell
$ nmap -sV -p- target -T4 | grep open

One forgotten open port is often the whole game.

journey // user to root
$ whoami

Watch a normal user become root.

kali doesn't make you a hacker
$ apt list --installed 2>/dev/null | wc -l

this counts how many packages are installed on your linux system.

kerberoasting, any domain user can crack a service account
$ impacket-GetUserSPNs corp.local/user:pass -request -dc-ip 10.0.0.10

requests a kerberos service ticket for a service account and cracks the hash offline to potentially

kerbrute enumerates AD usernames without alerts
$ kerbrute userenum -d corp.local --dc 10.0.0.10 users.txt

uses kerbrute to enumerate valid active directory accounts and spray passwords without tripping fail

level up your wordlists past rockyou
$ cewl <target-url>

recommends seclists, cewl, and crunch as better password wordlist sources than relying on rockyou al

linpeas scans a low priv shell for near certain privesc wins
$ curl -sL https://github.com/.../linpeas.sh | sh | tee peas.txt

this runs linpeas to color-code privilege escalation paths and shows using a flagged sudo rule to ge

low priv shell to root, the usual privesc path
$ sudo -l

it walks through checking sudo rights, suid binaries, and writable cron jobs to escalate from a low

mass assignment bug lets users grant themselves admin
$ user.update(**request.json)

shows how sending an extra role field the form never had let an attacker escalate to admin through m

mine certificate transparency logs for hidden subdomains
concept + defense
$ curl -s 'https://crt.sh/?q=example.com&output=json' | jq -r '.[].name_value' | sort -u | head

this pulls every publicly logged ssl certificate for a domain and lists the unique hostnames found i

nmap scan types decoded, stealth versus speed versus depth
$ nmap -sS

this breaks down nmap's syn, connect, udp, version, and script scan modes and when to use each.

one script tag in a search box can steal the session cookie
$ return render_template('search.html', q=q)

it demonstrates how unescaped user input causes xss and how templating plus a content security polic

online vs offline password attacks, know the difference

it compares hydra, hashcat, john, and password spraying to explain when each password attack techniq

passive recon first, active recon only when ready

explains the difference between passive recon tools like whois, dns, and theharvester versus active

path traversal hands over every file on the server

shows how an unsanitized file path lets an attacker read arbitrary files and how resolving and check

pivoting, own one box and reach the hidden subnet
$ ssh -D 1080 user@target

explains using ssh dynamic tunnels, proxychains, and chisel or ligolo to pivot tools like nmap and m

privilege escalation via writable cron jobs
concept + defense
$ ls -l /etc/cron.d/backup

checks the permissions on a cron job file to see if it's writable by a low privileged user

pspy spots root cron jobs for Linux privesc
$ ./pspy64

shows how pspy watches running processes without root to reveal a writable root cron job you can exp

responder turns a windows name lookup into a stolen hash
$ responder -I eth0 -wv

shows how responder answers LLMNR/NBT-NS broadcasts to capture an NTLMv2 hash that can then be crack

reverse shells beat firewalls by calling home instead

it explains why a reverse shell that makes the victim connect outbound gets past firewalls that bloc

score // how crackable is it
$ hashcat -b -m 1000 | grep Speed

Password strength isn't a vibe, it's math: the character set raised to the length.

sqli, xss, lfi, one root cause, trusting input

breaks down three classic web vulnerabilities that all stem from trusting unvalidated user input

SSRF turns a url fetch into AWS credentials
$ aws ec2 modify-instance-metadata-options --http-tokens required

shows how an unrestricted url fetch lets an attacker steal aws credentials from cloud metadata and h

the ad certificate services misconfig nobody audits
$ certipy find -u user@corp.local -p pass -dc-ip x -vulnerable -stdout

this shows using certipy to find and abuse a vulnerable ad cs template, esc1, to request a certifica

the metasploit workflow from module to shell
$ msfconsole

this walks through picking a metasploit module, setting a payload, and catching a reverse shell sess

the path from ordinary domain user to domain admin
$ BloodHound

this walks through how bloodhound mapping plus kerberoasting a weak service account leads to full do

the post exploitation loop after landing a shell

it walks through the recon, escalate, persist, pivot, loot cycle attackers use after gaining initial

unrestricted file upload leads to remote code execution
$ f.save(f'/var/www/app/uploads/{f.filename}')

shows how trusting a filename and extension during file upload let an attacker run commands as www-d

WATCH A WI-FI PASSWORD get cracked.
concept + defense
$ aircrack-ng -w rockyou.txt capture.cap

This is how a wifi password actually gets cracked.

what attackers read about you before they ever attack

it explains how subdomains, breach databases, employee names, and document metadata give attackers e

wifite automates the entire wifi attack
$ wifite --kill

shows wifite automatically scanning, capturing, and cracking wifi networks in one command.

wildcard tar in root cron = privilege escalation
concept + defense
$ crontab -l | tail -1

shows the last root cron job, which often reveals a tar command using a wildcard.

winPEAS finds the path from low priv shell to system

shows using winPEAS to find windows misconfigurations like unquoted service paths to escalate to sys

Harden & defend
4 built-in windows 11 settings that actually protect you

turns on bitlocker, controlled folder access, firewall, and removes smbv1 on windows 11

a honeypot means any hit is a real alert

sets up a fake service with opencanary on an unused port so attackers reveal themselves with zero fa

apparmor traps a compromised app inside its own permissions
$ aa-status aa-enforce /etc/apparmor.d/usr.sbin.nginx

it confines a linux program to only the files and capabilities it needs so an exploit can't spread b

audit your dependencies before attackers do
$ npm audit --omit=dev

this scans your project's dependencies for known vulnerabilities, ranks them by severity, and can au

auditd: linux's built in who did what audit log
$ auditctl -w /etc/passwd -p wa -k identity

sets up linux auditd rules to watch sensitive files and log command execution before an incident hap

caddy gets you free https in three lines
$ systemctl reload caddy

it shows how a simple caddyfile config automatically fetches and renews a let's encrypt cert while r

catch lookalike phishing domains before attackers use them
$ dnstwist --registered nimbus.shop

it shows how dnstwist finds registered lookalike domains of your own so you can spot phishing setups

check if RDP is wide open to the internet
$ Get-NetTCPConnection -LocalPort 3389

this checks the registry, local port, and public ip to see if remote desktop is listening and reacha

check if your drive is dying with smartctl
$ smartctl -H

this checks your drive's SMART health status and key failure indicators like reallocated, pending, a

chmod 777 isn't a fix, it's removing the lock
$ chmod 777 /var/www/uploads

it grants full read write and execute permissions to every user and process on that directory.

crowdsec blocks attackers before they reach you
$ cscli decisions list

installs crowdsec with a firewall bouncer to read logs, detect attacks, and share bans across the co

default deny nftables firewall every server needs

sets up a default deny nftables policy that only allows established sessions, loopback, ssh, and icm

docker silently punches holes through ufw
$ ufw-docker

this shows why docker's own iptables rules bypass ufw and how to fix it with the ufw-docker helper o

every open port is a door, find your listeners
$ ss -tulpn | grep LISTEN

this command lists every process on your machine that is actively listening for network connections,

fail2ban auto bans brute forcers, set it up right
$ systemctl restart fail2ban

it walks through configuring ban time, retry limits, and whitelists so fail2ban blocks brute force a

five baseline checks every mac should pass
$ fdesetup status; spctl --status; socketfilterfw --getglobalstate; socketfilterfw --setglobalstate on; csrutil status

this checks filevault, gatekeeper, firewall, and sip status, and turns the firewall on if it's off

five postgres settings that stop easy breaches

lists five postgresql configuration changes, like binding to localhost and enforcing scram auth, tha

five settings to harden any nginx server

lists five nginx configuration changes, like enforcing modern tls and hiding server tokens, to harde

four boring settings that stop most linux compromises

it lists automatic patching, a default deny firewall, audit logging, and fail2ban as a basic linux h

free tls the right way, cert, redirect, hsts, and a plus rating
$ certbot --nginx

this walks through issuing a free certbot certificate, auto renewal, forcing https, hsts, and testin

get free phone alerts from any script with ntfy
$ curl -d 'message' ntfy.sh/your-topic

this sends a push notification to your phone from any script or server using the free ntfy service

grade your SSH server config in 30 seconds
$ ssh-audit <server>

scans an ssh server and marks every algorithm as fail, warn, or good so you can see weak crypto at a

is antivirus even worth it on a linux server?
$ clamscan -r -i /home

recursively scans the /home directory and only prints infected files, using clamav on a linux box

keep a popped container from becoming a popped host
$ trivy

this covers running containers as a non-root user, dropping capabilities, read-only filesystems, and

linux hardening beyond the baseline
$ ufw limit ssh

walks through moving ssh off port 22, rate limiting, kernel sysctl hardening, crowdsec bans, and app

lock down a fresh linux box with three ufw commands
$ ufw default deny incoming && ufw allow OpenSSH && ufw enable

this sets ufw to block all incoming traffic by default, allows ssh access, then turns the firewall o

lock down every raspberry pi before first boot
$ ss -tlnp

this checks which services are listening on the network and walks through five quick hardening steps

lock down redis and database ports before shodan finds them
$ ss -tlnp

shows you which database ports like 6379, 27017, 5432, 3306, and 9200 are listening on 0.0.0.0 inste

lynis, one command to score your linux hardening
$ lynis audit system

runs lynis to audit a linux system and produce a hardening index with a ranked to-do list of fixes.

moving ssh off port 22 is not real security
$ nmap -p- --open localhost | grep ssh

this command scans every port on your own machine and filters for anything running ssh, showing that

nist says stop forcing password rotation
$ grep PASS_MAX_DAYS /etc/login.defs

checks how many days a linux system allows before forcing a password change

one backup means zero backups
$ restic snapshots | tail -1

this shows the most recent snapshot in your restic backup repository so you can confirm it actually

one front door: Authelia SSO + 2FA for every self-hosted app
$ default_policy: deny

shows how to run Authelia in docker and force two factor auth across your whole domain via your reve

one good sigma rule beats an expensive security tool

it explains how describing an attacker technique once in sigma and converting it to your siem's quer

one hardened front door with nginx and a waf

puts nginx in front of apps to terminate tls, load balance, filter attacks with a waf, and add secur

open sketchy attachments safely with windows sandbox
$ Enable-WindowsOptionalFeature -FeatureName Containers-DisposableClientVM

this enables windows sandbox, a disposable, isolated desktop built into windows pro and enterprise f

proxmox host baseline: lock down the thing running every vm you own

this sets up a named admin user with pveadmin role, totp 2fa, lan or vpn only web ui access, and sch

reveal // what a firewall is
$ iptables -L INPUT -n --line-numbers

A firewall sounds like a fortress.

reveal what a server confesses in its http headers
$ curl -sI https://example.com | grep -iE 'server|x-powered|set-cookie'

this pulls the http response headers from a site and filters for server, x-powered-by, and cookie de

rkhunter hunts rootkit fingerprints on linux
$ rkhunter --check --sk --rwo

it shows how rkhunter baselines clean binaries and then flags hidden directories or modified system

safe auto updates that patch without breaking production
$ unattended-upgrades

describes limiting automatic updates to security patches only, excluding fragile packages, kernel li

score // can they spoof your email
$ dig +short TXT yourdomain.com | grep spf

Can a stranger send email that looks like it came from your domain?

score // your website's headers
$ curl -sI https://yoursite.com | grep -iE 'strict|content-sec|frame'

One curl grades your website's security posture.

see everything your server does, live, for $0 with netdata
$ docker run -d --name=netdata netdata/netdata

this spins up netdata in a container to show per-second cpu, disk, network, and process metrics with

sign git commits with your ssh key, no gpg needed
$ git config --global gpg.format ssh

this configures git to sign your commits using an ssh key instead of gpg, so github marks them as ve

skip ufw, go straight to nftables
$ nft list ruleset | head -4

this shows the raw nftables ruleset instead of relying on ufw's simplified frontend

ssh certificates replace authorized_keys sprawl
$ ssh-keygen -s ca_key -I andres -n andres -V +8h user_key.pub

signs a short lived ssh certificate so servers trust one CA instead of scattered keys.

stop reaching for sudo su
$ sudo su

this command drops you into a full root shell instead of running a single privileged command

sysmon plus sigma is how a soc scales detection

it shows how logging process creation with sysmon and writing vendor neutral sigma rules lets one de

ten sysctl lines that harden a linux kernel for good
$ sysctl --system

shows a small set of kernel parameters that block syn floods, icmp redirect mitm, and expose less ke

the bastion host, one hardened door in
$ ssh -J bastion internal-host

lists the checklist for building a hardened bastion host with keys only, proxyjump, session logging,

the github security baseline you actually need
$ gh api user --jq .two_factor_authentication

this checks whether 2fa is enabled on your github account and lists the baseline steps to lock down

the linux laptop security baseline you actually need
$ sudo ufw enable

this checks disk encryption with lsblk, turns on the firewall, enables auto screen lock, and patches

the NAS hardening baseline everyone should ship with

this walks through closing FTP, killing vendor remote-access relays and UPnP, disabling default admi

the raw numbers behind why ssh keeps getting brute forced
$ grep 'Failed password' auth.log

this uses log grepping and shodan data to show how many bots hit exposed ssh servers and why keys be

the ssh baseline that kills the most common internet attack
$ PasswordAuthentication no

this lays out five sshd config lines, keys only, no root login, allowed users, that stop brute force

the wordpress security baseline everyone skips
$ wp core verify-checksums

this checks for tampered core files, lists outdated plugins, finds unknown admins, locks the dashboa

three DNS records that stop email spoofing

explains how spf, dkim and dmarc records together stop attackers from spoofing your domain in email.

Uptime Kuma: free self-hosted uptime monitoring and alerts

this shows how to run Uptime Kuma in Docker to monitor ping, HTTP, ports, and TLS expiry, then push

vlan segmentation, contain the blast radius

explains splitting users, servers, iot, and guests into separate vlans with acl controlled routing s

who's an admin on your windows pc? check in 1 minute
$ net localgroup administrators

this shows which accounts have admin rights on a windows pc, then helps you trim unused ones and rem

your ipv6 traffic is bypassing your firewall rules
$ ip6tables

this explains how to check what is listening on ipv6 and mirror your ipv4 firewall policy with ip6ta

Networking
802.1x on a cisco switch with ise end to end
$ dot1x system-auth-control

configures radius, aaa, and dot1x on a cisco switch so ise enforces identity on each port with mab a

802.1x with ise, who really decides network access

walks through the 802.1x nac flow where the switch just enforces while ise makes the actual access v

asa security levels, the number that runs the firewall

explains how cisco asa interface trust levels from 0 to 100 decide which traffic flows freely and wh

cisco asa firewall basics, security levels and nat

breaks down asa interface configuration with nameif, security level, ip, nat, and a default route to

Cisco ASA vs FTD, two firewalls, two jobs

compares asa's classic vpn focused firewall os to ftd's snort 3 based ngfw and explains why new depl

cisco native vlan mismatch enables vlan hopping

shows how mismatched native vlans between trunk ends leak untagged frames and open vlan hopping atta

Cisco SSH setup steps everyone forgets
$ crypto key generate rsa modulus 2048

walks through configuring ssh on a cisco device with rsa keys, local users, and vty restrictions ins

cisco's zone based firewall, built into ios

it shows how zones, class maps, and policy maps let ios routers statefully inspect and filter traffi

dns records leak your whole org's footprint
$ dig +short MX example.com; dig +short TXT example.com | head -2

this pulls a domain's mail server and text records straight from public dns.

ebgp peering, simpler than it sounds
$ show ip bgp summary

walks through configuring an external bgp neighbor and confirming the session is up by checking rece

EtherChannel with LACP, one logical link from many
$ show etherchannel summary

bundles multiple switch links into one port channel using lacp for more bandwidth and failover resil

expose a homelab service with zero open ports using cloudflare tunnel
$ cloudflared tunnel run --url http://localhost:8080 homelab

this creates an outbound-only tunnel that publishes a local service to a domain without opening any

five checks for why a ping fails on Cisco gear
$ show ip interface brief

walks through interface status, vlan membership, mac table, trunk allowed vlans, and routing to trou

HSRP failover keeps hosts online when a router dies

explains how hsrp lets two routers share a virtual gateway ip so hosts never notice a router failure

hsrp gives two routers one shared virtual gateway ip
$ standby 1 ip

explains how hsrp priority, preempt, and interface tracking let a standby router silently take over

IKEv2 site to site VPN, the best practice config

walks through building an ikev2 lan to lan vpn on cisco asa with strong crypto instead of legacy ike

inter-vlan routing on a layer 3 switch, explained

this covers how per-vlan svis let a layer 3 switch route between subnets in hardware, replacing rout

IOS-XE looks like classic IOS but runs on Linux underneath

explains how IOS-XE modernizes Cisco devices with isolated Linux processes, install versus bundle mo

journey // is your guest wifi real
$ ip route | grep default

Your guest wifi is only isolated if it's actually configured to be.

layer 2 hardening, diagram then config

walks through configuring port security, dhcp snooping, and dynamic arp inspection to stop layer 2 a

layer 2 hardening, port security, dhcp snooping, arp inspection

shows how port security, dhcp snooping, and dynamic arp inspection lock down layer 2 switchports.

layer 3 switch routing between vlans with SVIs
$ ip routing

shows how a layer 3 switch uses svis and ip routing to route between vlans at line rate instead of r

lock a switch port to one device with port security
$ switchport port-security switchport port-security maximum 1 switchport port-security mac-address sticky switchport port-

it configures a switch port to learn one sticky mac address and shut down if any other device connec

nat overload, one address for a whole network
$ ip nat inside source list 1 interface Gi0/0 overload

it shows how pat maps an entire private network onto one public ip using port numbers.

NAT overload, PAT explained with config
$ show ip nat translations

configures nat overload so many private lan addresses share one public ip via port multiplexing

opnsense: count your active block rules fast
$ pfctl -s rules | grep -c block

this command lists the firewall's active pf rules and counts how many are set to block traffic.

ospf areas explained, from backbone to abr

it explains how ospf uses area 0 as the backbone and abrs to summarize routes so big networks conver

OSPF multi area routing, the core commands
$ show ip ospf neighbor

sets up ospf with a router id, area assignments, passive interfaces, and checks neighbor state to ve

point Cisco ASA at ISE for RADIUS with CoA support
$ test aaa-server

configures an asa to use ise for radius authentication with change of authorization and shows testin

replace Telnet with SSH on a Cisco router in six lines
$ transport input ssh

configures ssh access on a router and disables telnet so router management traffic is encrypted inst

reveal // how dns works
$ dig +short example.com

DNS is a phonebook that turns names into addresses.

reveal // https in one look
$ openssl s_client -connect example.com:443 </dev/null 2>/dev/null | head

HTTPS feels like magic, but you can watch the whole thing.

reveal // the 13 root servers
$ dig . NS +short

Every name lookup on the internet ultimately starts in one place: the DNS root.

reveal // your mac address leaks
$ ip link show wlan0 | grep ether

Every network device has a MAC address, and the first half of it isn't random, it's the OUI, a regis

see every device on your wifi with ARP
$ arp -a

lists the devices your machine has talked to on the local network along with their IP and MAC addres

site to site IPsec, build the tunnel step by step

it explains how IKE phase 1 and phase 2 with ESP link two private LANs over the internet as one netw

tailscale, zero config vpn in four commands
$ tailscale up

shows how tailscale authenticates in the browser and builds a private wireguard mesh with peer to pe

the cisco device hardening baseline every router should ship with
$ transport input ssh

this lists six ios config steps, real credentials, ssh only, aaa, login throttling, and encrypted pa

the classic 3 leg DMZ firewall design

explains how a firewall separates internet, dmz, and inside zones so a compromised public server sta

the clean baseline config every switch needs first

it lists the CCNA level starting configuration for a switch including hostname, vlans, trunking, and

the vtp misconfig that can wipe every vlan on your network
$ vtp mode transparent

this explains how a switch with a higher vtp revision number can silently overwrite everyone's vlans

three commands that harden spanning tree
$ spanning-tree bpduguard enable

it shows how portfast, bpduguard, and root guard close off common layer 2 attack paths on switches.

traceroute: see how few hops separate you from anywhere
$ traceroute -n 1.1.1.1 | tail -n +2 | head -6

this prints the first few network hops your traffic takes on its way to 1.1.1.1, skipping the header

two cisco features that kill lan man in the middle attacks

explains how dhcp snooping and dynamic arp inspection stop rogue dhcp servers and arp spoofing on a

two thirds of web traffic already post quantum encrypted

reveals that most browsers have quietly switched to hybrid ml-kem post quantum encryption ahead of l

vlans and trunking explained, then configured

shows how access ports carry one untagged vlan while trunk ports carry many vlans tagged with 802.1q

vrf, one router, many isolated routing tables
$ vrf definition RED

demonstrates how a vrf lets one physical router keep separate routing tables so segments can't reach

wireguard vpn, key pair to handshake in six steps
$ wg genkey | wg pubkey

walks through building a wireguard vpn tunnel from generating keys to confirming the handshake

YOUR HOME network, from anywhere.
$ tailscale up

Reach every device in your house from anywhere in the world, with no port forwarding and no static I

Cloud & AWS
AI & security
the weekly drop

one command a week that makes you harder to hack.

a single tool, explained in plain english, every week. straight to your inbox.

no spam. one email a week. unsubscribe anytime.