Personal security notes

Managing Risk in My Digital Life

Not a universal privacy manifesto or a claim that my setup is bulletproof, just a living record of how I protect my accounts, devices, and personal data, and the trade-offs behind those choices.

Living document

These notes reflect my personal practices and threat model. They are not published on behalf of any current or former employer and do not represent their positions.

A setup I can actually maintain

Most of my digital life runs through Apple hardware and services, alongside a Windows installation, a dedicated x86 Linux machine, and a handful of single-purpose tools. My goal isn't maximum complexity. Security and privacy aren't a game of collecting the most esoteric tools or blindly following an ideology; every extra app, browser extension, sync daemon, and recovery key is another dependency that has to be understood, maintained, and trusted not to break when I actually need it.

I build around a few practical rules: minimize unnecessary exposure, isolate high-impact components where the friction is worth it, avoid single points of failure, and never make recovery entirely dependent on the same ecosystem I am trying to recover. Where native OS tooling is architecturally sound, I use it. Where compartmentalization buys real risk reduction, like separating TOTP seeds from passwords, I take on the extra maintenance.

What I trust, and why

Modern computing always involves delegated trust. Saying "I trust this company" is a trap. Executives, incentives, and business models change. Instead, I look at what technical guarantees exist, what data a service actually needs to function, whether the architecture is documented or independently audited, and how badly it hurts if that provider fails.

Why I anchor on Apple

I rely heavily on Apple for hardware security, password management, passkeys, encrypted storage, and core account infrastructure. That is a massive concentration of trust, and I don't pretend otherwise.

My preference isn't based on privacy billboards; it comes down to documented architecture and attack-surface reduction. Dedicated hardware like the Secure Enclave isolates cryptographic material from the main operating system kernel. Because much of Apple's stack is closed-source, their Platform Security guide isn't a substitute for independent source auditing, but it puts concrete architectural claims on the record where they can be scrutinized. For credentials, iCloud Keychain uses end-to-end encrypted synchronisation, meaning the decryption keys stay on my trusted devices rather than sitting on Apple's servers.

Leaning on first-party OS integration also lets me strip out privileged third-party code: fewer browser extensions, fewer background sync daemons, and fewer third-party hooks into sensitive workflows. At the same time, Apple's iCloud data security overview makes it clear that protection models vary by data category, and centralizing hardware, OS, identity, and cloud in one ecosystem creates obvious lock-in and concentration risk. My trust applies to specific cryptographic mechanisms, not to Apple as an institution. That’s why my critical recovery paths and offline backups live outside iCloud.

Following the subsidy

The cliché "if a product is free, you are the product" is lazy shorthand. Linux distributions, open-source utilities, and Wikipedia don't charge license fees. When Canonical ships Ubuntu for free and charges enterprises for support SLAs and compliance tooling, the subsidy is transparent.

Consumer platforms like Facebook and Instagram operate on a different exchange: user attention and behavioral telemetry feed an ad-targeting engine. It isn't that Meta literally sells a spreadsheet of your private chats to the highest bidder; it's that your activity is the raw material for their core business. There is a Turkish saying for this: Bedava peynir sadece fare kapanında olur (“The only free cheese is in a mousetrap”). A tool being free isn't an automatic red flag, but an unexplained business model always is.

Passwords, passkeys, and second factors

Apple Passwords and iCloud Keychain hold my primary vault. On iOS, I use native autofill; on non-Apple machines and secondary browsers, I intentionally avoid syncing the full vault. Typing or copying a credential manually has real downsides. It loses the automatic domain-matching protection of native autofill and briefly exposes secrets to the system clipboard. I prefer that trade-off over leaving my primary password database mounted across every OS and browser environment I touch.

Passkeys where supported

Whenever a service supports passkeys, I switch to them. Passwords are reusable shared secrets that can be phished, keylogged, or stuffed; passkeys use origin-bound public-key cryptography, making traditional credential-harvesting pages useless. I store mine in iCloud Keychain. I have weighed moving to hardware FIDO2 security keys, but once you factor in spare key logistics, cross-device connectors, and recovery ceremonies, synced passkeys hit the right balance for my current threat model.

