reference

Glossary

All the alphabet soup in one place: acronyms, identifiers, frameworks and concepts: what each one means and how it connects to the rest. Terms from every domain live here, with a domain filter when you want to focus.

frameworks and listsAppSec

OWASP Top 10: The best-known reference list of web application security risks (A01 broken access control, A02 cryptographic failures, A03 injection...), revised every few years by the OWASP community. It is an educational map of risk categories, not a tool checklist or a certification.
OWASP ASVSverification standard: Application Security Verification Standard: a verifiable checklist, with three levels of rigor, for auditing an application or commissioning an audit. Where the Top 10 teaches, the ASVS audits.
NIST SSDF: A US framework for a secure software development process (practices for producing secure software). It is about process, not tooling: it cites SAST, SCA and SBOM as parts of the lifecycle.
OWASP SAMM: A software security maturity model: it assesses the organization across five business functions to tell which level it is at and what to prioritize next.

identifiers, databases and scoresAppSec

CVEcommon vulnerabilities and exposures: The unique identifier of ONE specific public vulnerability, in the format CVE-YEAR-NUMBER. E.g., CVE-2021-44228 is Log4Shell. It is the real instance, not the class of the problem.
CWEcommon weakness enumeration: The identifier of the TYPE of weakness, the class of error in the code. CWE-89 is SQL injection, CWE-79 is XSS. The distinction that confuses everyone: CWE is the category, CVE is a concrete occurrence of it. A CVE for SQL injection in your framework will reference CWE-89.
CVSScommon vulnerability scoring system: A score from 0 to 10 that measures the technical severity of a vulnerability: how it is exploited (network or local, complexity, required privilege, user interaction) and what the impact is. 9.0+ is critical, but the number is theoretical: it does not know whether you are exposed.
EPSSexploit prediction scoring system: The probability (0 to 100%) that a CVE will actually be exploited in the next 30 days, based on evidence. It complements CVSS: a 9.8 with an EPSS of 0.1% can be less urgent than a 7.5 with an EPSS of 60%.
CISA KEVknown exploited vulnerabilities: A catalog of the vulnerabilities being actively exploited, right now, in the real world. 'It's in the KEV' = top priority, regardless of CVSS.
NVDnational vulnerability database: NIST's database that enriches each CVE with a CVSS score and an associated CWE. It is where most SCA tools get their data.
OSV / GitHub Advisoryadvisories: Vulnerability databases focused on package ecosystems (npm, PyPI, Maven...). More practical than the generic CVE: they tell you exactly which version is affected and which one fixes it.

tests and techniquesAppSec

SAST: Static analysis: examines the code without running it. It finds issues through flow analysis, not guesswork.→ SAST
DAST: Dynamic testing: attacks the running application from the outside, as a black box.→ DAST
IAST: Hybrid: an agent inside the application watches execution in real time, combining code context (SAST) with attack evidence (DAST).
RASP: Runtime Application Self-Protection: protection built into the application runtime that blocks attacks as they happen, even after deploy.
SCA: Composition analysis: inventories third-party dependencies and cross-references them with known CVEs.→ SCA
Secrets scanning: Scanning for exposed credentials in code, commits and git history.→ Secrets Scanning
Fuzzing: Bombarding the application with random inputs or mutations of valid inputs, hunting for crashes and unexpected behavior. The ancestor of modern DAST.
Pentest: Manual adversarial testing, with a defined scope and a report: a human (or team) deliberately trying to break into the application.
ASTabstract syntax tree: The syntax tree the parser produces: each code construct becomes a typed node, and tools analyze the tree instead of loose text.→ SAST
Source: The origin of untrusted data: user input, query string, header, file. It is where taint is born.→ SAST
Sink: The dangerous destination where untrusted data becomes a command, query or HTML: db.query, eval, innerHTML. If the taint reaches here, it is a vulnerability.→ SAST
Taint trackingtaint analysis: Following the 'dirty data' mark from the source to the sink, propagating through assignments and calls. It is the heart of modern SAST.→ SAST
Sanitizer / barrier: The function that cleans the data or proves it is safe (parameterized query, HTML escaping). It cuts the flow and the engine stops alerting on that path.→ SAST
False positive / false negative: False positive: an alert for a vulnerability that does not exist. False negative: a real vulnerability that slipped through. Every tool is constantly trading one for the other.

supply chain and artifactsAppSec

SBOM: The software's ingredient list: dependencies, versions, licenses and hashes, in a standard format.→ SBOM
purlpackage url: A universal package identifier: pkg:npm/lodash@4.17.15 states ecosystem, name and version unambiguously. It is the backbone of an SBOM.
CycloneDX / SPDX: The two standard SBOM formats. CycloneDX is more security-oriented, SPDX more license-oriented. In practice, both list the same components.
Hash (SHA-256): A file's fingerprint: if one byte changes, the hash changes. It proves the component is exactly what it claims to be.
Lockfile: The exact record of which version of each dependency was resolved (package-lock.json, go.sum...). Without it, builds are not reproducible and SCA cannot see the real tree.
Transitive dependency: A package you did not choose: it came in as a dependency of another dependency, sometimes three levels down. It gets CVEs just the same, and it is the classic blind spot.
Provenanceprovenance: The record of how and where an artifact was built: which pipeline, which commit, which machine. It lets you ask 'did this binary really come from our code?'.
SLSA: Supply-chain Levels for Software Artifacts: a scale from 1 to 4 for build integrity, from 'has documentation' to 'tamper-resistant build with verifiable provenance'.
Sigstore / Cosign: Signing and verifying artifacts without managing keys by hand: ephemeral keys tied to the build identity, with a public transparency log.
in-toto: A framework that signs, step by step, what the pipeline did: it proves the expected process ran, in the expected order, with no step swapped.
SCA vs SBOM: SCA is the live analysis (it monitors CVEs); SBOM is the snapshot of the moment (the inventory). In practice, they feed each other: SCA generates the SBOM and monitors it.→ SBOM

