Security

Authenticated encryption that encrypts and detects tampering in one call; the only kind of symmetric encryption you should use.

Memory-hard, salted, deliberately slow hashing so stolen password databases can't be cracked cheaply on GPUs.

Small, fast, deterministic public-key signatures that prove who produced a message; the default for tokens, releases and protocols.

Collision-resistant fingerprints of data; SHA-256 for interoperability, BLAKE3 for speed, HMAC/HKDF for keyed uses.

The standard encrypted, authenticated transport; one round trip, only forward-secret AEAD suites, and little left to misconfigure.

The elliptic-curve signature standardised in FIPS 186-5 (P-256) and used by secp256k1 ledgers; 64-byte signatures, but a repeated or biased nonce leaks the private key.

Each side multiplies the other's public curve point by its own scalar and both get the same point; always validate the peer key and run the result through a KDF.

A keyed short tag proving a message is unmodified and came from a key holder; pick HMAC, CMAC, KMAC or a one-time polynomial MAC by what primitive you already have.

HMAC-based two-step key derivation: extract a uniform pseudorandom key from any secret, then expand it into as many context-bound keys as you need.

Opaque server-side sessions in cookies for browsers, short-lived signed tokens between services; revocation decides most cases.

Delegated authorization (OAuth 2) and login on top of it (OIDC); use authorization code + PKCE for every user-facing client.

Phishing-resistant login with a per-site key pair held by the device or password manager; the server stores only a public key.

How to decide who may do what to which object; roles for coarse rules, relationships for sharing, and checks on every object.

A signed, URL-safe token carrying claims; the verifier's job is the checklist (pinned algorithm, key by kid, exp, aud, iss), not the format.

Short numeric codes derived from a shared secret plus a counter or the clock (HOTP, TOTP), or random codes sent by SMS or email; safe only with expiry, single use and attempt limits.

Both sides blind a Diffie-Hellman message with a password-derived group element, so an attacker gets one guess per run and nothing to brute-force offline.

Symmetric-key challenge-response in which a chip and its home server prove knowledge of one key, with a sequence number for freshness, and derive session keys.

The web and API vulnerability classes that cause most real breaches, each with the one structural fix that removes it.

Keep untrusted data as data: parse it into types at the boundary, and never splice it into code, queries, shells or HTML.

Compile a JSON Schema once, then check every untrusted document against it, within hard size and depth limits, and report failures as JSON Pointers.

UTS #39 maps every string to a "skeleton" so look-alikes collide, and restricts script mixing so most spoofs never get registered.

Mutate inputs, run an instrumented target, and keep any input that reaches a new code edge; feedback turns blind guessing into incremental search.

Keep keys and passwords out of code and logs, give workloads short-lived identity instead of static keys, and make rotation routine.

Control what code enters your build and prove what comes out: lockfiles, vetted updates, hardened CI, signed artifacts with provenance.

Assume every component will be compromised and limit what it can then reach: narrow identities, separate accounts, sandboxed processes.

An append-only log whose Merkle root, signed per batch, lets anyone verify an entry is present and history was never rewritten, with log-size proofs.

Separate signing roles with thresholds sign small metadata pinning file hashes, versions and expiry, so clients detect rollback, freeze and mix-and-match and recover by rotating the root.

Encrypt each object with its own data key and wrap that key under a KMS-held key, so rotation re-wraps 60 bytes and deleting a key shreds data.

Encrypt a digit or character string into another string of the same length and alphabet with a keyed Feistel network, reversible with the key and a context tweak, without a lookup table.

Keep secrets in one locked, fixed-size, non-copyable region, erase them with writes the compiler must keep, and exclude them from dumps and swap.

Split a secret into n shares so any k reconstruct it and any k-1 reveal nothing at all, using a random polynomial over a finite field.

Decide allow/deny for (principal, action, resource, context) in a separate engine with default deny, forbid-wins and an auditable list of determining policies.

Append a policy predicate to every query inside the database, so a forgotten WHERE tenant_id = ? in application code cannot leak another tenant's rows.

Authority is a handle you hold, not an identity you have: code can only act on objects it was explicitly given handles to, and handles can only be narrowed and passed on.

A URL carrying its expiry and a MAC or signature over method, path and query, so a verifier holding the key needs no lookup.

A public append-only Merkle tree whose signed heads let anyone verify an entry is present and history was only extended, with log-size proofs.

TLS where the client also proves a certificate key, so every connection carries a verified, rotatable machine identity.

A local agent works out which workload is calling, then hands it a short-lived signed identity that it renews automatically; no secret is shipped in advance.

A three-layer protocol on one TCP connection: encrypted packet transport, user authentication, then multiplexed channels with windows for shells, files and port forwards.

A UDP tunnel whose peers are public keys, with a 1-RTT Noise handshake, one fixed cipher suite and a key-to-address routing table.

A tamper-resistant device or service that generates keys, signs, decrypts and wraps with them internally, and releases a key only as ciphertext.

Each boot stage verifies the signature of the next before running it, anchored in an immutable ROM key hash, with version counters against downgrade and a TPM log of what ran.

A highest-seen counter plus a bitmap of the last W numbers rejects duplicates and stale messages in O(1) with a few hundred bytes of state.

Run risky work in a separate, deliberately powerless process and let a small privileged broker do the few things it needs, over a narrow pipe.

Combine declared identity, rate and timing, network, behaviour and integrity signals into one score per client, then map thresholds to allow, log, limit, challenge or block.

Build a per-user profile of input timing and motion, score each new session by distance to it, and feed the result into a risk score instead of a verdict.

Collect stable and volatile device signals, hash the stable core for exact lookup, fuzzy-match the rest with drift tolerance, and feed the result into a risk score.

Turn per-entity good/bad event counts into a trust score that forgets old evidence, borrows strength from parent groups for new keys, and maps to allow, challenge or block.

Hide sensitive field values from people and systems that don't need them, by masked copies or role-based masking at read time, while keeping joins and formats working.