CAP-PC ENS key terms

A flaw where the application exposes an internal identifier such as a record number and trusts the client to send it back unchanged, letting an attacker read or modify another user's data by editing that value.

Any failure to enforce who may perform an action or view a resource, including missing checks on the server, role confusion, and trust in client-supplied role or tenant fields. It consistently ranks as the top web application risk.

Gaining access to resources belonging to a peer account at the same privilege level, typically by changing a user or tenant identifier. It differs from vertical escalation, which moves a user to a higher role.

Raising one's own privilege level, for example from ordinary user to administrator, by abusing missing server-side checks, role parameters accepted from the client, or flaws in the authentication or session logic.

An attack that makes the server issue a request to a destination the attacker chooses, often reaching internal metadata services, admin panels, or cloud credentials that are unreachable from the internet.

Injecting script into pages other users view, so it runs in their browser origin. Stored, reflected, and DOM-based variants differ in where the payload lives and which code path renders it unsafely.

A response header that tells the browser which script, style, and network sources a page may use. A strict policy with nonces or hashes limits the impact of injection flaws but does not fix the underlying bug.

A browser enforcement mechanism that blocks assignment of plain strings to dangerous DOM sinks such as innerHTML unless a registered policy sanitizes them, turning DOM-based cross-site scripting into a load-time error.

Forcing a logged-in victim's browser to send a state-changing request to a site that trusts the browser's ambient credentials. Defenses include synchronizer tokens, strict SameSite cookies, and origin checks.

A cookie attribute controlling whether the browser attaches the cookie to cross-site requests. Lax and Strict modes block most cross-site form posts, reducing cross-site request forgery exposure, though not all browser and flow combinations behave identically.

An attack where the adversary plants a known session identifier in the victim's browser and, after the victim authenticates, reuses that same identifier to hijack the now-privileged session.

A signed, base64url-encoded token carrying claims about a subject. Security depends on verifying the signature with the correct algorithm and key, and on never trusting unverified header or claim values.

A JWT attack where a token signed with an asymmetric key is re-signed or presented using a symmetric algorithm, tricking a naive verifier into treating the public key as a shared secret and accepting a forged token.

The standard delegation flow where the client obtains a short-lived code and exchanges it, with its secret and a matching redirect URI, for tokens. Weak redirect validation or missing state checks enable token theft.

A parameter that sends users to an arbitrary external URL after login or logout. Beyond phishing, it can leak authorization codes or tokens when the redirect target is not strictly validated against an allowlist.

Accepting only values that exactly match a predefined set of permitted items, such as hosts, schemes, or file types, rather than rejecting known-bad patterns. Preferred over blocklists because it fails closed.

A framework behavior that binds every submitted request field onto an internal object, letting an attacker set fields such as role or verified status that the form never intended to expose.

Supplying sequences such as ../ or encoded equivalents so a file path escapes its intended directory, allowing reads or writes outside the web root when the resolved path is not canonicalized and checked.

Converting untrusted data into a representation safe for a specific context, such as HTML body, attribute, URL, or JavaScript string, so the browser treats it as text rather than executable markup.

A cookie flag that hides the value from JavaScript's document.cookie, preventing script-based theft of session identifiers even when cross-site scripting is present elsewhere on the domain.

A static technique that marks untrusted inputs as sources, tracks how values propagate through assignments and calls, and reports when they reach sensitive operations called sinks without sanitization.

In taint analysis, a source is where untrusted data enters, such as a request parameter, and a sink is a dangerous operation such as a SQL query or command execution. A finding requires an unbroken path between them.

A directed graph whose nodes are basic blocks and whose edges are possible jumps between them. Analyses use it to reason about reachability and to determine whether a sink is actually reachable from a source.

A tree representation of source code structure, omitting formatting details. Rules and linters match patterns on this tree so they can detect constructs that text search would miss or misreport.

A graph linking each function to the functions it may invoke. Security reviews use it to follow data across function and file boundaries and to spot entry points that reach dangerous helpers.