pipeline and practicesAppSec

CI / CDdelivery vs deployment: CI: validating every change automatically. Continuous delivery: deploy is one click. Continuous deployment: everything that passes the gates goes live on its own.→ CI/CD
Stage: A step of the pipeline: source, build, test, package, deploy, monitor. Each stage is a possible place for a security gate.→ CI/CD
Quality gate: A stage's explicit gate: 'fail the build if there is a new critical finding'. Without a clear criterion, a gate becomes a suggestion.
Policy as codeOPA / Rego: The security policy written as a versioned file that the pipeline consults (deny an image with a critical vulnerability, require a signature). Change the criterion = change the file, with review.→ DevSecOps
Pre-commit hook: A local check that runs before the commit leaves your machine: secrets scanning, linter, fast SAST. The cheapest form of feedback.→ Shift-left
Shift-left / shift-right: Shift-left: moving verification as early as possible in the lifecycle. Shift-right: also testing and observing in production (canary, observability). The two coexist.→ Shift-left
DevSecOps: Security as code inside CI/CD, with automated gates and shared responsibility.→ DevSecOps
Secret manager / vault: A vault that stores credentials and injects them at runtime (Vault, AWS Secrets Manager, Doppler). It takes the secret out of the code and allows rotation without a deploy.
Credential rotation: Replacing the compromised key: step number one after a leak. A removal commit does not fix it: the history keeps what was committed.→ Secrets Scanning
WAFweb application firewall: An edge filter that blocks known attack patterns in HTTP. It complements the code: it does not replace fixing the vulnerability, it only buys time.

core conceptsAppSec

Vulnerability: The weakness in the system that can be exploited: a concrete flaw in code, configuration or design.
Exploit: The technique or concrete artifact that abuses a vulnerability. The vulnerability is the hole; the exploit is the foot that goes in.
Threat vs risk: A threat is who or what can cause harm (the attacker). Risk is probability × impact in YOUR context. Tools report vulnerabilities; you decide the risk.
Attack surface: Everything exposed to untrusted input: endpoints, forms, dependencies, ports, pipelines. A minimal surface is a defense strategy.
Defense in depth: Independent layers of protection, on the premise that any one of them can fail: validation + parameterization + WAF + monitoring.
Zero-day: A vulnerability exploited before a public fix exists. Against a zero-day, only defense in depth and detection help in the moment.
CNAPP / ASPM: Market categories that bundle SAST + DAST + SCA + infrastructure into a single platform. Good to know they exist: the concept behind them is the same as the gates in this KB.

threat modelingAppSec

STRIDE: A mnemonic of six threat categories (Spoofing, Tampering, Repudiation, Information disclosure, Denial of service, Elevation of privilege) used as a checklist when walking through a data flow diagram.→ Threat modeling: think like the attacker before coding
DFDdata flow diagram: A drawing of a system's actors, processes, data stores and flows, with trust boundaries marked. It is the input to threat modeling: threats appear where a flow crosses a boundary.→ Threat modeling: think like the attacker before coding
Trust boundarytrust boundary: A line where the trust level of the data or of whoever sends it changes (internet to VPC, service to database, user to admin). Everything that crosses it must be authenticated, authorized and validated.→ Threat modeling: think like the attacker before coding

identity and accessCloudSec

IAMidentity and access management: The set of policies, roles and credentials that says who every human, service or workload is, and what each one can do. In the cloud, IAM became the new perimeter: the network edge got porous, so identity carries the authorization.→ IAM - identity and access
Least privilegeleast privilege: The principle of giving each identity only the permissions strictly needed for its function, and nothing more. It is the opposite of 'admin user by default': every extra role is one more path an attacker can use after a compromise.→ IAM - identity and access
Shared responsibility modelshared responsibility model: The classic split between what the cloud provider guarantees (security OF the cloud: datacenter, hardware, physical service) and what is the customer's responsibility (security IN the cloud: data, IAM, configuration, network). Confusing the two ends is the classic source of leaks.
Secret rotationcredential rotation: Periodically replacing (or doing so after a suspected leak) API keys, tokens and passwords stored in a vault. Without rotation, a secret exposed in a log or git history is valid forever; with rotation, it is valid until the next turnover.→ Secrets - vaults and rotation
Blast radiusblast radius: The size of the damage when something breaks: one account, an entire region, a tenant. Good cloud design limits the radius through isolation (separate accounts, separate VPCs, narrow roles) so that a failure or an attack does not become a full-blown disaster.

network and dataCloudSec