Keeping TOTP separate

My time-based one-time passwords (TOTP) live in a dedicated authenticator app, completely separate from my password manager. If both apps reside on the same unlocked device, a full endpoint compromise can still reach both, so this isn't magic isolation. What it prevents is a single vault compromise, sync leak, or accidental export from handing over both authentication factors in one package. My TOTP backups are encrypted independently with multiple recovery paths.

Where Bitwarden fits

I run Bitwarden (which documents its zero-knowledge model in its security white paper) as a strictly scoped secondary vault rather than a full mirror of my primary credentials. It adds another piece of infrastructure to maintain, but gives me clean cross-platform compartmentalization where I need it.

When deciding how strictly to lock down an account, I ignore how often I log into it. "Rarely used" does not mean low-impact. A forgotten ten-year-old forum or retail account can still hold PII, billing history, private messages, or password-reset leverage. The only question that matters is the blast radius if someone else takes it over.

Least privilege on personal machines

My daily driver accounts on macOS, Windows, and Linux run as standard users. Reading mail, writing code, and browsing the web do not require permanent root or administrator privileges; system-wide changes happen through a separate admin account.

On a personal computer, user-space and valuable data overlap heavily. Any malicious process running under my standard UID can already read my local files, browser cookies, and active sessions without needing root. What account separation actually buys is containment and friction: it stops silent system-level persistence, prevents drive-by configuration tampering, and turns every privilege-elevation prompt into a deliberate context switch where I have to verify what is asking for admin rights and why.

Linux as a purpose-built environment

While Linux is no longer my primary desktop, I maintain a dedicated x86 Linux workhorse for tasks that need raw system-level control, native x86 execution, or physical separation from my Mac. I value the classic Unix model (explicit permissions, strict user boundaries, observable processes, and small, composable tools), not because Unix heritage automatically makes a machine secure, but because it makes the system legible when configuring controls or spotting anomalies.

Why I stick with Fedora (and watch openSUSE)

After distro-hopping for years, I keep coming back to Fedora. Its release lifecycle hits the sweet spot between stale LTS packages and bleeding-edge instability. Out of the box, my setup runs with Secure Boot enabled, LUKS2 full-disk encryption, SELinux in enforcing mode, and minimal third-party repositories. I run KDE Plasma over GNOME for a purely practical maintenance reason: Plasma ships with the desktop features I need built in, whereas getting the same workflow elsewhere usually means bolting on third-party shell extensions.

My closest runner-up is openSUSE Tumbleweed. Pairing a rolling release gated by automated openQA testing with default Btrfs and Snapper integration means that if an update or config change goes sideways, I can boot straight into a read-only filesystem snapshot and roll back in seconds. Local snapshots are strictly for system recovery, never a substitute for offline backups.

Sandboxing untrusted workloads

When I need to run legacy binaries or software whose provenance I can't fully verify, it goes into a virtual machine on the Linux box with shared folders, clipboard sync, and drag-and-drop disabled, and the virtual NIC disconnected unless network access is strictly required. Virtualization isn't an impenetrable wall against host escapes, but it sharply reduces casual exposure to my primary environment.

Vetting software and verifying downloads

Installing code is an act of trust. On iPhone, I check the App Store’s App Privacy disclosures alongside the actual runtime permissions requested. A navigation app obviously needs GPS; a plain markdown note app has no business asking for location, contacts, or full photo library access. Because App Store labels are self-reported by developers, proportionality and developer track record matter more than the label alone.

On desktop systems, I verify SHA-256 checksums for OS images, ISOs, and installers whenever publishers provide them. A matching hash only proves the file matches the reference string. If an attacker compromises the distribution server and swaps both the binary and the hash text on the download page, a simple checksum check proves nothing. Whenever possible, I look for detached cryptographic signatures, OS code-signing notarization, or checksums verified through an out-of-band channel.

Quarantining untrusted USB media