Automated review of source, bytecode, or binaries without executing the program. It finds injection patterns and dangerous API use early but produces false positives that require human triage.

Pattern search that understands code structure, such as matching a function call with specific arguments rather than raw text. It reduces noise when hunting for dangerous API usage across a large repository.

Identifying third-party libraries and their versions in a build and mapping them to known vulnerabilities and license obligations. It complements code scanning because most shipped code is dependency code.

A machine-readable inventory of components and their versions in an artifact. It enables rapid impact checks when a new dependency vulnerability is published and supports supply-chain due diligence.

Publishing a malicious package under the same name as an internal library on a public registry, hoping build tooling resolves the public copy first. Pinning versions and scoping internal names mitigates it.

Accepting attacker-controlled serialized data that the runtime reconstructs into objects, potentially triggering gadget chains that execute code or alter state during reconstruction, before any business logic runs.

The property that code cannot read or write outside a buffer's bounds or use freed memory. Languages without it rely on careful review and mitigations such as bounds checks and sanitizers.

Feeding generated or mutated inputs to a program to trigger crashes and unexpected behavior. Coverage-guided fuzzers are effective at finding parsing bugs and memory errors in native code.

The most severe impact class, where an attacker causes the target to run commands or code of their choosing. It typically arises from injection flaws, unsafe deserialization, or vulnerable dependencies.

A link-local endpoint on cloud instances that returns configuration and temporary credentials. Version two requires a session token, which blocks simple request forgery that only issues GET requests.

A cloud identity policy granting broader actions or resources than the workload needs, such as wildcard actions. Compromise of that workload then yields far more access than intended.

Granting only the permissions required for a task, scoped to specific resources and conditions, and reviewing them regularly. It limits blast radius when credentials or workloads are compromised.

A chain of allowed actions, such as creating a role, attaching a policy, and passing it to a compute service, that lets a principal obtain permissions it was never directly granted.

A cloud audit log service recording API activity with identity, source address, and time. Investigators use it to reconstruct attacker actions and to detect unusual role assumptions or disabled logging.

An object store configured to allow anonymous read or list access. It commonly leaks backups, logs, and credentials, and is found through naming guesses and search engines rather than exploitation.

Protecting the build and deploy chain: restricting who can change pipeline definitions, isolating secrets from untrusted pull requests, and signing artifacts so tampering is detectable.

Storing and distributing credentials through a dedicated vault or managed secret store with rotation, access logging, and short lifetimes, instead of hardcoding them in repositories, images, or environment files.

A commercial adversary-simulation payload that provides command-and-control, lateral movement, and post-exploitation features. Defenders detect it through network signatures, named pipes, and process behavior.

The channel an operator uses to task compromised hosts and receive results. Profiles mimic legitimate traffic, and detection focuses on beacon timing, uncommon destinations, and protocol anomalies.

Using signed, preinstalled tools such as PowerShell, certutil, or wmic to perform actions, so activity blends with administration and evades detection that only watches for dropped binaries.

Requesting service tickets for accounts with service principal names, then cracking the encrypted portion offline to recover the service account password. Strong, long passwords and managed accounts reduce exposure.

A collaborative exercise where offensive actions are shared with defenders in real time so detection rules can be tuned and validated, converting red team findings into measurable defensive improvements.

Embedding instructions in content that a language model processes, causing it to ignore its intended task or leak data. Untrusted retrieved text and tool outputs are common delivery routes.

Placing adversarial instructions in data the model later retrieves, such as a web page or document, so the payload executes when the user asks an unrelated question and the model reads that content.

A model-driven system that can call functions, browse, or run code. Its risk grows with tool permissions, so designs should require confirmation for sensitive actions and validate tool arguments.

Reconstructing training data or sensitive attributes by repeatedly querying a model and analyzing outputs. Overfitting and overly detailed confidence scores make such inference easier for an attacker.

Corrupting training or fine-tuning data so a model learns biased behavior, backdoor triggers, or wrong associations. Provenance checks and evaluation on held-out data help detect it.