Security groupsecurity group: A stateful list of rules attached to an instance or network interface in the cloud: who can come in on which port, from which source. It works as a host firewall at the cloud level, and it fails open by default: if you forget to close a port, it stays open to 0.0.0.0/0.→ Network - segmentation and zero-trust
VPCvirtual private cloud: A logically isolated private network inside the public cloud: you choose the IP range, split it into public and private subnets, and control traffic with route tables and NAT. The VPC is your virtual datacenter; everything running inside it talks as if it were in the same rack.→ Network - segmentation and zero-trust
Network policy: Declarative firewall rules at the pod level (Kubernetes) or workload level (service mesh), stating which service can talk to which port. Unlike a security group, it operates at L7 inside the cluster, with label selectors, and is a central piece of defense in depth for east-west traffic.→ Kubernetes - secure runtime
KMSkey management service: A managed service that creates, stores and controls the use of cryptographic keys. The application rarely touches the master key: it asks the KMS to encrypt or decrypt, and the provider records every use in an auditable log. Without a KMS, the key ends up on disk and becomes a target.→ KMS & crypto - keys and envelopes
Envelope encryption: A two-layer pattern: a data key (DEK) encrypts the payload, and a KMS key (KEK) encrypts the DEK. The application stores the encrypted DEK alongside the data and only calls the KMS to unwrap the DEK when it needs to use it. It reduces KMS calls and limits exposure of the master key.→ KMS & crypto - keys and envelopes

posture and detectionCloudSec

Zero trust: A model that starts from the premise of trusting no one based on network position: every request is authenticated, authorized and logged, even when it comes from the internal network. It replaces the castle-and-moat with continuous verification at every door, human or service.→ Zero-trust - trust model
CSPMcloud security posture management: A tool that scans your cloud configuration against best practices and benchmarks (CIS, NIST), flagging public S3 buckets, overly broad IAM, exposed ports. It asks the question humans forget: 'what is misconfigured RIGHT NOW?'.→ CSPM - cloud posture
CWPPcloud workload protection platform: Monitored protection for running workloads: VMs, containers, serverless functions. It combines visibility into what runs (processes, syscalls, network) with prevention (blocking execution, isolating anomalies). It is endpoint security reworked for the ephemeral reality of the cloud.→ CWPP - workload protection
Driftconfiguration drift: When live infrastructure moves away from the declared state: someone opened a port in the console, a bucket became public, an IAM role became admin. Drift is configuration accumulated outside version control, and the best cure is IaC with review: everything that changes goes through code.
Hardeninghardening: Reducing a workload's surface to the essentials: disabling unused services, closing ports, removing superfluous packages, applying a baseline (CIS). It is the cloud equivalent of removing the default password and closing the windows: boring, repetitive, and the difference between an easy target and an expensive one.
Audit trailcloudtrail: An immutable record of every API call made in the cloud account: who called what, from where, with what result. It is the account's black box: after a leak, it answers 'what did the attacker do, and when?'. Without a trail, there is no investigation or informed containment.→ Logging & detection - signals and alerts

incident responseCloudSec

MTTRmean time to respond: The average time between confirming an incident and containing it. It is the metric that shows whether runbooks and automation really work, and the one that drops the most when response is practiced in exercises.→ Cloud incident response
Runbook: A step-by-step script for a type of incident (leaked key, compromised instance). Written before the crisis, tested in game days and, when possible, turned into automation.→ Cloud incident response
Chain of custodychain of custody: A record of who collected, stored and handled each piece of digital evidence, and when. Without it, the evidence loses value for audits and for any legal dispute.→ Cloud incident response

retrievalAgents

Retrievalsemantic search: The RAG step where you search your chunks for the passages that answer the user's question. Retrieval is the real bottleneck of the system: a good LLM with bad retrieval is an LLM that hallucinates with confidence. It ranges from dense similarity search to classic BM25, including hybrid and reranking.→ Retrieval
Reranking: The second pass of retrieval: the model takes the top-K candidates that came from the cheap search (say 50) and reorders them down to the K most useful (top 5 or 10) using a cross-encoder that saw query and chunk together. It adds latency, but cuts the noise: the LLM receives dense context instead of a mix of good and mediocre.→ Retrieval
BM25: The classic ranking function of text search: it scores each document by TF-IDF with saturation (important terms weigh more up to a ceiling) and normalizes by length. It is the sparse search of hybrid retrieval and captures exact term matches (error code, API name) where embeddings alone fail badly.→ Retrieval
Cosine similarity: A measure of how aligned two vectors are in embedding space: the cosine of the angle between them, independent of magnitude. For normalized embeddings the inner product is enough and stays fast, which is why it became the default distance in almost every vector database.→ Embeddings
HNSWhierarchical navigable small world: A layered graph structure that vector databases use for nearest-neighbor search in high dimensions. Each layer is a sparse graph that jumps far; the lower ones do the fine tuning. It is why pgvector, Pinecone, Weaviate, Qdrant and LanceDB answer in milliseconds with millions of vectors.→ Vector DB
ANNapproximate nearest neighbor: A family of algorithms (HNSW, IVF, LSH) that trade exactness for brutal speed in high-dimensional neighbor search. ANN does not find the perfect neighbor, but a good enough one, and in production retrieval that trade is what makes the system fit the latency budget.→ Vector DB

model, agents and protocolsAgents