A USB stick handed to me by a friend or relative never touches my main computer. It isn't a lack of trust in the person; I just have no idea which poorly maintained PCs or print-shop kiosks that drive has been plugged into. Beyond filesystem malware, USB sticks are active peripherals with their own controller firmware that can enumerate as keyboards or network interfaces, a risk highlighted in NIST’s removable-media guidance.

I inspect unfamiliar drives on a dedicated, air-gapped laptop completely separate from my Linux workhorse. It holds no personal accounts, no credentials, no vault access, and no personal files. The network drivers are stripped out entirely, and I periodically wipe and reinstall the OS from scratch, aligning with NSA removable-media mitigations.

If I need to pull a file off that drive onto my main machine, I use a strict one-way routine:

  1. Copy only the target file from the unknown stick onto a clean transfer drive that I own.
  2. Plug my transfer drive into the primary machine and scan the file again.
  3. Wipe the transfer drive immediately after.

Scanning isn't infallible. A clever payload can evade signatures, so this workflow is about hardware containment: keeping unknown USB controllers and uninspected filesystems physically away from my daily machines.

Splitting browsers by role and engine

I don't funnel my entire life through a single browser or rendering engine:

  • Zen: My daily driver. Most of the modern web works fine on Gecko or WebKit, so I see no reason to reward the Chromium monoculture by making Google Chrome my default. (Zen)
  • Orion: My choice when I want a lightweight, native macOS WebKit browser that still supports uBlock Origin, accepting that its WebExtensions support has occasional edge-case quirks.
  • Safari: Reserved for high-consequence tasks such as purchases, banking, government portals, and official applications. Using Safari doesn't magically validate a website, but it isolates sensitive sessions and transactions inside a clean, stock environment away from everyday browsing clutter.
  • Brave: My fallback for sites that genuinely break outside Chromium. I have plenty of reservations about Brave's business side quests, but as a stripped-down modified Chromium engine kept on standby for compatibility, it does the job.

Minimal extensions and strict transport

Aside from uBlock Origin, I don't run browser extensions. Extensions execute with sweeping privileges inside the exact DOM environments where I type passwords, card numbers, and private messages. As OWASP’s extension guidance details, even legitimate extensions get bought out, over-permissioned, or compromised via supply-chain updates. Not installing them is the cleanest defense.

Every browser I use also has HTTPS-Only Mode (or Chrome's Always use secure connections equivalent) enabled from day one to block silent plaintext HTTP downgrades. TLS protects the pipe between my browser and the server. It doesn't mean the server on the other end is honest, nor does it hide the data I submit from the site operator.

Messaging: cryptography vs. adoption

WhatsApp is my primary messenger for one reason: everyone I talk to is already on it. I would rather use iMessage or Signal full-time, and I do whenever the other person uses them, but a secure protocol with nobody on the other end is useless.

WhatsApp encrypts message payloads and calls end-to-end by default, and I keep end-to-end encrypted backups turned on so my cloud chat archives aren't left sitting in plaintext. However, payload encryption is not total privacy. Under its EEA privacy policy, WhatsApp still collects social graphs, phone numbers, IP addresses, device telemetry, and activity timestamps inside an advertising-driven parent company. You can trust the Signal protocol implementation protecting the message body without trusting Meta's broader ecosystem.

Managing residual risk through data minimization

Because I can't control WhatsApp's metadata collection, client vulnerabilities, or the security hygiene of the person on the other end of a chat, using it carries residual risk. When I can't reduce the likelihood of exposure (say, a contact's phone getting compromised, an unencrypted recipient backup, or a screenshot), I reduce the impact. I practice basic data minimization in chat: I am deliberate about which files, documents, and personal context I drop into long-lived message threads.

Evaluating other messengers and Encrypted RCS

When evaluating messengers, marketing labels mean nothing compared to default states. Apple documents iMessage end-to-end encryption, and Signal enforces it across every conversation and call. I have also evaluated Threema (which documents a clean, phone-number-free architecture in its cryptography white paper) and Telegram, where ordinary private and group Cloud Chats are stored accessible to the server, and only manually initiated one-to-one Secret Chats get end-to-end encryption.