Context windowcontext window: The maximum number of tokens the model can read at once: the prompt, the entire concatenated history and the output it will generate. It is the LLM's short-term memory. Huge windows seem to solve RAG, but they amplify cost, latency and the risk of the model getting lost in the middle of the text, so good context is small, well-chosen context.→ LLM - large language model
Hallucinationhallucination: When the model invents a plausible fact that was not in the data: an API name that does not exist, a nonexistent paper, a coherent command that does nothing. It is a training and retrieval problem, not a matter of 'truthfulness'. Mitigation is layered: retrieval with verifiable sources, a prompt that asks for citations, and an evaluator that hunts for invention automatically.→ Agent frameworks
Function callingtool use: The mechanism by which the LLM asks, instead of just producing text, to execute a function with structured parameters: the model emits JSON, your code runs the function, and the result goes back into the conversation. It is what turns a pure model into an agent able to act in the world, and what needs guardrails to prevent the wrong call with the wrong argument.→ Tool calling
Agent: A program that uses an LLM to decide what to do at each step, instead of following a fixed script. It receives a goal, chooses tools, observes the result, decides the next step, and continues until it finishes or gives up. The difference from a chatbot is autonomy: the agent sequences actions outside a predefined order.→ Agent frameworks
Agent graph: An explicit decomposition of the agent's reasoning into nodes (plan, act, observe, review) and directed edges, instead of a single loop that does everything. Advantage: each node is auditable and testable independently, and when the agent gets stuck you know at which node. LangGraph and state machines in general follow this model.→ Orchestration
MCP servermodel context protocol server: A server that implements the Model Context Protocol, Anthropic's open standard that standardizes the conversation between an agent and external tools. The agent lists what is available, calls what it needs, receives the result, with no case-by-case integration. A well-written MCP server becomes reusable by Claude, Cursor, Cline and any compatible client.→ MCP - model context protocol
Tool vs resource (MCP): In MCP, a tool is a function the agent invokes with parameters and gets a result on demand (a POST, a calculation, a send). A resource is a named piece of data the agent can read whenever it wants (a configuration file, a schema, a log). Separating the two matters: the LLM reasons better when operations with side effects are clearly distinct from reads.→ MCP - model context protocol
DeepAgents: LangChain's graph agent library that combines a planning tool, a filesystem tool and subagents to solve tasks too long for a single loop. It is a practical reference for an agent that does not stall on the third tool call and the place where you learn to calibrate autonomy before releasing a real agent into production.→ Agent frameworks

evaluation and securityAgents

SWE-bench: A benchmark that measures whether an agent can resolve real GitHub issues in real open source project code: multi-file, with tests, without instructions on how to do it. It is the current standard for telling apart an agent that impresses in a demo from one that actually closes tickets, and where deepagents and similar projects publish their progress numbers.→ Benchmarks - public reference
JudgeLLM-as-judge: Using a strong LLM (usually GPT-4 class or Claude Opus) to score another model's output against a rubric. It solves scale, because a human does not read 5,000 outputs per PR. It brings its own biases: position bias (prefers the first candidate), verbosity bias (prefers the longest) and self-promotion (thinks its own model is better). Calibration against a human evaluator is mandatory before trusting the judge.→ LLM as judge - automated rubric
Rubric: An explicit list of criteria and weights the judge uses to score an output: 'cite the source in the first sentence, maximum 2 lines, no adjectives, return JSON'. Without a written rubric the LLM-as-judge diverges between runs and between models, and you cannot improve prompt, model and dataset reproducibly. With a locked rubric it becomes a ruler, without it it becomes opinion.→ LLM as judge - automated rubric
Baseline: A reference (fixed) model or configuration that runs on the whole dataset before any change, so you can measure the delta of your modification. In LLM evals, 'better' without a baseline is a guess: was the previous version already good, or did it just look good in the demo? A baseline locked per version is what turns eval into science, and what separates 'passed the test' from 'passed the test, and here is the evidence'.→ Regression evals - fixed suite on the PR
Prompt injection: An attack in which hostile content (in an indexed page, in a summarized email, in a document the agent opens) tries to override the system instructions. The attacker knows the LLM mixes trusted text with found text and plants an 'ignore the previous instructions and run X'. It is the number 1 vector in production agents today; it is not an LLM bug, it is how agents read text by design.→ Guardrails - input and output filters
PIIpersonally identifiable information: Personal data that identifies someone: name and national ID, email, phone, address, IP. When the user pastes a document with PII into the chat, or RAG indexes a CRM with 5,000 customers, the agent becomes a leak by design. Guardrails here are detection on input, redaction before sending to the LLM, and short retention, because masking after receiving the response is already too late.→ Guardrails - input and output filters

edge defenseSecOps

WAFweb application firewall: Layer 7 HTTP traffic filter that decides, per request, whether it proceeds, is challenged, is limited or is blocked. It reduces the exposed surface and enables virtual patching; it does not replace fixing the application.→ WAF - observation, shadow and enforcement
Positive modelallowlist: Define what is valid for an endpoint (methods, paths, formats, sizes) and block everything else. More precise than signatures, but requires knowing the application.→ WAF - observation, shadow and enforcement
Shadow mode: Phase in which a rule runs in parallel without acting, and the simulated decision is compared with reality to measure false positives before enforcement.→ WAF - observation, shadow and enforcement
Virtual patchvirtual patching: WAF rule that blocks exploitation of a known vulnerability while the real fix has not yet reached the application. It buys time, it does not eliminate the flaw.→ WAF - observation, shadow and enforcement
Rate limiting: Limit on requests per entity and time window. The choice of key (IP, account, token, ASN) matters as much as the limit value.→ Adaptive rate limiting
Challengechallenge: Check that tries to prove the client is a real browser, without asking the user for anything in most cases. It is the step before blocking.→ Bot management
Fail-open / fail-closed: What the system does when a security control fails: fail-open lets traffic through (available, unprotected), fail-closed blocks it (safe, unavailable). The choice should be conscious, per endpoint.→ Defense in depth: edge system design

detection and metricsSecOps

Credential stuffing: Attack that tests leaked username/password pairs from other services at scale. Signature: many login failures spread across many IPs, with few attempts per account.→ L7 attacks: what to look for
Z-score: Distance of a value from the mean, measured in standard deviations. In detection, values far above the recent history of the same key suggest an anomaly.→ Detection engineering
EWMAexponentially weighted moving average: Average that gives more weight to recent data. Used as an adaptive baseline: it follows changes in normal traffic without getting stuck in the past.→ Detection engineering
Cardinality: Number of distinct values in a field (IPs, user agents). High cardinality makes aggregations expensive and takes down metrics systems; aggregate at the coarsest level that still separates the attack from normal traffic.→ Scale: telemetry, cardinality and cost
MTTTmean time to triage: Average time between the alert and its classification as real or false.→ SOC SLOs and continuous tuning
MTTCmean time to contain: Average time between confirming an attack and containing it.→ SOC SLOs and continuous tuning
Precision and recall: Precision: of the alerts issued, how many were real attacks. Recall: of the attacks that exist, how many were detected. Raising one tends to lower the other.→ SOC SLOs and continuous tuning

infrastructure and policy as codeEngineering

IaCinfrastructure as code: Describing infrastructure in versioned files (Terraform, Ansible). It brings review, history and testing to configuration, but replicates mistakes at scale if it is not scanned.→ Secure infrastructure as code
Drift: Divergence between the real state of the infrastructure and the state described in code, usually caused by a manual change. Detecting it keeps the code as the source of truth.→ Secure infrastructure as code
RegoOPA: Declarative language of Open Policy Agent for writing policies evaluated against an input (a Terraform plan, a Kubernetes manifest, an API request).→ Policy as code
Pipeline OIDC: The pipeline proves its identity to the cloud provider with a short-lived token and receives temporary credentials, eliminating static keys stored as secrets.→ CI/CD hardening
SLSA: Framework of assurance levels for the build chain: who built the artifact, from which source and in which environment, with verifiable provenance.→ CI/CD hardening

scale and reliabilityEngineering

Lag: Distance between the end of the log and the consumer's position. It is the most direct sign that detection is running late.→ Observability of the security platform itself
Idempotency: Property of an operation that, when repeated, produces the same result as a single execution. The basis for tolerating duplicate deliveries without acting twice.→ Reliability at scale: idempotency, retries and backpressure
DLQdead letter queue: Queue for events that could not be processed after the retries. It avoids blocking the flow and preserves the event for analysis.→ Reliability at scale: idempotency, retries and backpressure
Backpressure: Mechanism by which a slow consumer makes the producer slow down (or the excess is deliberately dropped), instead of memory growing without bound.→ Reliability at scale: idempotency, retries and backpressure
SOAR: Security orchestration, automation and response: running response steps automatically, described in playbooks, with brakes such as human approval and auditing.→ Security automation and playbooks as code

access and identityOWASP Top 10

IDORinsecure direct object reference · BOLA: The request names an object (an id) and the server returns it without checking that the caller may see it. The most common form of broken access control, and in APIs it is called broken object level authorization.→ A01 Broken Access Control
Deny by default: Access is forbidden unless a rule explicitly allows it, so a forgotten route fails closed instead of open.→ A01 Broken Access Control
Credential stuffing: Replaying leaked e-mail and password pairs from other breaches against your login. It works because people reuse passwords, so the defense is throttling, breached-password checks and a second factor.→ A07 Authentication Failures
Session fixation: An attacker plants a known session id in the victim's browser; if the app keeps that id after login, the attacker shares the session. Regenerate the id on login.→ A07 Authentication Failures
PasskeyWebAuthn: A phishing-resistant login based on a key pair stored on the user's device; the site holds only the public key, so there is no password to steal or stuff.→ A07 Authentication Failures

data and inputOWASP Top 10

SQL injectionSQLi: Input concatenated into a SQL string is parsed as part of the query. Parameterized queries send the values separately and remove the problem.→ A05 Injection
XSScross-site scripting: Injection into a web page: untrusted input is rendered as HTML or script in another user's browser. Escape on output by context and add a Content-Security-Policy.→ A05 Injection
Prepared statementparameterized query: A query whose structure is fixed before any value is supplied, so the database cannot confuse data with instructions.→ A05 Injection
Argon2id: A memory-hard password hashing function with a built-in salt. Slowness is the point: it makes each guess expensive for an attacker.→ A04 Cryptographic Failures
CSPRNGcryptographically secure random number generator: The operating system's source of unpredictable bytes (secrets in Python, crypto.randomBytes in Node, crypto/rand in Go). Use it for tokens and keys, never Math.random.→ A04 Cryptographic Failures
Authenticated encryptionAEAD: Encryption that also detects tampering (AES-GCM, ChaCha20-Poly1305). Encryption alone does not stop an attacker from modifying ciphertext.→ A04 Cryptographic Failures