Right now, I'm watching encrypted RCS closely. With the GSMA Universal Profile 3.0 adding end-to-end encryption and Apple rolling out beta support starting in iOS 26.5, cross-platform texting between iPhone and Android finally has a path off plaintext SMS/MMS. Still, protocol names and bubble colors aren't security guarantees; as Apple’s messaging comparison notes, I check for the explicit lock indicator on the thread before assuming a conversation is actually encrypted.

Untrusted networks and power

When I connect to unfamiliar public Wi-Fi (whether it's WIFI@DB on the train, BayernWLAN, hotels, cafes, or networks abroad), I route traffic through Mullvad. I don't run a VPN 24/7 at home or pretend it makes me anonymous. Its job is narrower: shifting trust away from a local network operator whose hardware and configuration I can't verify, in line with NSA wireless guidance.

Everyday network privacy: iCloud Private Relay vs. a full VPN

One reason I do not leave a traditional VPN running 24/7 at home is that a conventional single-hop VPN shifts trust from my ISP to the VPN provider. The provider can see my real IP address and the destination IPs my traffic reaches through the tunnel. HTTPS still protects the contents of those connections.

For everyday browsing on my Apple devices, I keep iCloud Private Relay enabled. It routes covered traffic through two relays, using QUIC and MASQUE to split what each operator can see:

  • The ingress hop (operated by Apple): Sees my real IP address and checks that my device is eligible to use the service. The destination is encrypted from this relay.
  • The egress hop (operated by a separate provider): Learns the destination, assigns a temporary IP address based on my approximate region, and connects to the website. It does not receive my original IP address or Apple Account identity.

Neither relay sees both my original IP address and my destination. That makes it harder for one operator to tie my browsing to my network identity.

Private Relay covers Safari browsing, DNS queries, and insecure HTTP traffic from apps, as Apple documents. It does not cover arbitrary traffic from every app. I leave it enabled for daily browsing and use Mullvad on unfamiliar public Wi-Fi when I want a system-wide WireGuard tunnel.

Rogue access points and evil twins

Anyone with commodity assessment hardware like a WiFi Pineapple (documented by Hak5) can spin up an evil-twin SSID and a convincing captive portal. While modern HTTPS prevents a rogue access point from reading encrypted payloads, controlling the local network path still lets an attacker harvest connection metadata, tamper with unencrypted requests, or hijack DNS and captive portals before a VPN tunnel comes up. A VPN neutralizes local network snooping once established, while leaving endpoint security and phishing judgment on me.

Power without data pins

I treat public USB ports at airports, trains, and hotels the same way. Standard USB cables carry both power and data over the same connector, and I have no way of knowing what sits behind a wall plate. While modern operating systems block unauthorized USB data enumeration until unlocked (meaning the real-world likelihood of juice jacking shouldn't be blown out of proportion), there is zero reason to expose a hardware data interface when all I want is electricity. I plug my own charger into an AC outlet, carry a power bank, or use a physical USB data blocker.

Isolating merchants with virtual cards

Financial accounts get strict compartmentalization because the blast radius of a leak is immediate. Rather than handing the same primary card number to every online shop and subscription, I generate merchant-specific virtual cards through my bank. Both Mastercard and Visa document how tokenized or virtual card numbers map back to an underlying funding account with independent controls.

Running one card per merchant buys two practical wins:

  1. Containment: If a merchant is breached or makes canceling a subscription painful, I can freeze, cap, or delete that single virtual card in seconds without updating my billing details across twenty other services.
  2. Attribution: If an unauthorized charge pops up on a card locked to a single vendor, I immediately know which relationship leaked (whether at the merchant, their payment processor, or during my checkout session).

Virtual cards isolate payment credentials, not the underlying bank account itself, so strong account authentication, instant push notifications, and reviewing statements still do the heavy lifting.

Why I use Apple Pay for contactless and checkout payments

Virtual cards handle online merchants that demand a raw card number. For contactless payments and supported checkouts, I use Apple Pay in place of my physical card or a competing wallet like Google Pay. What matters to me is where the payment credential lives and what the wallet provider retains afterward.

When I add a card to Apple Pay, the issuer or its payment network provisions a tokenised Device Account Number into the Secure Element, a dedicated chip isolated from iOS. Apple says it does not store the original card number on the device or on its servers. When I authorise a payment, the Secure Element supplies the token and a dynamic security code for that transaction. The merchant gets neither my original card number nor a security code it can reuse for another purchase.

Android supports both Host Card Emulation (HCE) and Secure Element card emulation. With HCE, the phone routes the terminal's requests to software. With Secure Element card emulation, those requests go to the chip. For my own payments, I prefer the hardware isolation Apple documents for Apple Pay.

Apple says it does not retain card transaction information that can be tied back to me, although it retains anonymous information about some payments made in apps and on the web. Google Wallet's privacy controls describe when payment activity can be saved to a Google Account or used for personalisation and ads, depending on the settings available. When I pay for a coffee or a train ticket, I want the payment rail to move money without adding that purchase to a behavioural profile.

Metadata, Git history, and OSINT breadcrumbs

A file or repository publishes much more than what renders on screen. A while back, someone I know built a public event website using GitHub Pages. The live site looked clean, but because the Git repository was public, the commit history still contained every scrapped venue idea, draft schedule, and dress-code note. Worse, the photo gallery was uploaded straight from a phone camera roll, leaving GPS coordinates, exact capture timestamps, and device EXIF intact. Nothing was hacked; Git and JPEG simply worked as designed.

Why "I have nothing to hide" misses the point

The mistake isn't just forgetting how git log or EXIF works. It's assuming a detail is harmless because it looks mundane in isolation. A single timestamp, an interior photo, a job title, or a software preference won't hand an attacker your keys. Combined, they build a profile of routines, relationships, travel windows, and technical context.

The 2020 Twitter breach is a textbook case of weaponized context. As the NYDFS investigation detailed, the attackers didn't start with a zero-day exploit; they researched employee roles, org charts, and remote-work routines during COVID-19, knowing VPN hiccups were common. When they cold-called staff posing as IT support, those mundane breadcrumbs acted as informal authentication material. They answered the victim's subconscious "how would an outsider know this?" check, manufacturing enough credibility to phish credentials, relay live MFA prompts, pivot through internal documentation, and ultimately hijack 130 accounts, including several high-profile accounts (stealing roughly $118,000 in bitcoin along the way). The lesson works both ways: publish fewer unnecessary breadcrumbs externally, and build internal access boundaries and phishing-resistant MFA that assume humans can be talked into trusting a good story.

Stripping files and repositories before release

Before I push a project or share a file publicly, I treat the export as an untrusted artifact:

  • Photos and video: On iOS, I toggle off location in the Share Sheet (see Apple’s photo-sharing documentation) and avoid sending "All Photos Data" unless required. For web assets, I strip metadata on the final exported file rather than trusting a platform to scrub it, and visually check the frame for street signs, license plates, screens, and reflections.
  • Documents and PDFs: Working drafts stay private; public releases are exported as separate files and scrubbed of author paths, revision history, comments, and hidden layers using tools like Microsoft's Document Inspector or Adobe's PDF sanitization (ensuring redactions are flattened, not just black vector boxes over selectable text).
  • Git repositories: Deleting a line in a new commit doesn't erase it from earlier history, and as GitHub’s data-removal documentation notes, rewriting history after the fact won't claw back existing clones, forks, or cached PRs. When draft history doesn't belong in public, I publish a clean, squashed repository from the start and always download and inspect the final live build.

When an organization asks for an ID scan

Plenty of banks, landlords, and certification bodies still ask for passport or ID scans over standard email instead of providing an encrypted upload portal. Because standard email is only encrypted hop-by-hop via TLS, attachments can sit in plaintext across mail servers, IMAP clients, and support ticketing systems indefinitely. Handing over a pristine, reusable scan is an identity-theft liability.

When I can't avoid sending an ID, I verify the request first and build a single-purpose, degraded copy:

  • Redact non-essential fields: I black out any data fields the recipient doesn't legally or operationally need to see, flatten the image so the redaction is irreversible, and strip file metadata.
  • Burn in a context watermark: I place a visible watermark directly across the document (overlapping part of the card without obscuring required fields): "Copy provided to [Recipient] for [Purpose] on [Date]."

In Germany, section 20 of the Personalausweisgesetz explicitly requires any reproduction of an ID card to be clearly and permanently recognizable as a copy, and the BfDI’s guidance supports redacting fields not required for identification. At the same time, regulated institutions like banks have strict statutory verification and retention duties under section 8 of the Money Laundering Act (GwG), so I leave legally mandated fields untouched. Watermarking and redacting won't make email end-to-end encrypted, but it kills the scan's reuse value if their inbox gets breached two years later.

Full-disk encryption and failure domains

Every computer and external drive I own runs full-volume encryption: FileVault on macOS, BitLocker on Windows, LUKS2 on Fedora, and VeraCrypt on external backup drives.

Full-disk encryption solves a very specific problem: physical loss. If a laptop is stolen off a train, a drive is pulled from a chassis, or an SSD is sent in for warranty repair, physical possession of the hardware doesn't grant access to the filesystem while powered down or locked. Once the volume is unlocked and mounted, disk encryption is transparent to the OS. That means active malware or an unlocked session can read the files just like I can.

Why my Fedora machine uses a pre-boot LUKS2 passphrase instead of TPM 2.0 auto-unlock

On Linux, systemd-cryptenroll can enrol a TPM 2.0 chip to unlock a LUKS2 volume during boot. The unlock can be bound to measurements recorded in selected Platform Configuration Registers (PCRs), and it can also require a PIN. Unattended unlock is convenient, especially for machines that need to restart without someone there. For my Fedora machine, I plan around someone stealing the entire computer.

A PCR policy checks whether the selected boot measurements match what the policy allows. It does not tell the TPM who is holding the machine. With unattended unlock, a stolen computer can boot normally to the login screen, with the encrypted volume mounted and the keys in memory. The login screen still controls access, but my data is now exposed to risks that only matter once the system is running, including local privilege escalation and memory extraction.

If someone steals my computer while it is powered off, I want the encrypted volume to stay locked when they press the power button. On Fedora, I use a strong pre-boot passphrase backed by LUKS2's memory-hard Argon2id key derivation, with no TPM unlock slot enrolled. The early boot environment can start, but the system cannot mount the encrypted root filesystem and finish booting until the volume is unlocked.

Out-of-band recovery

Encryption without a tested recovery path is just a self-inflicted denial of service. I store recovery keys for FileVault, BitLocker, LUKS2, and VeraCrypt completely outside the volumes they unlock, paying close attention to shared failure domains. Storing a Mac's FileVault recovery key exclusively inside the same Apple Account or keeping every backup key in the same physical room means a single account lockout or apartment fire takes down both the primary system and its recovery path.

Backups and resilience

One backup is no backup, and a mirrored drive is not a time machine.

My backup setup combines encrypted external media with multiple independent copies, using CISA’s 3-2-1 model (three copies, two media types, one off-site) as a baseline. In practice, that means separating three distinct concerns that people often lump together:

  • Confidentiality: Encrypting every external backup volume with VeraCrypt so an off-site drive doesn't become a data leak.
  • Availability: Keeping redundant copies across separate hardware and physical locations so a dead controller or local disaster doesn't wipe everything out.
  • Integrity and versioning: Maintaining historical snapshots rather than blind clones. A straight rsync mirror faithfully replicates accidental deletions, silent bit-rot, and ransomware encryption across your backup drive the moment you plug it in.

Above all, a backup strategy is only as real as its last restore test. Until you have actually decrypted the drive and restored data onto a clean system, you just have a hypothesis about whether the backup will work. And because threat models, tools, and providers never sit still, none of the setup on this page is final; it evolves whenever the risks change.