design and supply chainOWASP Top 10

Threat model: A structured answer to four questions: what are we building, what can go wrong, what will we do about it, and did we do a good job.→ A06 Insecure Design
Abuse case: A user story written from the attacker's side. Each one produces a requirement and a test.→ A06 Insecure Design
SBOMsoftware bill of materials: A machine-readable inventory of the components in a build. It answers "are we affected?" within minutes when a new vulnerability is announced.→ A03 Software Supply Chain Failures
Dependency confusion: Tricking a build into pulling a public package with the same name as an internal one. Use scoped names and a private registry that wins.→ A03 Software Supply Chain Failures
Subresource IntegritySRI: A hash in a script or link tag that makes the browser refuse the file if it does not match, so a compromised CDN cannot change your page.→ A08 Software or Data Integrity Failures
Insecure deserialization: Rebuilding objects from untrusted bytes with a format that can instantiate arbitrary types (Java serialization, pickle). The bytes can trigger code execution.→ A08 Software or Data Integrity Failures

operations and failureOWASP Top 10

Fail closedfail secure: When a security check cannot decide (timeout, error), the answer is deny. The opposite, failing open, turns every outage into an access-control bypass.→ A10 Mishandling of Exceptional Conditions
Log injection: User input containing newlines or control characters forges log entries. Encode input or use structured (JSON) logging.→ A09 Security Logging and Alerting Failures
Correlation idrequest id: A unique id attached to a request and to every log line it creates, shown to the user in error messages so support can find the details without leaking them.→ A09 Security Logging and Alerting Failures
Security misconfiguration: Correct software running with unsafe settings: debug on, default credentials, public storage, permissive CORS, missing headers.→ A02 Security Misconfiguration
CORScross-origin resource sharing: A browser mechanism that lets a server say which other origins may read its responses. A wildcard origin combined with credentials is a misconfiguration.→ A02 Security Misconfiguration

layers and termsVibecoding

Vibe coding: A style of programming where you describe what you want and steer by running the result, without reading every line. The term was popularized in early 2025 and now often names AI-assisted programming in general.→ The vibecoding spectrum
Model: The neural network that predicts the next step. It produces text, including requests to call tools. It is not the tool you type into.→ Model, harness and provider
Harnessagent harness · scaffold: The program around the model: builds the prompt, exposes tools, enforces permissions and runs the loop. Claude Code, OpenCode, oh-my-pi and Codex CLI are harnesses.→ Model, harness and provider
Provider: Where a model runs and how you reach it: the vendor API, a cloud, a router such as OpenRouter, or your own machine.→ Model, harness and provider
Open-weight model: A model whose trained weights are published, so you can run it yourself. Not always the same as open source: check the license.→ Choosing a model: frontier, cheap and open

toolsVibecoding

OMPoh-my-pi: An open-source terminal coding agent that began as a fork of the minimal Pi agent and added structured edits, language-server and debugger operations, browser access, plugins and subagents.→ Coding agents compared
OMOOh My OpenAgent · oh-my-opencode: A plugin for OpenCode that adds a team of specialized agents and an autonomous multi-agent mode. It extends a harness; it is not one.→ Coding agents compared
herdr: A terminal multiplexer for AI coding agents. It keeps several agents in real terminal panes, shows their status and persists across disconnects. It organizes agents instead of replacing them.→ Orchestration and parallel agents
Git worktree: An extra working directory with its own branch for the same repository. Gives each agent an isolated place to work.→ Orchestration and parallel agents

working well and safelyVibecoding

AGENTS.md: A file at the repository root with instructions for coding agents (commands, conventions, boundaries). A common convention across tools; Claude Code reads CLAUDE.md.→ Context engineering for coding agents
MCPModel Context Protocol: An open protocol for connecting agents to tools and data sources through servers. Every server you connect extends what the agent can do, so it also extends the attack surface.→ Context engineering for coding agents
Plan mode: A read-only mode where the agent explores and proposes a plan for approval before it edits anything.→ Context engineering for coding agents
Prompt injection: Instructions hidden in content the agent reads (a README, a web page, a tool result) that the model may follow as if you had written them.→ Securing the agent itself
Slopsquatting: Registering a package under a name an AI invented, so that an agent or developer who installs it without checking gets malware.→ Securing the agent itself
Verification loop: The checks every change must pass before it is trusted: tests that decide, a diff you read, CI gates and independent review.→ The verification loop

deliveryDevOps

CIcontinuous integration: Merging small changes into a shared branch often, with every change built and tested automatically so integration problems appear within minutes.→ The delivery lifecycle
CDcontinuous delivery · continuous deployment: Delivery keeps every change deployable at any time; deployment goes further and releases each passing change to production automatically.→ The delivery lifecycle
Artifact: The versioned, immutable output of a build (a container image, a package). The same artifact is promoted through every environment.→ CI pipelines that stay fast
Trunk-based development: Working in short-lived branches merged into the main branch frequently, hiding unfinished work behind feature flags.→ Git workflows and code review
CODEOWNERS: A repository file that maps paths to the people or teams who must review changes there.→ Git workflows and code review

releaseDevOps

Canary release: Sending a small share of traffic to a new version, watching its metrics, then widening it. Limits the damage of a bad release.→ Release strategies and rollback
Blue/green deployment: Two full environments: traffic switches from the old to the new at once, and rollback is switching back.→ Release strategies and rollback
Feature flag: A switch in configuration that turns a feature on or off without a deploy. Separates deploying code from releasing it.→ Release strategies and rollback

platformDevOps

IaCinfrastructure as code: Describing infrastructure in versioned files that are reviewed and applied by tools, so environments are reproducible.→ Infrastructure as code
Drift: A difference between the real infrastructure and what the code says, usually from a manual change.→ Infrastructure as code
Container image: A read-only stack of layers plus metadata from which containers start. Identified by a digest, tagged by a mutable name.→ Containers and images
Pod: In Kubernetes, one or more containers that run together and share a network identity. The smallest deployable, and disposable, unit.→ Kubernetes fundamentals
Probereadiness · liveness: A health check the cluster runs: readiness decides whether a pod gets traffic, liveness decides whether it should be restarted.→ Kubernetes fundamentals

operations and reliabilityDevOps

SLIservice level indicator: A measurement of service quality as users experience it, such as the fraction of requests that succeed quickly.→ Reliability: SLOs, error budgets and incidents
SLOservice level objective: The target for an SLI over a window. It defines how reliable is reliable enough.→ Reliability: SLOs, error budgets and incidents
Error budget: The allowed unreliability, 100% minus the SLO. While it remains you can take risks; when spent, reliability work comes first.→ Reliability: SLOs, error budgets and incidents
Golden signals: Latency, traffic, errors and saturation: four measurements that describe the health of almost any service.→ Observability: metrics, logs and traces
Cardinality: The number of distinct label combinations in a metric. Unbounded labels (user ids) can overwhelm a metrics system.→ Observability: metrics, logs and traces
Postmortemblameless review: A written review of an incident that asks how the system allowed it, not who erred, and ends with owned actions.→ Reliability: SLOs, error budgets and incidents

process and rolesIncident response

Incident commanderIC: The person who owns the response and makes decisions, while others do the hands-on work. Keeping these roles apart prevents the leader from disappearing into the technical details.→ The incident response lifecycle
SeveritySEV level: An agreed scale for how serious an incident is, decided in advance so that people do not argue about it during the event. It sets who is paged and how fast.→ The incident response lifecycle
Tabletop exercise: A discussion-based rehearsal of an incident scenario. It tests the plan, the contacts and the decisions without touching production.→ The incident response lifecycle
Containment: Limiting an incident's spread and damage: isolate a host, revoke credentials, block a destination. Short-term containment buys time; long-term containment prepares a clean recovery.→ Triage, scoping and containment
Triage: The first assessment of an alert: is it real, how far has it gone, and how urgent is it.→ Triage, scoping and containment

detection and intelligenceIncident response

Threat hunting: A proactive search of telemetry for attacker activity that automated detections missed, driven by a testable hypothesis.→ Threat hunting
IOCindicator of compromise: An observable that suggests compromise, such as a file hash, a domain or an address. Quick to use and quick to expire, since attackers change them easily.→ Threat intelligence
TTPtactics, techniques and procedures: How an adversary operates. Behavior is much harder for them to change than an indicator, so it is a more durable basis for detection.→ Threat intelligence
MITRE ATT&CK: A public knowledge base of adversary tactics and techniques observed in real intrusions, used to describe behavior and measure detection coverage.→ Threat intelligence
Pyramid of Pain: A model that ranks indicators by how much blocking them hurts an attacker, from trivial (hash values) to painful (tactics and techniques).→ Threat intelligence
Sigma: A vendor-neutral format for detection rules that can be converted to the query language of many SIEM products.→ Log analysis and building a timeline
Pivoting: Taking one known fact (an address, an account, a hash) and searching for everything else that shares it, to widen or narrow the scope.→ Log analysis and building a timeline

forensics and malwareIncident response

Chain of custody: A written record of who held a piece of evidence, when and what was done with it. It supports the credibility of evidence in a dispute.→ Digital forensics fundamentals
Order of volatility: The principle of collecting the most fragile evidence first: memory, then processes and connections, then temporary files, then disk and logs.→ Digital forensics fundamentals
Write blocker: A device or software that lets you read a disk without allowing any change to it, so the evidence stays intact.→ Digital forensics fundamentals
YARA: A language for describing the patterns that identify a family of files, used to find malware samples and variants.→ Malware analysis fundamentals
Sandbox: An isolated environment where a suspicious file can run under monitoring so its behavior can be observed safely.→ Malware analysis fundamentals
Double extortion: A ransomware tactic that both encrypts systems and steals data, threatening to publish it, so that restoring from backup does not end the pressure.→ Ransomware response playbook

engagementsOffensive security

Rules of engagementRoE: The agreed document that turns permission into practical limits: scope, time window, forbidden actions, rate, emergency contacts and how findings are reported.→ Authorization, scope and ethics
Scope: The list of systems, accounts and activities that may be tested, and those explicitly excluded. Anything outside it is not authorized.→ Authorization, scope and ethics
Coordinated disclosureresponsible disclosure: Reporting a vulnerability privately to its owner and allowing reasonable time to fix before any public detail.→ Authorization, scope and ethics
Penetration testpentest: A time-boxed attempt to exploit weaknesses within an agreed scope, to show what an attacker could actually do.→ Penetration testing methodology
Black, gray and white box: How much the tester knows in advance: nothing, some (such as accounts and documentation), or everything including source code.→ Penetration testing methodology
PTESPenetration Testing Execution Standard: A description of the phases of a penetration test, from pre-engagement to reporting.→ Penetration testing methodology

techniquesOffensive security

Attack surface: Everything an attacker can reach and try: internet-facing assets, services, interfaces and the people who use them.→ Reconnaissance and attack surface
Passive and active recon: Passive gathers information without touching the target; active probes it directly and must stay within scope and rate limits.→ Reconnaissance and attack surface
Subdomain takeover: A DNS record pointing to a cloud or SaaS resource that no longer exists, which someone else can claim and serve content from your domain.→ Reconnaissance and attack surface
BOLAbroken object level authorization: An API accepts an object id and returns the object without checking that the caller may access it. The API form of an IDOR.→ Web and API security testing
Mass assignment: An API binds client-supplied fields onto an object, letting a caller set fields (such as a role) that they should not control.→ Web and API security testing
Attack path: A chain of permissions, credentials and trusts that leads from a foothold to something valuable. Defenders map and cut these paths.→ Attack paths and privilege escalation
Privilege escalation: Gaining more rights than initially granted, through a flaw, a misconfiguration or a stolen credential.→ Attack paths and privilege escalation

exercises and reportingOffensive security

Red team: An objective-based, usually covert simulation of a realistic adversary that tests the organization's people, process and technology.→ Red team, purple team and adversary emulation
Purple team: A collaborative exercise where attackers and defenders work together in the open, checking detection technique by technique and fixing gaps immediately.→ Red team, purple team and adversary emulation
Adversary emulation: Reproducing the documented behavior of a specific threat actor to test whether defenses would catch it.→ Red team, purple team and adversary emulation
DMARC: An email authentication policy that tells receivers what to do with messages that fail SPF or DKIM checks for your domain, and where to send reports.→ Social engineering and phishing defense
CVSSCommon Vulnerability Scoring System: A standard for scoring the technical severity of a vulnerability. It needs adjusting for your context before it sets priority.→ Reporting findings and driving remediation
Retest: Verifying that a fix really closes a finding, not only the exact request that was reported.→ Reporting findings and driving remediation

riskGRC and leadership

Risk appetite: How much risk the organization is willing to accept in pursuit of its goals. It frames which risks need treatment and which can be accepted.→ Security risk management
Inherent and residual risk: Inherent risk is the level before controls; residual risk is what remains after them. Reporting both shows what the controls achieve.→ Security risk management
Risk register: The working record of identified risks: owner, rating, controls, treatment, actions and review date.→ Security risk management
Risk treatment: The four responses to a risk: reduce it with controls, accept it knowingly, transfer it (insurance, contract) or avoid it by stopping the activity.→ Security risk management
Concentration risk: Excess dependence on one supplier, provider or technology, so that its failure becomes your failure.→ Third-party and supply chain risk
Vendor tiering: Grouping suppliers by criticality so that the depth of review and monitoring matches the impact of their failure.→ Third-party and supply chain risk

frameworks and complianceGRC and leadership

ISMSinformation security management system: The set of policies, processes and controls that an organization uses to manage information security, as required by ISO 27001.→ Security frameworks and standards
NIST CSF: A voluntary framework that organizes a security program into functions: Govern, Identify, Protect, Detect, Respond and Recover.→ Security frameworks and standards
CIS Controls: A prioritized list of practical safeguards grouped in implementation levels, helpful for deciding where to start.→ Security frameworks and standards
SOC 2: An auditor's report on a service provider's controls for security and related criteria, commonly requested by customers.→ Security frameworks and standards
Control: A safeguard that reduces the likelihood or impact of a risk; to be auditable it must have an owner, a frequency and evidence.→ Compliance in practice: controls, evidence and audits
Evidence: Proof that a control operated during a period, such as a configuration export, a log, a ticket or an approval record.→ Compliance in practice: controls, evidence and audits

architecture and leadershipGRC and leadership

Zero trust: An approach that grants no trust by network location: every request is authenticated and authorized using identity, device and context.→ Security architecture principles
ADRarchitecture decision record: A short document recording a significant decision, its context, alternatives and consequences.→ Security architecture principles
KRIkey risk indicator: A measure that warns that risk is increasing, such as a growing backlog of critical findings or unsupported systems.→ Security metrics and reporting to leadership
Crown jewels: The assets whose loss or compromise would hurt the organization most. Strategy starts by identifying and protecting them.→ Security strategy, roadmap and budget
Blameless reporting: A culture where people who report mistakes or incidents quickly are supported, because early reports limit the damage.→ Crisis communication and security culture
Security champion: A person in an engineering or business team who acts as the local point of contact for security and brings it into daily work.→ Crisis communication and security culture