Security Glossary
Key terms from the Security course, linked to the lesson that introduces each one.
934 terms.
A
- Absolute Timeout
- Absolute Timeout means the session dies after a fixed duration from creation, regardless of activity.
- Lesson 733 — Session Timeout Configurations
- Access control and identity management
- You configure who can access the application, what permissions they have, and how they authenticate. Weak passwords or overly permissive sharing settings are customer failures.
- Lesson 1688 — Shared Responsibility in SaaS
- access control vestibule
- A mantrap (also called an access control vestibule) is a small room with two interlocking doors.
- Lesson 2282 — Mantrap and Turnstile Controls
- Access patterns
- A user who typically accesses 3 databases now queries 47 different ones
- Lesson 1890 — Behavioral Analytics and Anomaly Detection
- access right
- The access right is especially important—individuals must receive copies within 30 days (extendable once by 30 days).
- Lesson 2583 — HIPAA Privacy Rule Requirements
- Access tokens
- Access tokens are short-lived credentials (typically 15 minutes to 1 hour) that your application presents to protected APIs.
- Lesson 760 — OAuth 2.0 Tokens: Access and Refresh
- Achievable
- Set realistic targets. Aiming for "zero vulnerabilities" sounds great but is impractical; "95% of critical vulnerabilities patched within 14 days" is achievable.
- Lesson 2526 — Designing Effective Security Metrics
- action
- The action is what the subject wants to do to the object:
- Lesson 795 — Access Control Fundamentals
- Actions
- Actions are the actual tasks performed: query a threat feed, isolate an endpoint, disable a user account, send a notification to Slack, create a ticket in your ITSM platform, or extract indicators from an email attachment.
- Lesson 2327 — Playbook Design Fundamentals
- Active Learning Strategies
- Smart attackers use uncertainty sampling—querying inputs where their current substitute model is least confident, maximizing information gain per query. This dramatically reduces the number of queries needed.
- Lesson 2828 — Query-Based Model Stealing
- Active reconnaissance
- Active reconnaissance means directly interacting with the target to gather information.
- Lesson 337 — Active vs Passive Reconnaissance
- Admission webhooks
- Admission webhooks are custom HTTP callbacks that let you inject your own policy logic into this checkpoint.
- Lesson 1649 — Admission Controllers and Policy Enforcement
- Agency Authorization
- A single agency sponsors and authorizes your cloud service for their use. Other agencies can leverage this with less effort.
- Lesson 2613 — FedRAMP Authorization Framework
- Agent Resource Usage
- EDR agents are resource-intensive because they collect real-time telemetry from multiple system layers. Before deployment, benchmark your endpoints to understand typical CPU and memory utilization, then factor in the EDR agent's expected overhead (typically 2-5% CPU and 100-300MB RAM, varying by vendor and configuration).
- Lesson 1583 — EDR Deployment and Performance Considerations
- Aggregation
- Aggregation means collecting results from all security tools into a centralized location—a security dashboard, database, or tracking system.
- Lesson 1309 — Vulnerability Aggregation and DeduplicationLesson 1402 — Security Test Results Management
- Alert triage
- Alert triage is the critical skill of rapidly sorting security alerts to identify genuine threats (true positives) from benign activity (false positives).
- Lesson 1578 — EDR Alert Triage and InvestigationLesson 2308 — SOC Analyst Responsibilities and Workflows
- Alert-to-Incident Ratio
- This compares total alerts generated to actual confirmed incidents. If you receive 1,000 alerts but only 50 become incidents, your ratio is 20:1. Lower ratios mean better signal-to-noise. World-class SOCs aim for ratios below 10:1, while immature programs often suffer ratios exceeding 100:1.
- Lesson 2354 — Alert Quality Metrics
- ALLOW-FROM uri
- Your page can be framed only by the specified origin. Note: this directive is obsolete and poorly supported; use Content Security Policy's frame-ancestors directive instead for specific origin allowlists.
- Lesson 1135 — X-Frame-Options Header
- Amazon Macie
- Amazon Macie is AWS's managed service for automated storage security.
- Lesson 1791 — Storage Security Scanning and Macie
- Analogy
- If the role gives you a master key to multiple rooms, a session policy is like saying "for this visit, I only want access to Room 3." You voluntarily limit yourself.
- Lesson 162 — Elliptic Curve Point OperationsLesson 390 — ARP Spoofing Defense MechanismsLesson 1221 — HTML Entity Encoding and Attribute ContextLesson 1656 — Read-Only Filesystems and tmpfsLesson 1732 — Role Chaining and Session Policies
- Anonymization
- Anonymization is the irreversible process of removing or destroying all identifiable information from data so that individuals can never be re-identified, even with additional information.
- Lesson 2902 — Anonymization vs. Pseudonymization
- API call behavior
- A service account that normally makes 20 S3 API calls per hour suddenly makes 5,000
- Lesson 1890 — Behavioral Analytics and Anomaly Detection
- API key metadata
- Track which keys are used by which services for targeted rotation
- Lesson 1348 — API Key and Certificate Rotation
- API Server
- The API server is Kubernetes' control center—every command, deployment, and configuration change flows through it.
- Lesson 1662 — Kubernetes Architecture and Attack SurfaceLesson 1968 — Kubernetes Security Architecture Overview
- Application code security
- preventing SQL injection, XSS, and other vulnerabilities
- Lesson 1687 — Shared Responsibility in PaaS
- application-level retrieval
- Instead of having secrets pre-loaded into environment variables or mounted files before your application starts, application-level retrieval means your code actively connects to a secret store (like Vault, AWS Secrets Manager, or Azure Key Vault) at runtime and fetches the secrets it needs.
- Lesson 1339 — Application-Level Secret Retrieval
- approximate differential privacy
- It provides what's called approximate differential privacy (or (ε,δ)-DP), where δ represents a small probability that the stronger privacy guarantee might fail.
- Lesson 2916 — The Gaussian Mechanism and Advanced Noise
- Architecture review
- Architecture review means examining your system's design documents, diagrams, and planned structure to identify potential security weaknesses before developers start coding.
- Lesson 78 — Architecture Review and Threat Identification
- architecture-level attack tree
- An architecture-level attack tree is a hierarchical diagram where:
- Lesson 2641 — Architecture-Level Attack Trees
- Argon2
- Argon2 is newer and comes in three variants: Argon2d (resistant to GPU attacks), Argon2i (resistant to side-channel attacks), and Argon2id (hybrid, recommended for password hashing).
- Lesson 139 — Modern KDFs: scrypt, Argon2, and HKDF
- ARP spoofing
- This creates an attack vector called ARP spoofing or ARP poisoning.
- Lesson 384 — ARP Protocol Fundamentals and Security Weaknesses
- asset
- An asset is anything of value—customer data, intellectual property, authentication tokens, configuration secrets.
- Lesson 2638 — Identifying Assets and Attack Surface
- Asset criticality
- Asset criticality means understanding which systems matter most to your organization's mission, revenue, compliance, and operations.
- Lesson 2076 — Severity Assessment and CVSS ScoringLesson 2450 — Asset Criticality and Business Context
- Asset Identification
- Asset Identification means cataloging what you're protecting: user credentials, financial data, intellectual property, or system availability itself.
- Lesson 2636 — Architectural Threat Modeling Fundamentals
- Assets
- Assets are what you're defending—anything valuable that attackers want to steal, modify, or destroy.
- Lesson 41 — Assets, Entry Points, and Trust BoundariesLesson 2498 — Risk Components: Assets, Threats, and Vulnerabilities
- ATT&CK Navigator
- The ATT&CK Navigator is MITRE's interactive web-based tool that turns the massive ATT&CK matrix into a visual, color-coded spreadsheet.
- Lesson 2183 — ATT&CK Navigator and Visualization
- Attack graphs
- Attack graphs are similar but more flexible—they show multiple interconnected paths and dependencies as a network diagram, useful when attack steps can happen in various orders or share preconditions.
- Lesson 67 — Attack Trees and Attack Graphs
- attack payloads
- Active scanning means the tool deliberately sends malicious or malformed inputs—called attack payloads—to your application to see how it responds.
- Lesson 1372 — Active Scanning and Attack Simulation
- attack surface
- Your attack surface is the sum of all points where an unauthorized user could try to enter or extract data from your system.
- Lesson 73 — Attack Surface Analysis
- Attack Surface Reduction
- Attack Surface Reduction means minimizing the number of exposed interfaces, services, code paths, and features that could potentially be exploited by an attacker.
- Lesson 10 — Attack Surface Reduction
- Attack surfaces
- Attack surfaces are all the points where data enters or exits your system—APIs, user inputs, file uploads, database connections.
- Lesson 2031 — Threat Modeling in Design Phase
- attacker persona
- An attacker persona is a fictional but realistic profile of someone who might attack your system.
- Lesson 54 — Creating Attacker Personas for Threat Models
- Attestation
- Attestation is how you verify your system hasn't been compromised.
- Lesson 1464 — Measured Boot and TPM Integration
- Attribute inference
- Attribute inference is a related technique where an attacker infers sensitive attributes (like race, health status, or income) that were not supposed to be learned or exposed by the model, but that correlate with the model's decision boundary.
- Lesson 2832 — Model Inversion and Attribute Inference
- audit finding
- An audit finding is a documented control deficiency—a gap between what should exist (the requirement) and what actually exists (the observation).
- Lesson 2548 — Audit Findings and Risk Rating
- Audit logging
- Every access attempt is logged to Azure Monitor
- Lesson 1325 — Secret Stores vs Environment VariablesLesson 1329 — Azure Key Vault
- Audit trail
- Every key usage is logged for compliance
- Lesson 1797 — Key Management for Database Encryption
- Auditability
- every check is logged and traceable
- Lesson 1301 — Automated Package Verification Workflows
- Authenticated scanning
- Authenticated scanning is like getting a key: you walk inside and inspect the actual contents, configurations, and installed software.
- Lesson 2436 — Authenticated Scanning and Credentialed Checks
- Authentication
- Authentication is proving you are who you claim to be (showing your passport).
- Lesson 1206 — Authentication vs Identification: Terminology ChangesLesson 1701 — Authentication vs Authorization in Cloud IAM
- Authentication and authorization
- Each application/user must prove identity and is granted only necessary secrets
- Lesson 1325 — Secret Stores vs Environment Variables
- Authentication confusion
- The scanner loses session state and flags logout pages as access control issues
- Lesson 1375 — False Positive Management in DAST
- Authorization
- Authorization is which floors and rooms your badge can unlock.
- Lesson 1701 — Authentication vs Authorization in Cloud IAM
- Authorization Code Flow
- The Authorization Code Flow is OAuth 2.0's most secure grant type, designed for server-side applications.
- Lesson 758 — Authorization Code Flow Deep DiveLesson 1011 — OAuth 2.0 Flows for API Access
- Authorization Code Flow with PKCE
- For almost all modern applications, Authorization Code Flow with PKCE is the answer.
- Lesson 771 — OIDC Authentication Flows
- Authorization Code Grant
- Authorization Code Grant is the gold standard for web applications with server backends.
- Lesson 757 — OAuth 2.0 Grant Types
- Autocrypt
- Autocrypt is a specification for automating OpenPGP key exchange through regular email headers.
- Lesson 2966 — Modern Alternatives: Autocrypt and Delta Chat
- Automated evidence collection
- Automated evidence collection means deploying tools, scripts, and integrations that continuously capture compliance artifacts from your systems without human intervention.
- Lesson 2620 — Automated Evidence Collection
- Automated hardening scripts
- Automated hardening scripts are pre-written configuration management tools that read security baseline requirements and apply them systematically.
- Lesson 1418 — Automated Hardening and Remediation Scripts
- Automated Remediation
- Trigger device quarantine, factory resets, or forced firmware updates when infection is detected.
- Lesson 2802 — IoT Botnet Detection and Mitigation
- Automated Scanning
- Automated Scanning means your CI/CD system runs tools like Trivy, Grype, or OWASP Dependency-Check on every build.
- Lesson 1308 — Integrating Scanning into CI/CD Pipelines
- auxiliary modules
- While exploit modules deliver payloads for system compromise, auxiliary modules are Metasploit's non-exploitation workhorses.
- Lesson 2197 — Auxiliary Modules and Scanning
- Availability
- Availability is ensured through redundancy (backup systems + failover mechanisms + DDoS protection)
- Lesson 3 — Defense in DepthLesson 13 — CIA Triad: Confidentiality, Integrity, Availability
- avalanche effect
- The avalanche effect means that changing even a single bit of input should completely transform the output hash.
- Lesson 203 — Determinism and Avalanche Effect
B
- Back-Channel Communication
- The IdP can directly notify RPs when a user's session changes (like logout), without relying on browser communication.
- Lesson 775 — OIDC Session Management and Single Logout
- backdoor
- A backdoor is a covert method of bypassing normal authentication to gain remote access to a system.
- Lesson 1524 — Backdoors and Remote Access Trojans (RATs)
- Backdoors
- Backdoors are hidden entry points installed on compromised systems.
- Lesson 2118 — Maintaining Access and Persistence Mechanisms
- Backup vulnerabilities
- Backup vulnerabilities are similarly critical: cloud backups often use weaker encryption than E2EE, creating a secondary attack surface.
- Lesson 2957 — Encrypted Messaging Attacks and Vulnerabilities
- Balance checks
- Apply the same coupon code multiple times before the "used" flag is set
- Lesson 939 — Time-of-Check to Time-of-Use Testing
- Balancing Act
- The key tension is security versus performance. Too aggressive monitoring slows systems; too many exclusions leave gaps. Monitor endpoint performance post-deployment, adjust collection settings, and communicate with users about expected impact.
- Lesson 1583 — EDR Deployment and Performance Considerations
- BApp Store
- The BApp Store is Burp's official extension marketplace, accessible directly from the Extender tab.
- Lesson 2214 — Burp Extensions and BApp Store
- baseline security configuration
- A baseline security configuration is a documented, standardized set of security settings that defines the minimum acceptable security posture for your systems.
- Lesson 1412 — Baseline Security Configuration
- Baselining
- Baselining means documenting your network's typical behavior over time:
- Lesson 416 — Network Monitoring and Baselining
- batch verification
- While aggregation combines signatures into one, batch verification is about checking multiple signatures at once more efficiently than verifying them individually.
- Lesson 239 — Aggregate Signatures and Batch Verification
- Behavior on timeout
- The regex operation throws an error or returns failure
- Lesson 1180 — Regex Timeout and Resource Limits
- Bettercap
- Bettercap is the modern successor to Ettercap, designed for speed and extensibility.
- Lesson 401 — MITM Attack Tools and Frameworks
- BeyondCorp
- BeyondCorp is Google's implementation of Zero Trust, developed after they moved away from privileged internal networks.
- Lesson 2686 — BeyondCorp Model and Zero Trust Access
- Binary Format
- Data is split into TYPE, LENGTH, FLAGS, and PAYLOAD fields. This is more efficient but harder for humans to debug with traditional tools.
- Lesson 1097 — HTTP/2 Protocol Architecture and Security Model
- BinaryFormatter
- BinaryFormatter is the most notorious offender.
- Lesson 1185 — Insecure Deserialization in .NET
- Bind Shells
- The target opens a listening port for you to connect to:
- Lesson 2236 — Netcat and Socat for Network Pivoting
- binwalk
- binwalk is the Swiss Army knife of firmware analysis.
- Lesson 2761 — Firmware Binary Analysis and Unpacking
- Black-box access
- Black-box access means the attacker only interacts with the model as a user would—submitting inputs and observing outputs.
- Lesson 2809 — Threat Model for Adversarial Attacks
- BLAKE3
- BLAKE3 is the newest evolution—even faster than BLAKE2, highly parallelizable, and designed for modern multi-core processors.
- Lesson 215 — Specialized Hash Functions: BLAKE2, BLAKE3
- blast radius
- The blast radius is determined by the IAM role's permissions.
- Lesson 1936 — Credential Exposure via IMDS
- Blast radius containment
- If an AZ is compromised, attackers cannot pivot to resources in other zones through layer-2 networking
- Lesson 1834 — Multi-AZ Subnet Design for Resilience
- blind command injection
- This is called blind command injection, and it requires creative techniques to confirm the vulnerability exists and extract data.
- Lesson 605 — Blind Command Injection Techniques
- Blind IDOR
- Blind IDOR is trickier: the application doesn't give you direct feedback about whether you accessed someone else's data.
- Lesson 820 — Blind IDOR and Indirect Object References
- blind signature
- A blind signature is the digital equivalent: a protocol where a signer creates a valid digital signature on a message without learning its content.
- Lesson 233 — Blind Signatures and Anonymous Credentials
- Blind SSRF
- Blind SSRF is trickier—the server makes the request you specify, but you never see the response.
- Lesson 888 — Blind SSRF Detection and Exploitation
- block cipher
- A block cipher is a symmetric encryption algorithm that processes data in fixed-size chunks called "blocks" (commonly 128 bits or 16 bytes).
- Lesson 85 — Block Cipher Fundamentals and Structure
- Block Public Access
- A safety feature that overrides other settings to prevent accidental public exposure. Always enable unless you specifically need a public bucket (rare).
- Lesson 1782 — S3 Bucket Security Fundamentals
- Bluebugging
- Bluebugging is the most severe attack—full device takeover.
- Lesson 558 — Bluetooth Attacks: Bluejacking, Bluesnarfing, and Bluebugging
- Bluejacking
- Bluejacking is the unauthorized sending of unsolicited messages (contacts, notes, or images) to nearby Bluetooth devices.
- Lesson 558 — Bluetooth Attacks: Bluejacking, Bluesnarfing, and Bluebugging
- Bluesnarfing
- Bluesnarfing is a serious data theft attack where an attacker connects to a vulnerable device without authorization and extracts sensitive information—contacts, calendars, text messages, photos, or even emails.
- Lesson 558 — Bluetooth Attacks: Bluejacking, Bluesnarfing, and Bluebugging
- bootkit
- A bootkit is malware that infects the boot sector or bootloader—the very first code executed when a computer starts.
- Lesson 1553 — Bootkits and MBR Persistence
- Bootkit infections
- Bootkit infections are a particularly dangerous variant.
- Lesson 2765 — Firmware Backdoors and Persistent Threats
- Bootkits
- Bootkits are malware that infects the boot process itself, executing before the operating system loads.
- Lesson 1463 — UEFI Firmware Attacks and Vulnerabilities
- botnet
- A botnet is a network of infected computers (called "bots" or "zombies") controlled remotely by an attacker.
- Lesson 1526 — Botnets and Command-and-Control
- brute force attack
- A brute-force attack is an exhaustive search method that tries every possible combination of characters until the correct password is found.
- Lesson 696 — Brute Force and Dictionary AttacksLesson 2229 — Brute-Force and Mask Attacks
- bug bounty program
- A bug bounty program is a crowdsourced security initiative where organizations reward external security researchers for responsibly disclosing vulnerabilities.
- Lesson 2479 — Bug Bounty Fundamentals and Models
- Build Dynamic Inventories
- Query all resources by tag combinations. For example, find all Environment:Production resources owned by Owner:security-team that are DataClassification:sensitive.
- Lesson 2001 — Tag-Based Resource Inventory and Discovery
- Build Log Exposure
- Build Log Exposure is the primary danger.
- Lesson 1323 — Environment Variables in CI/CD Pipelines
- Build-time accuracy
- The SBOM reflects the precise dependencies resolved during that specific build
- Lesson 1283 — Continuous SBOM Generation in CI/CD
- Build-time injection
- Build-time injection means embedding secrets into your application package, container image, or compiled binary before deployment.
- Lesson 1335 — Runtime Secret Injection Patterns
- Bullet cameras
- Bullet cameras are obvious deterrents for outdoor perimeters.
- Lesson 2284 — Video Surveillance and Monitoring
- Burp Suite's Turbo Intruder
- Burp Suite's Turbo Intruder is the most popular tool for this.
- Lesson 906 — Exploiting Race Conditions with Concurrent Requests
- Business Criticality
- A critical vulnerability on your public-facing payment server trumps the same vulnerability on an isolated test system. Consider:
- Lesson 1602 — Vulnerability Assessment and Prioritization
- Business Rules
- The logic governing what's allowed (e.g., "discount codes apply only once per user" or "refunds only within 30 days")
- Lesson 937 — Mapping Business Workflows
- Bypass resilience
- If one proxy is blocked, you can reroute through others
- Lesson 2994 — Proxy Chains and SOCKS
- Bypass risks
- If authentication checks are duplicated in 20 places, one missed check creates a vulnerability
- Lesson 1212 — Separation of Concerns for Security Boundaries
C
- CA flag
- A boolean (true/false) indicating whether this is a CA certificate
- Lesson 174 — Certificate Extensions: Basic Constraints and Key Usage
- CA-issued certificate
- A CA-issued certificate is like a passport issued by your government—everyone trusts it because a recognized authority verified your identity.
- Lesson 178 — Self-Signed Certificates vs CA-Issued Certificates
- Cache Key Design
- Cache Key Design is your first line of defense.
- Lesson 1122 — Cache Configuration Security
- Caching scan results
- Caching scan results means storing outcomes from unchanged code or dependencies.
- Lesson 3035 — Performance Optimization for Security Scans
- Canonicalization
- Canonicalization means converting input to its simplest, standard representation before applying security checks.
- Lesson 1166 — Defense: Canonical Form Validation Strategies
- Cascade failures
- A compromise in the shared mechanism affects all users simultaneously
- Lesson 2670 — Least Common Mechanism
- Case Management System
- The centralized workspace where analysts track investigations, assign tasks, document findings, and collaborate. When the orchestration engine creates a security case, all related alerts, artifacts, evidence, and analyst notes live here in one place—eliminating spreadsheet chaos.
- Lesson 2326 — SOAR Architecture and Components
- Case variation
- shell.PHP or shell.PhP (if checks are case-sensitive)
- Lesson 947 — Web Shell Upload Techniques
- Centralized Authentication
- The gateway verifies API keys, OAuth tokens, or JWTs before requests reach your backend. If authentication fails, the request never touches your services. This prevents authentication logic duplication and ensures consistent security policies.
- Lesson 1043 — API Gateway and Defense Patterns
- Centralized services
- A single security account auditing or managing resources across dozens of accounts
- Lesson 1737 — Cross-Account Access Fundamentals
- CEO Fraud
- CEO Fraud is the most prevalent whaling attack.
- Lesson 2255 — Whaling and Executive Impersonation
- Certificate lifecycle
- Renewal before expiry is critical—devices may lack real-time clocks or internet connectivity
- Lesson 2792 — Certificate-Based Authentication in Constrained Devices
- Certificate pinning
- Certificate pinning means your application explicitly checks that the server's certificate (or its public key) matches a specific, pre-approved value that you've "pinned" into your code.
- Lesson 186 — Certificate Pinning Techniques
- Certificate validation bypasses
- An attacker controlling one domain on a shared IP can potentially intercept or influence traffic meant for another domain if the certificate's Subject Alternative Name (SAN) includes both. Even with proper certificates, subtle validation flaws can be exploited.
- Lesson 1101 — HTTP/2 Connection Coalescing Attacks
- chain of custody
- The chain of custody is a documented chronological record of who handled evidence, when, where, and why.
- Lesson 2379 — Evidence Collection Principles and Legal Considerations
- Chargeback
- Chargeback means actually billing departments for their usage.
- Lesson 2000 — Cost Allocation and Chargeback with Tags
- Checkov
- Checkov is a comprehensive, policy-as-code scanner supporting Terraform, CloudFormation, Kubernetes, Dockerfile, and more.
- Lesson 3000 — IaC Security Scanning Tools and Static Analysis
- Chisel
- Chisel is a fast TCP/UDP tunnel transported over HTTP, secured via SSH.
- Lesson 2242 — Chisel and Ligolo for Reverse Tunneling
- chkrootkit
- chkrootkit is a Unix-based scanner that performs cross-view differential analysis by comparing system binaries and checking for known rootkit signatures.
- Lesson 1564 — Rootkit Detection Tools and Frameworks
- CIA Triad
- The CIA Triad is the foundation of information security.
- Lesson 13 — CIA Triad: Confidentiality, Integrity, Availability
- clean-label poisoning
- Unlike label flipping attacks where attackers corrupt the labels themselves, clean-label poisoning is far more insidious.
- Lesson 2820 — Clean-Label Poisoning Attacks
- Clear justification
- Document why the risk is acceptable (cost-benefit analysis, business necessity, low likelihood)
- Lesson 2521 — Risk Acceptance and Documentation
- Client Associations
- Wireless devices constantly communicate with their connected APs. By passively monitoring wireless traffic, you can identify which client devices (laptops, phones, IoT devices) are associated with which access points.
- Lesson 355 — Wireless Network Topology Mapping
- Client Certificates
- The most common approach for admin access. You generate X.509 certificates signed by the cluster's Certificate Authority (CA). When you send a request, the server validates your certificate against its trusted CA—like showing a government-issued ID.
- Lesson 1663 — API Server Authentication Mechanisms
- Client Credentials Flow
- Client Credentials Flow is for machine-to-machine communication where no user is involved.
- Lesson 1011 — OAuth 2.0 Flows for API Access
- Client Credentials Grant
- Client Credentials Grant is for machine-to-machine communication where no user is involved.
- Lesson 757 — OAuth 2.0 Grant Types
- ClientAliveCountMax
- Defines how many keepalive messages can go unanswered before the server disconnects. Together with ClientAliveInterval, this determines total idle timeout. For example: ClientAliveInterval 300 (5 minutes) and ClientAliveCountMax 2 means 10 minutes of unresponsiveness triggers disconnection.
- Lesson 1447 — Idle Timeout and Connection Limits
- Clock skew
- Clock skew is the difference between a system's recorded time and true time (typically UTC from an authoritative source).
- Lesson 2418 — Time Source Synchronization and Clock Skew
- Cloning
- Once captured, the credential is written to a blank writable RFID card or tag. The clone becomes an exact duplicate that readers cannot distinguish from the original.
- Lesson 2274 — Badge Cloning and RFID Attacks
- Closed port
- Usually sends back an ICMP port unreachable message (the OS tells you "nothing is listening here")
- Lesson 341 — UDP Scanning Techniques
- Cloud metadata services
- Cloud metadata services are the game-changer.
- Lesson 1204 — Server-Side Request Forgery Enters the Top 10
- Cloud SIEM
- A Cloud SIEM is your security operations command center—it collects logs and events from all those sources you've been configuring (CloudTrail, VPC Flow Logs, application logs, etc.) and turns them into actionable security intelligence.
- Lesson 1878 — Cloud SIEM Architecture and Components
- ClusterFuzz
- ClusterFuzz is the underlying infrastructure that powers OSS-Fuzz.
- Lesson 1394 — Continuous Fuzzing and Integration
- Cobalt Strike
- Cobalt Strike is the commercial gold standard for adversary simulation, providing sophisticated teamserver capabilities, Beacon implants with advanced evasion, and malleable C2 profiles that mimic legitimate traffic patterns.
- Lesson 2216 — Exploitation Framework LandscapeLesson 2217 — Metasploit vs. Alternative Frameworks
- Code deployment
- A developer writes code, but a separate reviewer must approve it before production
- Lesson 7 — Separation of Duties and Privilege Separation
- Cold start
- The platform provisions a fresh execution environment. Isolation is strongest here; no leftover data from previous runs.
- Lesson 1942 — Function Execution Context and Isolation
- Collection and Storage
- Document what vulnerabilities exposed data without copying entire databases. If you must capture evidence (screenshots, sample records), encrypt it immediately and store it on approved, isolated systems—never on personal devices or cloud services. Use strong encryption (AES-256) and ensure storage media is controlled.
- Lesson 2096 — Data Handling and Confidentiality
- Collectors
- Collectors are distributed agents or forwarders deployed near data sources.
- Lesson 2315 — SIEM Architecture: Collectors, Aggregators, and Storage
- collision resistance
- You've learned that collision resistance means it should be computationally infeasible to find two different inputs that produce the same hash output.
- Lesson 202 — The Birthday Paradox and Collision Probability
- Commercial feeds
- Commercial feeds are subscription-based services that provide curated, high-fidelity threat data.
- Lesson 2339 — Threat Intelligence Feeds and Sources
- Communication protocols
- Communication protocols are your emergency playbook: they define who to contact, when, how, and what to communicate when critical situations arise during testing.
- Lesson 2094 — Communication Protocols and Escalation
- Community images
- Community images are user-contributed—they might be convenient, but you're trusting unknown maintainers who may abandon them or include malicious code.
- Lesson 1633 — Base Image Selection and Trust
- compensating control
- A compensating control is an alternative security measure that reduces risk to an acceptable level when the primary (ideal) control cannot be implemented.
- Lesson 26 — Compensating ControlsLesson 2463 — What Are Compensating Controls
- Complete mediation
- Complete Mediation is the security design principle that demands every single access attempt to every protected resource must be validated against the current access control rules.
- Lesson 1213 — Complete Mediation and Access ChecksLesson 2629 — Complete Mediation
- Compliance as Code
- Instead of maintaining compliance through spreadsheets, manual reviews, and periodic audits, Compliance as Code means writing your compliance requirements as actual code that can be executed, tested, and enforced automatically.
- Lesson 2623 — Compliance as Code
- Compliance mode
- Compliance mode is stricter—no one, not even the account owner, can delete or modify locked objects until retention expires.
- Lesson 1787 — Object Lock and Immutable Storage
- Compliance reporting
- Compliance reporting is the process of documenting that your cloud infrastructure meets specific regulatory requirements.
- Lesson 1993 — Compliance Reporting and Evidence Collection
- Compliance responsibility mapping
- Compliance responsibility mapping is the process of determining which party (cloud provider or customer) is responsible for implementing and maintaining each control required by regulations like HIPAA, PCI-DSS, SOC 2, or GDPR.
- Lesson 1691 — Compliance Responsibility Mapping
- Components
- Exported activities, services, broadcast receivers, or content providers (android:exported="true") are publicly accessible—potential attack entry points.
- Lesson 2714 — APK Structure and Manifest Analysis
- Compromise Recording
- Compromise Recording is the design principle that assumes breaches will happen—so your system must create an unforgeable trail of evidence when they do.
- Lesson 2635 — Compromise Recording and Auditability
- Compromised credentials
- Compromised credentials are now the primary attack vector because cloud platforms are designed to be accessible from anywhere—by anyone with valid credentials.
- Lesson 1696 — Identity as Attack Surface
- Conditions
- A policy statement essentially says: "This Effect applies to this Principal when they attempt this Action on this Resource, but only if these Conditions are met."
- Lesson 1703 — Policy Structure and Syntax FundamentalsLesson 2327 — Playbook Design Fundamentals
- Confidentiality
- Confidentiality is protected by multiple barriers (encryption + access controls + network segmentation)
- Lesson 3 — Defense in DepthLesson 13 — CIA Triad: Confidentiality, Integrity, Availability
- Configuration Change Control
- Configuration Change Control is your formal gatekeeper process ensuring changes are intentional, tested, approved, and traceable.
- Lesson 1623 — Configuration Change Control
- Configuration Drift
- Maintaining identical security policies across providers is nearly impossible. One team might enable IMDSv2 enforcement in AWS while another forgets the Azure equivalent (managed identity configuration). This creates compliance gaps.
- Lesson 1986 — Multi-Cloud and Hybrid Compliance Challenges
- Configuration errors fail safely
- A typo or misconfiguration results in blocked access (annoying but safe) rather than unintended exposure
- Lesson 839 — Deny by Default Principles
- Configuration Vulnerabilities
- A manually opened port or disabled encryption setting creates an attack surface invisible to your IaC security scans and policy checks.
- Lesson 2022 — Infrastructure Drift: Causes and Risks
- Confusion
- Confusion means making the relationship between the key and the ciphertext as complex as possible.
- Lesson 85 — Block Cipher Fundamentals and Structure
- consent
- Under GDPR, consent is one of several legal bases for processing personal data (as you learned in "Legal Bases for Processing").
- Lesson 2556 — Consent Requirements and Management
- Consistency
- every build is checked the same way
- Lesson 1301 — Automated Package Verification WorkflowsLesson 2059 — Security Automation and Orchestration
- Constant-time implementation
- ChaCha20-Poly1305 is easier to implement without timing vulnerabilities, reducing side-channel attack risks
- Lesson 127 — ChaCha20-Poly1305
- Container escape
- Container escape means breaking out of this isolation to gain control of the host operating system, typically with root privileges.
- Lesson 2148 — Container Escape for Privilege Escalation
- Context blindness
- A scanner flags an "open" service that's actually protected by network segmentation or requires additional authentication
- Lesson 2441 — False Positives and Validation
- Context Confusion
- Context Confusion is the underlying vulnerability: when user data is embedded in a different parsing context than the application expects.
- Lesson 676 — HTML Injection and Context Confusion
- context-aware output encoding
- Remember from our last lesson that context-aware output encoding means escaping data differently depending on where it appears (HTML body, attributes, JavaScript, etc.).
- Lesson 1247 — Auto-Escaping Mechanisms and Configuration
- Contextual Analysis
- Evaluate whether flagged code is actually exploitable in your specific environment. A SQL injection finding in dead code or test fixtures is typically a false positive.
- Lesson 3016 — False Positive Management
- Continuous Identity Verification
- Continuous Identity Verification means constantly re-evaluating whether the current user is genuinely who they claim to be throughout the entire session.
- Lesson 1699 — Continuous Identity Verification
- Continuous Monitoring
- Dependencies aren't "set and forget." Regularly re-evaluate libraries, watch for security advisories, and have an incident response plan if a dependency is compromised. Track what data each SDK accesses through your app's threat model.
- Lesson 2740 — Third-Party SDK and Library Security
- Continuous scanning
- Continuous scanning means abandoning the snapshot approach for persistent, always-on monitoring that detects vulnerabilities the moment they appear.
- Lesson 2443 — Continuous Scanning and Real-Time Detection
- Continuous security testing
- Continuous security testing means automatically scanning your APIs on every deployment or schedule—not just once.
- Lesson 1044 — API Security Testing and Monitoring
- Control
- Can modify the boot process, bypass Secure Boot (if keys are compromised), or inject code into the loading OS
- Lesson 1554 — UEFI and Firmware Rootkits
- Control channel
- Handles authentication, key exchange, and tunnel setup using TLS (remember: TLS VPNs from the previous lesson). This is encrypted and reliable.
- Lesson 486 — OpenVPN Architecture and Components
- Control description
- The specific activity performed (e.g., "Access reviews conducted quarterly by department managers")
- Lesson 2598 — Control Design and Implementation
- Control Mapping Complexity
- A single GDPR requirement might require CloudTrail in AWS, Azure Monitor in Azure, and Cloud Audit Logs in GCP. You must map each provider's native controls to your compliance framework separately.
- Lesson 1986 — Multi-Cloud and Hybrid Compliance Challenges
- Cookie security flags
- Cookie security flags are your first line of defense.
- Lesson 670 — HttpOnly and Secure Cookie Flags
- cookie tampering
- This is called cookie tampering, and it's a serious threat if your application trusts cookie data blindly.
- Lesson 727 — Cookie Tampering and Integrity
- Cookies
- Cookies are stored by the browser and automatically included with every request to the same domain.
- Lesson 706 — Session Transmission: Cookies vs URL Parameters vs Headers
- Coordination with Legal
- Coordination with Legal is non-negotiable.
- Lesson 2428 — External Communication and Disclosure
- Correctness
- The computed result is accurate, even if some parties try to cheat
- Lesson 255 — Introduction to Secure Multi-Party Computation (MPC)
- Correlation rules
- Correlation rules are the detective logic that connects these dots.
- Lesson 2318 — Correlation Rules and Detection Logic
- cosign
- cosign is a newer tool from the Sigstore project that simplifies container signing.
- Lesson 1297 — Container Image Verification
- Covenant
- Covenant is a modern .NET-based C2 framework designed for red team operations with a web interface, offering strong Windows integration and advanced obfuscation.
- Lesson 2217 — Metasploit vs. Alternative Frameworks
- Crack Rate
- The percentage of hashes you successfully cracked versus the total. If you cracked 450 out of 1,000 hashes, that's a 45% crack rate. This metric helps you gauge both the strength of the password policy and the effectiveness of your attack strategy.
- Lesson 2235 — Password Analysis and Cracking Metrics
- Credential dumping
- Credential dumping is the technique of extracting usernames, passwords, and authentication tokens from a compromised machine.
- Lesson 2119 — Credential Dumping Fundamentals
- Credential Stuffing at Scale
- Stolen plain text credentials are sold on dark web marketplaces and used in automated "credential stuffing" attacks, where bots attempt login across thousands of websites using leaked username/password pairs.
- Lesson 683 — Why Plain Text Password Storage is Catastrophic
- Critical weakness
- The requesting page blindly trusts and executes whatever the server returns—a major CSRF and security risk.
- Lesson 858 — SOP Exceptions and Relaxations
- cron jobs
- On Linux/Unix systems, cron jobs are automated tasks scheduled to run at specific times.
- Lesson 2145 — Cron Job and Scheduled Task Exploitation
- Cross-account access
- Chain roles across accounts while restricting what actions are allowed in downstream accounts
- Lesson 1712 — IAM Roles: Federated and Assumable IdentitiesLesson 1716 — Resource-Based vs Identity-Based PoliciesLesson 1732 — Role Chaining and Session Policies
- Crypto-agility
- Crypto-agility means designing systems that can swap cryptographic algorithms without requiring massive rewrites.
- Lesson 277 — Migration Strategies and Crypto-Agility
- Cryptographic erasure
- Instead of trying to find every copy of a key, encrypt all data with a Key Encryption Key (KEK). Destroy only the KEK securely—all encrypted data becomes instantly unreadable. This is faster and more reliable for large datasets.
- Lesson 320 — Key Destruction and Sanitization
- CSRF
- CSRF is prevented by CSRF tokens, SameSite cookies, and verifying request origins
- Lesson 852 — CSRF vs XSS: Key Differences
- CVE Database
- Maintained by MITRE, this is the naming standard. Each CVE entry includes a unique ID, description, and references — but minimal scoring details.
- Lesson 1613 — Vulnerability Database and CVE Mapping
- CVSS Scores
- The Common Vulnerability Scoring System provides a standardized severity rating (0-10). A CVSS 9.8 vulnerability deserves more attention than a 4.2—but context matters.
- Lesson 1602 — Vulnerability Assessment and Prioritization
D
- Dangerous characters
- Dangerous characters are neutralized before reaching the browser
- Lesson 1247 — Auto-Escaping Mechanisms and Configuration
- DAST Gates
- Configure runtime test failures based on exploitable vulnerabilities detected in running applications—for example, blocking deployment if SQL injection or XSS vulnerabilities are discovered.
- Lesson 2065 — Automated Security Gates in CI/CD
- data access layer
- The data access layer (DAL) is the code that sits between your application and your database.
- Lesson 1244 — Database Access Layer Security Patterns
- Data channel
- Carries your actual encrypted traffic. This is where your web requests, files, and application data flow through.
- Lesson 486 — OpenVPN Architecture and Components
- Data classification
- Data classification is the systematic process of organizing data into categories based on sensitivity, regulatory requirements, and business impact if compromised.
- Lesson 1801 — Data Classification Fundamentals
- Data classification and handling
- You determine what data goes into the SaaS application and whether it's appropriate for that service's security level. Uploading highly sensitive data to a consumer-grade SaaS tool is your risk.
- Lesson 1688 — Shared Responsibility in SaaS
- Data controllers
- Entities that determine why and how personal data is processed
- Lesson 2551 — GDPR Overview and Scope
- Data discovery and staging
- Data discovery and staging is the methodical process of locating valuable information—credentials, customer databases, intellectual property, financial records—and preparing it for removal while staying under the radar.
- Lesson 2125 — Data Discovery and Staging
- data enclave
- A data enclave is an isolated environment where only classified data at a specific level resides—often with dedicated networks, separate storage systems, and stringent access controls.
- Lesson 2652 — Data Segmentation and Classification
- Data loss attacks
- An attacker can fill your origin's storage with garbage data, forcing the browser to evict legitimate user data
- Lesson 1079 — Storage Quota and Eviction Policies
- Data mapping
- Data mapping is the systematic process of identifying and documenting where personal data originates, how it moves through systems, where it's stored, who processes it, and where it ultimately goes—whether deleted, archived, or shared with third parties.
- Lesson 2889 — Data Mapping for PIAs
- Data minimization
- Less persistent data means smaller attack surface
- Lesson 2956 — Disappearing Messages and Perfect Forward Secrecy
- Data Protection by Design and Default
- Similarly, Data Protection by Design and Default means embedding privacy protections into your systems' architecture from day one.
- Lesson 2557 — Data Protection by Design and Default
- Data residency
- Data residency refers to the physical location where data is stored.
- Lesson 1982 — GDPR and Data Sovereignty Requirements
- data subject
- The data subject is simply the living person to whom the personal data relates.
- Lesson 2552 — Personal Data and Special Categories
- De-identification
- De-identification is the broader umbrella term for any technique that removes or obscures personally identifiable information, including both anonymization and pseudonymization approaches.
- Lesson 2902 — Anonymization vs. Pseudonymization
- Dead Letter Queue
- A Dead Letter Queue is a separate queue or topic where failed events are routed after all retry attempts are exhausted.
- Lesson 1958 — Dead Letter Queues and Error Handling
- Decoder
- Decoder is your Swiss Army knife for transforming data formats.
- Lesson 2215 — Advanced Burp Features and Workflows
- Dedicated parsers
- Dedicated parsers are purpose-built for specific formats.
- Lesson 1181 — Alternative Parsing Strategies
- Default deny
- Default deny is a security stance where the operating system or application blocks all actions, connections, or executables unless they're explicitly permitted.
- Lesson 1406 — Default Deny and Allowlisting
- Default Deny Principle
- The Default Deny Principle means your firewall's baseline rule is to block all traffic unless you've explicitly allowed it.
- Lesson 428 — Default Deny Principle
- Default Encryption
- Ensures all objects are encrypted at rest, even if not specified during upload.
- Lesson 1782 — S3 Bucket Security Fundamentals
- Defense in Depth
- Defense in depth means implementing multiple, independent security controls so that if one fails, others still protect your application.
- Lesson 10 — Attack Surface ReductionLesson 657 — CSP Fundamentals and PurposeLesson 1140 — Defense-in-Depth for Frame-Based AttacksLesson 1152 — Validation Layers and Defense in DepthLesson 1209 — Defense in Depth Through Layered ValidationLesson 2279 — Physical Access Control Models and Zones
- Defense in Depth Through Design
- Defense in Depth Through Design means intentionally building systems with overlapping, independent security layers from the ground up.
- Lesson 2671 — Defense in Depth Through Design
- defense-in-depth strategy
- A defense-in-depth strategy means implementing multiple independent layers of authorization checks, so if one layer fails or is bypassed, others still protect your resources.
- Lesson 838 — Access Control Defense Strategy
- Defensive coverage measurement
- Defensive coverage measurement means mapping your security controls (EDR, SIEM rules, network sensors, etc.) to specific ATT&CK techniques, then identifying which techniques lack adequate detection or prevention.
- Lesson 2185 — Measuring Defensive Coverage with ATT&CK
- DENY
- Your page cannot be displayed in any frame, regardless of the site attempting to frame it. This is the most restrictive option.
- Lesson 1135 — X-Frame-Options Header
- Deny by Default
- Deny by Default is a security principle where every resource or action starts in a locked-down state—all access is blocked unless you explicitly configure a permission to allow it.
- Lesson 839 — Deny by Default Principles
- DenyGroups
- users in listed groups are explicitly blocked
- Lesson 1443 — Restricting SSH Access by User and Group
- Dependabot alerts
- Notifications when vulnerabilities are found
- Lesson 1303 — GitHub Dependency Scanning and Dependabot
- dependency resolution
- This process is called dependency resolution.
- Lesson 1280 — Dependency Resolution and Lock Files
- Deprecation
- Deprecation is the controlled process of retiring those old versions safely.
- Lesson 1038 — API Versioning and Deprecation
- DER
- DER is the raw binary encoding of certificate data.
- Lesson 179 — Certificate Encoding: PEM, DER, PKCS#12, and Formats
- Deserialization
- Deserialization is the reverse: reading that stored format and reconstructing the original object in memory.
- Lesson 1183 — Deserialization Fundamentals and Attack Surface
- Detached Signatures
- The signature lives in a separate file from the message. Perfect for software distribution—you download program.exe and program.exe.sig separately, then verify them together. The signature doesn't modify the original file.
- Lesson 2960 — OpenPGP Message Format and Operations
- Detect Orphaned Resources
- Identify resources lacking ownership tags or those whose tagged owner has left the organization. These orphans are security risks—unpatched, unmonitored, and potentially hosting vulnerabilities.
- Lesson 2001 — Tag-Based Resource Inventory and Discovery
- Detection Engine
- The heart of Snort. It matches preprocessed packets against your ruleset using pattern matching and generates alerts when threats are detected.
- Lesson 458 — Snort: Architecture and Rule Syntax
- detection use case
- A detection use case is a documented threat scenario with matching detection logic that tells your SIEM what to look for and when to alert.
- Lesson 2319 — Use Cases and Detection Content Development
- Deterministic
- No per-signature randomness means no nonce reuse vulnerabilities
- Lesson 228 — EdDSA and Ed25519 Signatures
- Device attestation
- proving to remote servers that your hardware is genuine
- Lesson 307 — Trusted Platform Modules (TPMs)
- Device Enrollment
- The entire device is managed (common for company-owned devices). The organization controls everything: apps, settings, security policies, and can perform full device wipes.
- Lesson 2742 — Mobile Device Management (MDM) Fundamentals
- Device Hardening
- Device Hardening means disabling Bluetooth when not needed, just as you lock your car when parked.
- Lesson 560 — Bluetooth Security Best Practices
- device posture assessment
- This is called device posture assessment — checking things like OS patch level, firewall status, antivirus presence, disk encryption, and whether the device is jailbroken or rooted.
- Lesson 2678 — Device Trust and Endpoint Security
- Device seizure
- Device seizure is the most direct threat.
- Lesson 2957 — Encrypted Messaging Attacks and Vulnerabilities
- dictionary attack
- A dictionary attack is smarter: instead of random combinations, attackers use wordlists—files containing thousands or millions of commonly used passwords like "password", "123456", "qwerty", and "admin".
- Lesson 696 — Brute Force and Dictionary Attacks
- Dieharder
- Dieharder is an extended, more comprehensive battery based on earlier work by George Marsaglia.
- Lesson 293 — Testing Randomness Quality
- Diffusion
- Diffusion means spreading the influence of each plaintext bit across many ciphertext bits.
- Lesson 85 — Block Cipher Fundamentals and Structure
- digital signature
- A digital signature is like a wax seal on a letter, but cryptographically unbreakable.
- Lesson 225 — Digital Signature Fundamentals and Use Cases
- Direct Connect
- Direct Connect is that private road for your data.
- Lesson 1841 — Direct Connect and Dedicated Connectivity
- Direct dependencies
- Direct dependencies are the main branches you can see and touch
- Lesson 1259 — Understanding Software Dependencies and Transitive Risk
- Directory authorities
- Directory authorities are trusted servers (currently 9 worldwide) that maintain consensus about which relays are trustworthy, fast, and available.
- Lesson 2983 — Tor Network Architecture
- Discovery
- Discovery means finding everything: servers, databases, workstations, applications, network devices, data repositories, cloud resources, and even intellectual property.
- Lesson 2501 — Asset Identification and Valuation
- Distributed attack surface
- Each edge node is a potential entry point
- Lesson 1862 — CDN Architecture and Threat Model
- Diversity
- Diversity means those backups work differently from each other.
- Lesson 28 — Redundancy and Diversity in Security
- DLP monitoring
- DLP monitoring means actively watching alert streams to detect when sensitive data moves inappropriately, while incident response is your structured approach to investigating and remediating those violations before they become breaches.
- Lesson 1808 — DLP Monitoring and Incident Response
- DNS Exfiltration
- The most reliable method. You provide a URL pointing to a domain you control (like http://your-unique-id.attacker.com). If you see a DNS lookup in your server logs, you've confirmed the vulnerability exists—the target made an outbound request.
- Lesson 888 — Blind SSRF Detection and Exploitation
- DNS Queries
- The attacker's most popular choice. You make the server perform a DNS lookup that includes stolen data in the subdomain:
- Lesson 606 — Out-of-Band Data Exfiltration
- DNS spoofing
- DNS spoofing is when an attacker sends fake DNS responses to trick a victim's computer into believing a legitimate domain points to the attacker's IP address instead of the real one.
- Lesson 394 — DNS Spoofing and Cache PoisoningLesson 1130 — DNS Cache Poisoning and Spoofing
- Domain names
- The websites or command-and-control servers attackers use
- Lesson 2336 — Indicators of Compromise (IOCs) and Their Limitations
- Double Submit Cookie Pattern
- The Double Submit Cookie Pattern is a stateless CSRF defense that works by setting a random value in both a cookie and a request parameter (like a hidden form field or custom header).
- Lesson 866 — Double Submit Cookie Pattern
- DP-SGD
- Differential privacy (DP) provides a mathematical framework to prevent this, and DP-SGD is the algorithm that makes it practical.
- Lesson 2841 — DP-SGD and Private Training Algorithms
- Droppers
- Droppers are compact programs that carry encrypted or obfuscated malware embedded within them.
- Lesson 1525 — Droppers, Downloaders, and Loaders
- dual-user pattern
- The dual-user pattern is the standard approach for zero-downtime database rotation:
- Lesson 1347 — Database Credential Rotation
- Dynamic ARP Inspection
- Dynamic ARP Inspection is the antidote to ARP poisoning.
- Lesson 409 — Switch Port Security and Defenses
- Dynamic Secrets
- Some systems need temporary, short-lived credentials generated on-demand. Environment variables are static—they can't generate a new database credential that expires in 30 minutes.
- Lesson 1324 — When Environment Variables Are InsufficientLesson 1331 — Dynamic Secrets and Leasing
E
- East-West traffic
- East-West traffic refers to communication between internal systems (server-to-server, zone-to-zone), as opposed to North-South traffic (traffic entering or leaving your network).
- Lesson 452 — East-West Traffic ControlLesson 2689 — East-West Traffic Inspection and Enforcement
- EAX
- EAX is a patent-free AEAD mode designed to be simpler than CCM while maintaining security.
- Lesson 128 — AES-CCM and Other AEAD Modes
- Economic balance
- Economic balance means you don't overspend on security relative to the asset's value or the threat's likelihood.
- Lesson 2672 — Work Factor and Economic Balance
- EDHOC
- EDHOC is a lightweight key exchange protocol designed specifically for constrained devices.
- Lesson 2797 — Authentication Protocols for Constrained Environments
- Effect
- Either Allow or Deny. This is your yes-or-no decision.
- Lesson 1703 — Policy Structure and Syntax Fundamentals
- Effective permissions verification
- Effective permissions verification means checking every layer:
- Lesson 1826 — Common Misconfigurations and Troubleshooting
- egress-only internet gateway
- An egress-only internet gateway is a stateful IPv6 component that allows outbound traffic from your VPC to the internet while preventing the internet from initiating connections to your instances.
- Lesson 1833 — Egress-Only Internet Gateways for IPv6
- Enable complete system compromise
- a leaked database password or AWS key can grant unlimited access to critical infrastructure
- Lesson 1252 — Understanding Hardcoded Secrets and Their Risks
- Enclosure switches
- Microswitches that detect when device casings are opened
- Lesson 2775 — Physical Tampering and Anti-Tamper Mechanisms
- Encrypt-then-MAC
- Encrypt-then-MAC is the safest construction: you first encrypt your plaintext, then compute the MAC over the resulting ciphertext (and any associated data like IVs).
- Lesson 123 — Encrypt-then-MAC ConstructionLesson 124 — MAC-then-Encrypt and Encrypt-and-MAC Pitfalls
- encrypted tunnel
- An encrypted tunnel is established between your device and a VPN gateway at the corporate perimeter
- Lesson 467 — Remote Access VPNs
- Encryption at rest
- Encryption at rest means secrets are encrypted before being written to disk, so they're unreadable without the proper decryption key.
- Lesson 1317 — Encryption at Rest for Secret Storage
- Encryption at rest and in transit
- Secrets are protected even if storage is compromised
- Lesson 1325 — Secret Stores vs Environment Variables
- encryption modes
- Review that encryption modes are appropriate—authenticated encryption modes like GCM are preferred over ECB (which should raise red flags).
- Lesson 2042 — Cryptography and Secrets Review
- Encryption operations
- Data is encrypted before upload
- Lesson 1766 — Client-Side Encryption for Cloud Data
- End-to-end encryption
- End-to-end encryption means only you and your intended recipient hold the keys.
- Lesson 2940 — E2EE vs Transport Encryption
- Enforcement Mechanisms
- Policies without teeth are suggestions. Use 802.1X to verify device compliance before granting access, WIPS to detect violations automatically, and MAC filtering or NAC (Network Access Control) to quarantine non-compliant devices.
- Lesson 553 — Wireless Security Policies and Compliance
- Enforcing mode
- Enforcing mode is the production state where SELinux actively blocks unauthorized actions.
- Lesson 1454 — SELinux Modes and Policy Types
- Enhanced monitoring difficulty
- Binary protocols are harder to inspect with traditional web application firewalls and logging tools
- Lesson 1097 — HTTP/2 Protocol Architecture and Security Model
- Entry Points
- Entry Points are every door, window, and tunnel into your system.
- Lesson 41 — Assets, Entry Points, and Trust Boundaries
- Envelope encryption
- Envelope encryption is the core pattern: your data is encrypted with a DEK, then that DEK is encrypted with your KMS master key.
- Lesson 1767 — Key Management Services (KMS) Deep Dive
- Ephemeral keys
- Ephemeral keys are generated fresh for each connection
- Lesson 2979 — Implementing Forward Secrecy in TLS
- Establishing baselines
- Establishing baselines means documenting your system's normal behavior:
- Lesson 1558 — Behavioral Analysis and Anomaly Detection
- etcd
- A distributed key-value store holding all cluster state and secrets (credentials, configurations). Think of it as Kubernetes's memory. Risk: Direct access means reading sensitive data and manipulating cluster state.
- Lesson 1662 — Kubernetes Architecture and Attack Surface
- ETSI EN 303 645
- ETSI EN 303 645 is the European standard for consumer IoT security.
- Lesson 2758 — IoT Regulatory Landscape and Security Standards
- Ettercap
- Ettercap is the veteran Swiss Army knife of MITM attacks.
- Lesson 401 — MITM Attack Tools and Frameworks
- Event Channels
- Event Channels are logical containers that categorize events by purpose and audience.
- Lesson 1508 — Windows Event Log Architecture and Components
- Event normalization
- Event normalization is the SIEM's translation engine.
- Lesson 2317 — Event Normalization and Parsing
- Event Providers
- Event Providers are the applications, drivers, and system components that generate events.
- Lesson 1508 — Windows Event Log Architecture and Components
- Event-source assumptions
- Event-source assumptions are dangerous: just because an API Gateway or queue invoked your function doesn't mean the original requester is authorized.
- Lesson 1964 — Broken Access Control in Functions
- Evidence Collection
- For SOC 2 or ISO 27001 audits, gathering evidence across multiple platforms means different APIs, log formats, and export mechanisms. Your auditor needs consistent proof that encryption-at-rest exists everywhere, but each cloud implements it differently.
- Lesson 1986 — Multi-Cloud and Hybrid Compliance Challenges
- evil twin
- An evil twin is a rogue wireless access point that impersonates a legitimate network.
- Lesson 398 — MITM on Wireless Networks
- Example scenario
- A vulnerable login page that responds differently based on whether your injected condition is true or false.
- Lesson 568 — Blind SQL Injection FundamentalsLesson 617 — XML Injection Attack VectorsLesson 632 — DOM-Based XSS: Client-Side VulnerabilitiesLesson 2144 — Path Hijacking and Environment Manipulation
- Exfiltration Techniques
- Collected data is transmitted to command-and-control servers using encrypted channels, often piggybacking on legitimate traffic to avoid detection by monitoring tools you learned about with Sysmon and Windows Event Logging.
- Lesson 1523 — Spyware and Information Stealers
- Exit policies
- Some relays refuse exit traffic; only about 10-15% are exits
- Lesson 2985 — Tor Relays: Guard, Middle, and Exit
- Expanded attack surface
- More code means more potential vulnerabilities
- Lesson 2667 — Economy of Mechanism
- Expert Determination
- A qualified statistician certifies the re-identification risk is very small
- Lesson 2582 — Protected Health Information (PHI)
- explicit allow rule
- An explicit allow rule is a firewall rule that precisely defines what traffic is permitted by specifying exact combinations of source address, destination address, port numbers, and protocols.
- Lesson 429 — Explicit Allow Rules
- exploit
- A vulnerability is a weakness; an exploit is the proof that the weakness can be abused.
- Lesson 2107 — Exploitation Fundamentals and Anatomy of an Exploit
- Exploit Kits
- These are pre-packaged toolkits that automatically probe your browser, plugins (Flash, Java), and operating system for known vulnerabilities. When they find a weakness—an unpatched browser, outdated plugin, or OS vulnerability—they deliver malware tailored to that specific flaw. Popular exploit kits include Angler, RIG, and Magnitude.
- Lesson 1528 — Drive-by Downloads and Web-Based Infection
- exploit module
- An exploit module is the vehicle that delivers your attack—it targets a specific vulnerability in a system (like a buffer overflow or a misconfigured service).
- Lesson 2195 — Exploit Modules and Payloads
- Exploitation
- Exploitation is the process of leveraging that vulnerability to achieve a specific goal—whether it's executing code, escalating privileges, or exfiltrating data.
- Lesson 2107 — Exploitation Fundamentals and Anatomy of an Exploit
- external entities
- These parsers supported a powerful feature called external entities — essentially, instructions that told the parser to fetch and include content from external sources (files or URLs).
- Lesson 1202 — The Rise and Fall of XXE and XML Security
- External ID
- An External ID is a random, unique secret string you generate and share only with the trusted third-party.
- Lesson 1739 — External ID for Third-Party Access
- External resource coordination
- External resource coordination means identifying and building relationships with specialized partners before an incident occurs.
- Lesson 2378 — External Resource Coordination
F
- Fail Conditions
- Fail Conditions are rules that stop the build when specific criteria are met.
- Lesson 1308 — Integrating Scanning into CI/CD Pipelines
- Fail-Safe Defaults
- Fail-Safe Defaults means your system should start in the most secure state possible—denying all access—and only grant permissions when explicitly allowed.
- Lesson 4 — Fail-Safe Defaults and Secure by DefaultLesson 2666 — Fail-Safe Defaults
- Falco
- Falco is an open-source runtime security tool that uses system call monitoring (via eBPF or kernel modules) to detect anomalous behavior.
- Lesson 1673 — Runtime Security and Threat DetectionLesson 1974 — Runtime Security and Threat Detection
- False negatives
- Scanners miss some threats (no tool is 100% accurate)
- Lesson 961 — Virus Scanning and Malware Detection Integration
- false positive
- A false positive is an alert that triggers on benign activity—like flagging a legitimate admin script as malware or marking routine database queries as data exfiltration.
- Lesson 1614 — False Positive ManagementLesson 2345 — False Positive Identification and Analysis
- False Positive Management
- False Positive Management is crucial at scale.
- Lesson 2053 — Test Result Management and Remediation Workflows
- Faster operations
- ECC point multiplication is computationally lighter than RSA's large modular exponentiation
- Lesson 163 — ECC vs RSA: Security and Performance
- FedRAMP Marketplace
- Once authorized, your service is listed publicly, enabling other agencies to adopt it faster.
- Lesson 2613 — FedRAMP Authorization Framework
- Feistel network
- A Feistel network is a symmetric structure used to build block ciphers like DES.
- Lesson 86 — Feistel Network Architecture
- Fiat-Shamir heuristic
- The Fiat-Shamir heuristic is a technique that transforms interactive proofs into non-interactive ones.
- Lesson 242 — Interactive vs Non-Interactive Proofs
- File inclusion
- Including files where the extension is appended server-side
- Lesson 1163 — Null Byte Injection and String Termination
- Fingerprinting
- Determining the NoSQL database type
- Lesson 592 — NoSQLMap and NoSQL Injection Automation
- Fingerprinting large data
- You can represent massive files with a compact, fixed-size "fingerprint." This is why software downloads include hash values—you can verify a 5GB download with just a 32-byte hash.
- Lesson 204 — Fixed-Length Output Property
- flat network
- A flat network is like having one giant room where everyone can see and talk to everyone else.
- Lesson 447 — Flat Networks vs Segmented Networks
- For Risk Communication
- The Top 10 speaks a common language between security teams, developers, and executives. When explaining why injection prevention matters, referencing "OWASP Top 10 #3" provides instant context and credibility.
- Lesson 1207 — Using the Top 10 Effectively in Security Programs
- For Security Awareness Training
- The Top 10 provides an excellent framework for teaching developers about real-world vulnerabilities. Each category offers concrete examples (like the injection attacks, authentication failures, and prototype pollution you've already learned) that developers encounter daily.
- Lesson 1207 — Using the Top 10 Effectively in Security Programs
- Form Hijacking
- The script locates form elements on the page and attaches event handlers to intercept the submit event. Before the legitimate form data reaches the real server, the attacker's code copies it and transmits it elsewhere.
- Lesson 639 — Keylogging and Form Hijacking
- Forward secrecy
- Ephemeral ECDH keys mean past sessions stay safe even if the server's long-term key is compromised
- Lesson 170 — ECC in Practice: TLS and Beyond
- Forward security
- Forward security means that even if your key is compromised, signatures created before the compromise remain valid and unforgeable.
- Lesson 240 — Forward-Secure and Stateful Signatures
- FOSSA
- FOSSA is a commercial platform that provides comprehensive license scanning, policy enforcement, and compliance reports.
- Lesson 1307 — License Compliance Scanning
- Fourth-party risk
- Fourth-party risk refers to the security exposure created by your vendors' suppliers, service providers, and subcontractors—parties you have no direct relationship with but who can still compromise your security.
- Lesson 2540 — Fourth-Party and Supply Chain Risk
- Fragmentation
- Fragmentation is the technique of splitting IP packets into smaller pieces (fragments) that are reassembled by the target host.
- Lesson 369 — Fragmentation and Packet Manipulation
- Freshness vs performance tradeoff
- Cache too long, and revocations are delayed; cache too short, and performance suffers
- Lesson 191 — Certificate Revocation Lists (CRLs)
- Frida
- Frida is a dynamic instrumentation toolkit that lets you inject JavaScript into running mobile apps.
- Lesson 2726 — Dynamic Analysis and Runtime InstrumentationLesson 2727 — Certificate Pinning Bypass Techniques
- From subnet discovery
- The gateway is typically the first or last usable IP in a subnet (e.g., 192.168.1.1)
- Lesson 353 — Gateway and Router Identification
- From traceroute results
- The first hop beyond your local machine is usually your gateway; subsequent hops reveal routing infrastructure
- Lesson 353 — Gateway and Router Identification
- Front-Channel Communication
- The RP's browser can periodically check with the IdP (in a hidden iframe) whether the user's IdP session is still valid. If the IdP session ends, the RP can respond accordingly.
- Lesson 775 — OIDC Session Management and Single Logout
G
- Gadget chains
- Gadget chains are sequences of method calls triggered automatically during deserialization.
- Lesson 1184 — Insecure Deserialization in Java
- gadgets
- Instead, attackers chain together tiny existing code fragments already present in executable memory—called gadgets—to perform arbitrary operations.
- Lesson 2109 — Return-Oriented Programming (ROP)
- Generalization
- Generalization means replacing specific values with broader categories.
- Lesson 2906 — Generalization and Suppression
- Git hooks
- Git hooks are stored in .git/hooks/ and can execute any security validation you define.
- Lesson 1397 — Commit-Time Security Gates
- GitHub Advisory Database
- Integrated directly into GitHub's ecosystem, it tracks vulnerabilities across multiple languages and automatically alerts repository owners when their dependencies are affected.
- Lesson 1262 — Vulnerability Databases and CVE Tracking
- GitLeaks
- truffleHog and GitLeaks are specialized tools that scan container images (and git repositories) for secrets using pattern matching and entropy analysis:
- Lesson 1640 — Secrets and Sensitive Data in Images
- global sensitivity
- This maximum possible change is called global sensitivity, and it directly controls how much noise you need.
- Lesson 2917 — Sensitivity and Query Analysis
- Grants
- Grants are tokens that provide temporary, narrow permissions—perfect for automated workflows where an application needs to encrypt data without permanent key access.
- Lesson 1769 — Encryption Key Policies and Access Control
- Granular Data Collection
- Granular Data Collection means choosing the appropriate level of specificity when gathering information.
- Lesson 2898 — Granular Data Collection
- gratuitous ARP
- A gratuitous ARP is an ARP response sent without being requested.
- Lesson 385 — ARP Cache Mechanics and Poisoning Principles
- Guard relays
- Guard relays are your entry point into the Tor network.
- Lesson 2985 — Tor Relays: Guard, Middle, and Exit
- Guidelines
- Guidelines are recommendations and best practices—not mandatory, but strongly suggested.
- Lesson 2488 — Policy Hierarchy: Policies, Standards, Procedures, Guidelines
H
- HackerOne
- HackerOne is the largest platform by user base, hosting programs for companies like the U.S.
- Lesson 2480 — Bug Bounty Platform Ecosystem
- Hacktivists
- Hacktivists are attackers motivated by beliefs—political activism, social justice, environmental concerns, or ethical stances.
- Lesson 50 — Motivations: Hacktivism and Ideological Attacks
- Hardening
- Hardening means disabling or restricting dangerous features entirely.
- Lesson 1250 — Sandboxing and Template Engine Hardening
- Hardware acceleration
- Hardware acceleration means the CPU includes special built-in circuits designed specifically to perform AES operations.
- Lesson 94 — Hardware Acceleration and AES-NI
- hardware root of trust
- A hardware root of trust is a secure, immutable foundation embedded in silicon that stores cryptographic secrets and performs security-critical operations.
- Lesson 2796 — Device Identity and Hardware Root of Trust
- hash
- A hash function is a mathematical algorithm that takes any amount of input data (whether it's a single character or an entire movie file) and transforms it into a fixed-size output called a hash or digest.
- Lesson 198 — Hash Function Fundamentals
- hash function
- A hash function is a mathematical algorithm that takes any amount of input data (whether it's a single character or an entire movie file) and transforms it into a fixed-size output called a hash or digest.
- Lesson 198 — Hash Function Fundamentals
- Hashtopolis
- Hashtopolis is a popular open-source framework that acts as a server/agent system: you install agents on multiple cracking nodes (your laptop, a server, cloud instances), and the server distributes chunks of the keyspace to each agent.
- Lesson 2234 — Cloud-Based and Distributed Cracking
- Header Handling Changes
- HPACK compression (HTTP/2) and QPACK (HTTP/3) change how headers are processed. Your WAF and security middleware must understand these compression schemes or work at the decoded layer to catch attacks properly.
- Lesson 1104 — Migrating Safely to HTTP/2 and HTTP/3
- Header name conflicts
- HTTP/2 allows header names that are invalid in HTTP/1.1 (like headers with spaces or uppercase letters). During downgrade, proxies may strip, normalize, or pass these through differently.
- Lesson 1112 — HTTP/2 Downgrade and Smuggling
- Header-based transmission
- Header-based transmission is the most secure approach:
- Lesson 1009 — API Key Authentication: Design and Security
- HID attacks
- The USB pretends to be a keyboard, typing malicious commands faster than humans can react (Rubber Ducky-style attacks)
- Lesson 2251 — QR Code and USB Drop Attack Tools
- High
- Current controls are weak; threat actors are motivated; similar incidents have occurred
- Lesson 2891 — Privacy Risk Assessment Methodology
- Hopper
- Hopper is a disassembler for iOS binaries (Mach-O files), converting ARM/ARM64 machine code into assembly instructions and attempting to reconstruct higher-level pseudocode.
- Lesson 2724 — Decompiling and Disassembling Mobile Apps
- horizontal escalation
- While vertical escalation means gaining higher privileges (normal user → admin), horizontal escalation means staying at your privilege level but accessing resources belonging to other users at the same level.
- Lesson 825 — Horizontal Privilege Escalation Patterns
- host-based firewall
- Think of network security like a medieval castle: the network firewall is your outer wall protecting the perimeter, but a host-based firewall is the locked door on each individual room inside.
- Lesson 1584 — Host-Based Firewall Architecture and Purpose
- hostapd
- hostapd is a more feature-complete solution:
- Lesson 535 — Evil Twin Attack Techniques and Tools
- HTTP headers
- HTTP headers are better than URLs but require JavaScript to set on every request, making them cumbersome for traditional web apps.
- Lesson 706 — Session Transmission: Cookies vs URL Parameters vs Headers
- HTTP method confusion
- A GET /api/users might be public, but DELETE /api/users/{id} exists without verifying the caller is an admin.
- Lesson 1031 — API5:2023 - Broken Function Level Authorization
- HTTP POST Binding
- The assertion is sent via an auto-submitted HTML form in the response body. Supports larger payloads and is more commonly used for responses.
- Lesson 777 — SAML Authentication Flow
- HTTP Redirect Binding
- The assertion is encoded in the URL query string (Base64 + URL-encoded). Limited by URL length but doesn't require JavaScript.
- Lesson 777 — SAML Authentication Flow
- httpOnly cookies
- httpOnly cookies are inaccessible to JavaScript—the browser handles them automatically.
- Lesson 794 — JWT Storage and XSS Risks
- HTTPS enforcement
- HTTPS enforcement means redirecting all HTTP traffic to HTTPS automatically and setting HSTS headers to prevent protocol downgrade attacks.
- Lesson 1864 — CDN SSL/TLS Configuration
I
- IaC pipeline security
- IaC pipeline security means embedding security controls—scanning tools, policy enforcement, and human approvals—directly into your CI/CD automation, treating infrastructure deployment with the same rigor as application code releases.
- Lesson 3006 — IaC Pipeline Security and CI/CD Integration
- IAM policies
- IAM policies are checked for additional permissions
- Lesson 1769 — Encryption Key Policies and Access Control
- ID Token
- In OpenID Connect, the ID token is a special credential that proves who the user is.
- Lesson 769 — OpenID Connect Overview and Relationship to OAuth 2.0Lesson 770 — ID Tokens and JWT Structure in OIDC
- IDA Pro
- IDA Pro is the industry-standard commercial disassembler with sophisticated analysis features, plugin ecosystems, and excellent ARM support for embedded systems.
- Lesson 2762 — Reverse Engineering Firmware Binaries
- Identification
- Identification is establishing which identity you're claiming (stating your name).
- Lesson 1206 — Authentication vs Identification: Terminology Changes
- Image signing
- Image signing is like sealing an envelope with wax and your personal stamp.
- Lesson 1644 — Image Signing and Verification
- Immutable Artifacts
- Once a model version is trained, it should be immutable and cryptographically signed (lesson 2874).
- Lesson 2878 — ML Pipeline Security and Governance
- Implementation Complexity
- Getting MPC right is hard. Unlike using a hash function, you need specialized libraries, careful network design, and deep cryptographic expertise to avoid subtle vulnerabilities.
- Lesson 261 — Practical MPC Applications and Limitations
- Implementation errors
- Developers are more likely to make mistakes in complex systems
- Lesson 2667 — Economy of Mechanism
- In-Memory Execution
- In-Memory Execution (fileless malware) is particularly effective.
- Lesson 1570 — Antivirus Evasion Techniques
- In-scope assets
- In-scope assets are the specific systems, domains, and applications researchers are authorized to test.
- Lesson 2481 — Program Scope and Rules of Engagement
- Inbound
- Blocked (NAT is one-way only; no unsolicited inbound connections allowed)
- Lesson 1831 — NAT Gateway Architecture
- incident
- An incident is a subset of events that indicates actual harm, policy violation, or imminent threat requiring coordinated response.
- Lesson 2361 — Incident vs Event: Defining the Threshold
- incident response
- DLP monitoring means actively watching alert streams to detect when sensitive data moves inappropriately, while incident response is your structured approach to investigating and remediating those violations before they become breaches.
- Lesson 1808 — DLP Monitoring and Incident Response
- Incident Response Policy
- An Incident Response Policy is the organizational blueprint that defines who does what, when, and how during a security incident.
- Lesson 2492 — Incident Response Policy
- Increased Attack Surface
- Tokens living in JavaScript are vulnerable to XSS attacks. If an attacker injects malicious code, they can immediately steal the token from memory or intercept it from the URL.
- Lesson 765 — Implicit Flow Deprecation and Risks
- IndexedDB
- A full NoSQL database in the browser for complex data structures
- Lesson 1072 — Client-Side Storage Overview and Threat Model
- Individually identifiable
- Individually identifiable means the information either identifies the person or could reasonably be used to identify them.
- Lesson 2582 — Protected Health Information (PHI)
- Inherent risk
- Inherent risk is the level of risk that exists in its natural, untreated state—before you apply any security controls.
- Lesson 2505 — Inherent vs Residual Risk
- Inherited controls
- Inherited controls are those the cloud provider implements and maintains.
- Lesson 1691 — Compliance Responsibility Mapping
- Injection Flaws
- Injection Flaws are among the most prevalent.
- Lesson 1260 — Common Vulnerability Types in Dependencies
- Inline Signatures
- The signature packet wraps around the message data. Everything travels together in the packet structure.
- Lesson 2960 — OpenPGP Message Format and Operations
- Input Validation
- Input validation means checking that incoming data (in requests) matches your expectations before using it.
- Lesson 615 — Preventing LDAP InjectionLesson 1039 — Input Validation and Output Encoding
- Instance monitoring and runtime protection
- Instance monitoring and runtime protection means installing specialized agents directly on your VMs that continuously watch for suspicious behavior, unauthorized changes, and active attacks while the instance is operational.
- Lesson 1930 — Instance Monitoring and Runtime Protection
- instance profile
- An instance profile is a container for an IAM role that you attach to a compute resource.
- Lesson 1734 — Instance Profiles and Container Credentials
- Instance profiles
- Instance profiles are the mechanism that attaches an IAM role to a cloud VM (like an EC2 instance).
- Lesson 1926 — IAM Roles and Instance Profiles
- instrumentation agents
- IAST tools inject lightweight monitoring code—called instrumentation agents—into your application's runtime environment.
- Lesson 1378 — IAST Fundamentals and How It Works
- Integration
- Integration means feeding the structured threat scenarios from threat modeling directly into your risk analysis process, transforming abstract threats into concrete, prioritized risks with dollar values and likelihood percentages.
- Lesson 2514 — Threat Modeling Integration with Risk Analysis
- Integration Framework
- The connective tissue linking your SOAR to other tools (SIEM, EDR, firewalls, threat intel feeds, ticketing systems). Uses APIs, webhooks, and custom connectors to enable bidirectional communication. Without robust integrations, your SOAR can't pull data or execute actions across your security stack.
- Lesson 2326 — SOAR Architecture and Components
- Integrity
- Integrity is maintained through various checks (input validation + audit logs + checksums)
- Lesson 3 — Defense in DepthLesson 13 — CIA Triad: Confidentiality, Integrity, Availability
- inter-service encryption
- This is called inter-service encryption, and it prevents attackers who've breached your network perimeter from eavesdropping or tampering with internal traffic.
- Lesson 1776 — Encryption Between Cloud Services
- Internal audits
- Internal audits are planned, systematic examinations of your ISMS against ISO 27001 requirements and your own documented processes.
- Lesson 2608 — Internal Audits and Management Review
- Internal Resource Access
- An attacker changes a URL parameter to http://localhost:6379 to probe internal Redis databases, or http://169.254.169.254/latest/meta-data/ to steal cloud provider credentials.
- Lesson 1033 — API7:2023 - Server Side Request Forgery (SSRF)
- Internal security
- Internal security means protecting resources within your trust boundaries.
- Lesson 25 — Perimeter vs Internal Security
- introspection
- GraphQL comes with a powerful built-in feature called introspection that lets anyone query the API to discover its complete schema—every type, field, query, mutation, and argument available.
- Lesson 1000 — GraphQL Introspection and Information Disclosure
- Inventory Constraints
- An online store shows "3 items remaining." An attacker places multiple simultaneous orders before the inventory counter updates, purchasing more than actually exists.
- Lesson 941 — Testing Limits and Constraints
- iOS Keychain
- iOS Keychain is a secure, encrypted container managed by the operating system.
- Lesson 2734 — Secure Data Storage on Mobile
- IP addresses
- The network locations attackers connect from
- Lesson 2336 — Indicators of Compromise (IOCs) and Their Limitations
- IP spoofing
- IP spoofing means forging the source address in a packet header to make it appear from a different IP.
- Lesson 370 — Decoy Scanning and IP Spoofing
- ISAKMP SA
- IKE Phase 1 establishes what's called an ISAKMP SA (Internet Security Association and Key Management Protocol Security Association) — essentially a secure, authenticated control channel.
- Lesson 479 — Internet Key Exchange (IKE) Phase 1
- ISO 19011
- ISO 19011 is the gold standard for audit management.
- Lesson 2545 — Audit Frameworks and Standards
- ISO 27001
- ISO 27001 is an internationally recognized standard that defines how to build and maintain a Security Management System.
- Lesson 22 — ISO 27001 and Security Management Systems
- ISO 27005
- ISO 27005 is the international standard for information security risk management, tightly integrated with ISO 27001.
- Lesson 2507 — Risk Assessment Methodologies and Frameworks
- isogenies
- Isogeny-based cryptography uses special mathematical mappings called isogenies between elliptic curves to build encryption schemes resistant to quantum attacks.
- Lesson 274 — Isogeny-Based Cryptography
- isogeny
- An isogeny is a structure-preserving map between two elliptic curves.
- Lesson 274 — Isogeny-Based Cryptography
- Isolation
- The malware can't escape to harm the real system
- Lesson 1567 — Behavioral Detection and Sandboxing
- Issuer
- The Certificate Authority (CA) that vouches for this certificate—the "issuing country" in our passport analogy
- Lesson 171 — X.509 Certificate Structure and Format
- Iterative improvement
- Defenses are tuned on-the-spot, then retested
- Lesson 2168 — Purple Team: Bridging Red and Blue
- Iterative refinement
- Iterative refinement is key: run scans, review false positives, adjust rules, repeat.
- Lesson 1363 — False Positives and Tuning SAST Tools
- Iterative threat modeling
- Iterative threat modeling means revisiting your threat model during each sprint or development cycle.
- Lesson 79 — Threat Modeling During Development
J
- JAB Provisional Authorization
- The Joint Authorization Board (representing DoD, DHS, and GSA) grants provisional authorization, providing the highest reusability across agencies.
- Lesson 2613 — FedRAMP Authorization Framework
- Jailbreaking
- Jailbreaking is the art of crafting prompts that convince an LLM to bypass its safety constraints.
- Lesson 2858 — Jailbreaking and Constraint Bypass
K
- key
- The key (literally) is what's kept private, not the lock design.
- Lesson 1214 — Open Design and Security Through Transparency
- Key activation
- Key activation is the controlled procedure for making a cryptographic key operational in a system.
- Lesson 314 — Key Activation and Installation
- Key Derivation Function
- A Key Derivation Function is a cryptographic algorithm that transforms weak input material (like passwords or master keys) into strong cryptographic keys suitable for encryption, authentication, or other purposes.
- Lesson 137 — Key Derivation Functions (KDFs) Overview
- Key escrow
- Key escrow means giving a trusted third party a copy of your keys.
- Lesson 311 — Key Backup and Recovery ProceduresLesson 317 — Key Backup and Recovery
- Key generation
- Keys are created in your environment
- Lesson 1766 — Client-Side Encryption for Cloud Data
- Key policies
- Key policies are resource-based policies attached directly to encryption keys in your Key Management Service.
- Lesson 1769 — Encryption Key Policies and Access Control
- Key policy
- Key policy is evaluated first (explicit deny blocks immediately)
- Lesson 1769 — Encryption Key Policies and Access Control
- Key rotation
- Key rotation means proactively replacing encryption keys before compromise occurs:
- Lesson 2963 — Forward Secrecy and Key Rotation in Email
- Key sanitization
- Key sanitization means ensuring that every copy of the key material is irreversibly erased from all locations: RAM, disk, backup tapes, hardware tokens, logs, and even swap files or hibernation images.
- Lesson 320 — Key Destruction and Sanitization
- Key storage
- More frequent rotation means more keys to manage
- Lesson 2981 — Post-Compromise Security and Future Secrecy
- Key synchronization
- Key synchronization is tricky: you can't just copy keys (that breaks forward secrecy).
- Lesson 2955 — Device Management and Multi-Device Security
- Key wrapping
- Key wrapping is a specialized encryption mode designed specifically for encrypting keys.
- Lesson 308 — Key Storage Encryption and Protection
- Key-value manipulation
- In Redis, commands are string-based. Injecting command separators can execute multiple operations.
- Lesson 594 — NoSQL Database Fundamentals and Attack Surface
- Keychain
- The Keychain is iOS's encrypted vault for sensitive credentials (passwords, tokens, certificates, cryptographic keys).
- Lesson 2704 — Data Protection API and Keychain
- Keylogging
- The attacker's injected script uses JavaScript event listeners to capture keydown, keypress, or keyup events. Every character typed—passwords, credit cards, messages—gets recorded and sent to the attacker's server.
- Lesson 639 — Keylogging and Form Hijacking
- kubelet
- An agent on each worker node that ensures containers are running as specified. It communicates directly with the API server. Risk: If compromised, an attacker gains node-level access and can manipulate containers.
- Lesson 1662 — Kubernetes Architecture and Attack SurfaceLesson 1671 — Kubelet Security and Node Hardening
L
- Label flipping
- Label flipping is a data poisoning technique where an attacker changes the labels of carefully selected training samples to cause a model to misclassify specific inputs at inference time.
- Lesson 2819 — Label Flipping and Targeted Poisoning
- Laplace Mechanism
- The Laplace Mechanism is the foundational technique: it adds random noise drawn from a Laplace distribution to query outputs, where the noise scale is calibrated to the query's sensitivity and your chosen epsilon.
- Lesson 2915 — The Laplace Mechanism
- Lateral movement
- Lateral movement is the technique of pivoting from one compromised system to another within a network, spreading access like ripples in a pond.
- Lesson 2150 — Lateral Movement Fundamentals and Objectives
- Lattice-based cryptography
- Based on finding short vectors in high-dimensional grids (lattices). This is the most promising approach, offering efficiency and versatility.
- Lesson 268 — Post-Quantum Cryptography Fundamentals
- Layered authentication and authorization
- Layered authentication and authorization means implementing multiple, independent identity verification and access control checks across different system boundaries and privilege levels.
- Lesson 2659 — Layered Authentication and Authorization
- layered controls
- Validate that layered controls are actually working
- Lesson 2661 — Monitoring and Response Across Layers
- layers
- In serverless architectures, layers are packages of shared libraries, dependencies, or runtime code that multiple functions can reference.
- Lesson 1957 — Function Layer Security
- Least privilege
- Least Privilege means every component, user, or service receives only the minimum permissions necessary to perform its function.
- Lesson 430 — Least Privilege Network AccessLesson 1950 — Least Privilege for Serverless FunctionsLesson 2018 — Least Privilege in IaC: Roles, Permissions, and Service AccountsLesson 2032 — Security Design Patterns
- Least privilege routing
- Only add routes that are strictly necessary. Don't associate a public subnet route table with a database subnet that should never touch the internet.
- Lesson 1830 — Route Tables and Subnet Associations
- Leaves
- Leaves are individual exploits or entry points across architectural components
- Lesson 2641 — Architecture-Level Attack Trees
- Length
- Hash output length is your first clue. MD5 hashes are always 32 hexadecimal characters, SHA-1 produces 40, and SHA-256 yields 64.
- Lesson 2226 — Hash Identification and Analysis
- License conflicts
- Some licenses are incompatible with each other. For example, you cannot combine GPL and Apache 2.0 code in certain ways. SCA detects when your dependency graph contains conflicting terms.
- Lesson 1272 — License Compliance Scanning
- LicenseFinder
- LicenseFinder is an open-source alternative that supports multiple package managers and allows you to define custom policies.
- Lesson 1307 — License Compliance Scanning
- Limited budget
- Finite number of queries (though sometimes millions are feasible)
- Lesson 2827 — Model Extraction Attack Fundamentals
- Limits breach impact
- If other systems are compromised, the CDE remains isolated
- Lesson 453 — Segmentation for Compliance
- LINDDUN
- The go-to choice when privacy is paramount (healthcare, finance, personal data processing). It focuses specifically on privacy threats that STRIDE might overlook. However, it's narrower in scope—less effective for general security concerns.
- Lesson 75 — Comparing Threat Modeling Methodologies
- LinEnum
- LinEnum is another popular script that performs similar enumeration but with a different output format and check coverage.
- Lesson 2149 — Linux Privilege Escalation Enumeration
- Local caching
- Local caching means storing a secret in memory after fetching it once.
- Lesson 1334 — Secret Store Access Patterns
- Log injection
- Log injection is particularly sneaky: attackers inject malicious payloads into function logs, which downstream log processing functions might execute or parse unsafely.
- Lesson 1944 — Serverless Data Flow and Injection Risks
- Log rotation
- Log rotation is like having multiple buckets on a carousel: when one fills, you rotate to the next, archive the full one, and eventually discard the oldest.
- Lesson 1484 — Log Rotation and Retention Policies
- Long-term credentials
- Long-term credentials are like traditional house keys—they work indefinitely until you explicitly revoke or replace them.
- Lesson 1729 — Temporary Credentials vs Long-Term Credentials
M
- MAC address
- A MAC address is the hardware identifier burned into every network card—it's how switches know which physical port to send frames to.
- Lesson 406 — MAC Address Spoofing and Duplication
- MAC address spoofing
- MAC address spoofing means changing your network card's MAC address to impersonate another device.
- Lesson 406 — MAC Address Spoofing and Duplication
- MAC flooding
- In the previous lesson, you learned that MAC flooding is an attacker technique to break out of switch isolation.
- Lesson 404 — Port Mirroring and SPAN Ports
- macOS Keychain
- A system service that encrypts keys using hardware-backed encryption when available
- Lesson 309 — Software Key Storage Mechanisms
- magic numbers
- Every file type has distinctive byte patterns called magic numbers or file signatures.
- Lesson 2402 — File Carving and Deleted File Recovery
- Mail server routing information
- The path your message took
- Lesson 2964 — Metadata Leakage in Encrypted Email
- Mailvelope
- Mailvelope is a browser extension for webmail clients (Gmail, Outlook.com, etc.).
- Lesson 2961 — Email Client Integration and Plugins
- Management reviews
- Management reviews are periodic leadership evaluations where executives assess the ISMS performance, resource needs, and improvement opportunities.
- Lesson 2608 — Internal Audits and Management Review
- Managing False Positives
- Managing False Positives is crucial—not every flagged CVE affects your code path.
- Lesson 1273 — SCA Tool Integration and Configuration
- manifest
- The manifest is like a blueprint or table of contents.
- Lesson 1632 — Container Image Anatomy and Layers
- Manual encoding
- Manual encoding means you, the developer, explicitly call encoding functions every time you output data:
- Lesson 1224 — Template Auto-Escaping vs Manual Encoding
- Manual Security Testing
- Manual Security Testing represents expert review that automation can't replace—context-aware threat analysis, business logic flaws, and sophisticated attack chains.
- Lesson 2741 — Mobile Security Testing and CI/CD
- mask attack
- A mask attack is a smarter, optimized version of brute-forcing.
- Lesson 2229 — Brute-Force and Mask Attacks
- MaxStartups
- Controls how many unauthenticated connection attempts can occur simultaneously. This defends against connection flood attacks by limiting pending authentication sessions. Format is start:rate:full (e.g., 10:30:60 means start dropping 30% of connections after 10 concurrent attempts, dropping all after 60).
- Lesson 1447 — Idle Timeout and Connection Limits
- MD5
- Collisions can be generated in seconds on modern hardware. Attackers demonstrated this as early as 2004, and tools to create MD5 collisions are now publicly available.
- Lesson 208 — MD5 and SHA-1: Broken Hash Functions
- Medical research
- Hospitals encrypt patient records, researchers analyze encrypted data for patterns, and results are returned encrypted—protecting patient privacy throughout.
- Lesson 2924 — Homomorphic Encryption Applications
- metadata services
- These metadata services are designed to be accessible only from within the cloud instance, but SSRF vulnerabilities can break that boundary.
- Lesson 885 — Cloud Metadata Service Attacks
- microsegmentation
- Zero Trust network segmentation—often called microsegmentation—takes this much further by creating security boundaries around individual workloads, applications, or even processes rather than broad network zones.
- Lesson 2679 — Zero Trust Network Segmentation
- Misconfiguration protection
- If firewall rules are accidentally removed, the service remains unreachable
- Lesson 1436 — Network Service Binding
- misuse cases
- While traditional use cases describe how legitimate users interact with your system, abuse cases (also called misuse cases) flip the script: they describe how an attacker might exploit your system's features.
- Lesson 2029 — Abuse Cases and Misuse Cases
- Mitigation Tracking
- Mitigation Tracking is your action plan.
- Lesson 81 — Threat Model Documentation and Artifacts
- mitmproxy
- mitmproxy is a Python-based interactive HTTPS proxy perfect for inspecting and manipulating web traffic.
- Lesson 401 — MITM Attack Tools and Frameworks
- Model inversion
- Model inversion is the process of reconstructing actual training data samples—or approximate replicas—by querying a trained model repeatedly and analyzing its outputs.
- Lesson 2832 — Model Inversion and Attribute Inference
- Modules
- The recipes you actually use. Five main types:
- Lesson 2193 — Metasploit Architecture and Components
- Multi-channel verification
- Multi-channel verification is essential.
- Lesson 2294 — Vendor and Third-Party Communication Security
- Multi-level security
- Multi-level security is needed (Top Secret, Secret, Unclassified data on same system)
- Lesson 1450 — MAC vs DAC: Fundamental Differences
- Multi-step IDOR exploitation
- Multi-step IDOR exploitation means an attacker chains these requests together, manipulating object IDs at each stage to access or modify resources they shouldn't touch.
- Lesson 818 — Multi-Step IDOR Exploitation
- Multiple downstream targets
- A single function might query databases, invoke APIs, and execute commands
- Lesson 1960 — Injection Vulnerabilities in Serverless
N
- Name Constraints
- Name Constraints are like property boundaries for intermediate CA certificates.
- Lesson 185 — Name Constraints and Certificate Extensions
- Naming conventions
- Naming conventions are critical for governance.
- Lesson 1721 — Creating and Managing Service Accounts
- Network ACL
- A Network ACL is a stateless firewall that operates at the subnet level in your VPC.
- Lesson 1822 — Network ACL Structure and Subnet Association
- Network ACLs
- Rules are processed in numerical order (lowest first). The first matching rule wins—subsequent rules are ignored. Includes explicit deny rules.
- Lesson 1819 — Security Groups vs Network ACLs: Fundamental Differences
- Network segmentation
- Limits damage when an endpoint is compromised
- Lesson 1573 — Antivirus Limitations and Complementary Controls
- nftables
- nftables is the modern successor that unifies all these separate tools into a single framework with consistent syntax.
- Lesson 443 — nftables Architecture and ImprovementsLesson 1586 — iptables and nftables on Linux
- NIST SP 800-22
- NIST SP 800-22 is a suite of 15 statistical tests developed by the National Institute of Standards and Technology.
- Lesson 293 — Testing Randomness Quality
- No credential stuffing
- No passwords means no breached credentials to reuse
- Lesson 755 — Passwordless Security Trade-offs
- No credential theft
- Attackers can't intercept passwords because none are sent
- Lesson 542 — EAP-TLS and Certificate-Based Authentication
- No hop limit enforcement
- No hop limit enforcement means requests can be forwarded through proxies or misconfigurations
- Lesson 1934 — IMDSv1 vs IMDSv2 Security Improvements
- No length padding vulnerabilities
- The sponge construction naturally avoids certain extension attacks
- Lesson 210 — SHA-3 and the Keccak Algorithm
- No periodic password changes
- Only change when compromise is suspected
- Lesson 694 — Password Complexity Requirements and Their Effectiveness
- No Refresh Tokens
- The implicit flow never issues refresh tokens for security reasons. When your access token expires, you must re-authenticate the user, creating a poor user experience.
- Lesson 765 — Implicit Flow Deprecation and Risks
- No special cases
- The curve arithmetic avoids edge cases that cause timing leaks
- Lesson 167 — Curve25519 and EdDSA
- No stack traces to users
- Detailed technical errors (stack traces, database errors, file paths) are gold for attackers mapping your infrastructure.
- Lesson 1156 — Validation Error Handling
- no-cloning theorem
- The no-cloning theorem is a fundamental law of quantum mechanics: you cannot create an identical copy of an unknown quantum state.
- Lesson 280 — QKD Security Guarantees and No-Cloning Theorem
- Noisy Neighbor Attacks
- A malicious container can consume excessive CPU, memory, or disk I/O to starve other tenants' workloads—essentially a denial-of-service within the host.
- Lesson 1631 — Multi-Tenancy Security Challenges
- non-interactive proof
- A non-interactive proof is a single, standalone message.
- Lesson 242 — Interactive vs Non-Interactive Proofs
- non-reversibility
- This is called non-reversibility or the one-way property.
- Lesson 206 — Non-Reversibility and One-Way Property
- non-transitive routing
- Think of it like building a private bridge between two gated communities—residents can visit each other directly without going through public roads, but visitors from one community can't automatically access a third community through the bridge (this is called non-transitive routing).
- Lesson 1836 — VPC Peering Fundamentals
- nonce
- A nonce (number used once) is a value that must be unique for each encryption operation with the same key.
- Lesson 131 — Nonces vs IVs: Definitions and DifferencesLesson 661 — Nonces and Hashes for Inline Content
- nonce management
- Like AES-GCM, proper nonce management is critical—never reuse a nonce with the same key, or you compromise both confidentiality and authenticity.
- Lesson 127 — ChaCha20-Poly1305
- Nonprofits and government entities
- Nonprofits and government entities are generally exempt
- Lesson 2562 — CCPA Overview and Scope
- NoSQLMap
- NoSQLMap is a specialized tool designed to automate the discovery and exploitation of NoSQL injection vulnerabilities.
- Lesson 592 — NoSQLMap and NoSQL Injection Automation
O
- Object storage
- You control bucket policies, object ACLs, encryption settings, and versioning. Provider secures the underlying infrastructure. Public exposure risks are YOUR responsibility—misconfigured bucket policies are the #1 cloud data breach vector.
- Lesson 1781 — Cloud Storage Service Models and Security Responsibilities
- Official images
- Official images are maintained by Docker or the software vendor (like nginx:latest or ubuntu:22.04).
- Lesson 1633 — Base Image Selection and Trust
- On pull request creation
- Block merging until secrets are removed
- Lesson 1353 — CI/CD Pipeline Secret Scanning
- OneCRL
- CRLSets (Chrome) and OneCRL (Firefox) are browser-maintained lists of revoked certificates.
- Lesson 197 — Modern Revocation Alternatives
- OPA Gatekeeper
- OPA Gatekeeper is a popular tool that uses admission controllers to enforce policy-as-code.
- Lesson 1973 — Kubernetes Admission Controllers
- oracle
- This is called an oracle because the server "answers questions" about padding validity without realizing it's leaking secrets.
- Lesson 97 — CBC Padding Oracle Attacks
- Orchestration Engine
- This is the brain of your SOAR platform. It executes workflows, manages task queues, schedules automated actions, and coordinates between different security tools. Think of it as a conductor ensuring each automation step fires at the right time and in the right sequence.
- Lesson 2326 — SOAR Architecture and Components
- Organization Leakage
- An enterprise app verifies team membership but doesn't ensure the resource being accessed belongs to that same team's organizational scope.
- Lesson 812 — Context-Dependent Authorization Failures
- Organized Criminals
- Organized Criminals are financially motivated professionals.
- Lesson 47 — Understanding Adversary Types and Skill Levels
- origin
- In web security, an origin is like your home address — it uniquely identifies where content comes from.
- Lesson 856 — Origin Definition and ComparisonLesson 1056 — Origin Components: Scheme, Host, and Port
- OSS-Fuzz
- OSS-Fuzz is Google's free service for open-source projects.
- Lesson 1394 — Continuous Fuzzing and Integration
- out-of-band patching
- Emergency patching (also called out-of-band patching) is your rapid response protocol for critical vulnerabilities that can't wait for your standard cycle.
- Lesson 2459 — Emergency and Out-of-Band Patching
- Out-of-scope targets
- Out-of-scope targets are systems researchers must not touch—even if vulnerabilities exist there.
- Lesson 2481 — Program Scope and Rules of Engagement
- Outdated packages
- Outdated packages are the most frequent vulnerability.
- Lesson 2875 — Dependency Vulnerabilities in ML Frameworks
- Output encoding
- Output encoding means transforming outgoing data (in responses) so it can't be misinterpreted as executable code by the receiver.
- Lesson 1039 — Input Validation and Output Encoding
- Overly permissive policies
- A user with iam:AttachUserPolicy can attach an admin policy to themselves
- Lesson 1753 — IAM Privilege Escalation Overview
- OWASP Top 10
- The OWASP Top 10 is a regularly updated document that ranks the most critical security risks facing web applications.
- Lesson 1200 — History and Purpose of the OWASP Top 10
- Owner
- The person or team responsible for the resource. Critical for incident response and accountability.
- Lesson 1997 — Mandatory Tags for Security and Compliance
P
- Package name reservation
- Package name reservation means proactively registering placeholder packages on public repositories (npm, PyPI, RubyGems, etc.) using the same names as your internal, private packages—before an attacker does.
- Lesson 1291 — Package Name Reservation and Defensive Registration
- packets
- Instead, it's broken into small pieces called packets.
- Lesson 374 — Understanding Network Packets and Protocol Layers
- Parameter entities
- Parameter entities are special entities defined in the DTD (Document Type Definition) and used within the DTD itself.
- Lesson 624 — XInclude and Parameter Entity Attacks
- parameter entity attacks
- XInclude injection and parameter entity attacks are two clever workarounds that bypass these defenses by exploiting different parts of the XML specification.
- Lesson 624 — XInclude and Parameter Entity Attacks
- Parameter tampering
- Parameter tampering is the practice of modifying these client-controlled values to trick the server into granting elevated privileges.
- Lesson 809 — Parameter Tampering for Authorization Bypass
- Partial responses
- The server returns data that doesn't match your request's expected length or content
- Lesson 1108 — Detecting Request Smuggling Vulnerabilities
- Passive reconnaissance
- Passive reconnaissance means collecting information without ever touching the target's systems.
- Lesson 337 — Active vs Passive Reconnaissance
- Passkeys
- Passkeys are the next evolution of passwordless authentication, building on WebAuthn (which you learned earlier).
- Lesson 754 — Passkeys and Cross-Device Authentication
- Password Reuse Reality
- Most users reuse passwords across multiple sites. When your database is breached, attackers don't just compromise your service—they gain access to users' email accounts, banking sites, social media, and workplace systems. One breach becomes dozens.
- Lesson 683 — Why Plain Text Password Storage is Catastrophic
- Patch compliance monitoring
- Patch compliance monitoring is the continuous process of verifying which systems have received their patches and which haven't.
- Lesson 2461 — Patch Compliance Monitoring and Reporting
- Patch Management Integration
- The most powerful aspect: CVM systems feed vulnerability data directly into patch management platforms. When a critical CVE is discovered on fifty servers, the integration automatically creates deployment tasks, tracks patching progress, and rescans to verify remediation—closing the loop from detection to fix.
- Lesson 1616 — Continuous Vulnerability Monitoring
- Path
- Limits cookies to specific URL paths. Path=/admin means the cookie only sends to URLs starting with /admin. However, this provides minimal security since same-origin JavaScript can still access these cookies.
- Lesson 1074 — Cookie Security Attributes Deep Dive
- Path sensitivity
- Path sensitivity means the tool remembers the conditions and checks that happened earlier in a code path.
- Lesson 1361 — Control Flow Analysis and Path Sensitivity
- Penetration testing
- Penetration testing is like a focused safety inspection of specific doors and windows.
- Lesson 2080 — What is Penetration Testing?Lesson 2085 — Penetration Testing vs Red Teaming
- pepper
- A pepper is a secret value stored outside the database (like in your application configuration or environment variables) that gets mixed into every password hash.
- Lesson 691 — Pepper: Application-Level Secrets for Defense-in-Depth
- Performance
- MPC is slow—often 1000× slower than regular computation. That secret sharing and garbled circuit overhead adds up. Computing on encrypted data means massive network traffic between parties.
- Lesson 228 — EdDSA and Ed25519 SignaturesLesson 261 — Practical MPC Applications and Limitations
- permission boundary
- A permission boundary is a policy that defines the maximum permissions an identity (including service accounts) can have, regardless of what its identity-based policies grant.
- Lesson 1707 — IAM Boundaries and Permission GuardrailsLesson 1727 — Service Account Permission Boundaries
- Permissions
- Permissions are the rules that tie everything together.
- Lesson 795 — Access Control Fundamentals
- Persistence
- Persistence is the set of techniques attackers use to maintain access across these disruptions.
- Lesson 1127 — Web Cache Poisoning via Host HeaderLesson 1536 — Persistence Fundamentals and Attacker Goals
- Persistent
- Attacks remain active until the malicious data is removed.
- Lesson 631 — Stored XSS: Persistent AttacksLesson 1527 — Advanced Persistent Threats (APTs)Lesson 2819 — Label Flipping and Targeted Poisoning
- Personal data
- Personal data is any information relating to an identified or identifiable natural person (the data subject).
- Lesson 2552 — Personal Data and Special Categories
- phishing kit
- A phishing kit is essentially a website-in-a-box that mimics legitimate login pages.
- Lesson 2261 — Phishing Infrastructure and Automation
- Physical
- a sticker, specific object, or lighting pattern
- Lesson 2822 — Trojan Attacks on Neural Networks
- Physical key control procedures
- Physical key control procedures are essential safeguards:
- Lesson 2283 — Lock Types and Physical Key Management
- pickle
- pickle is Python's native serialization format.
- Lesson 1186 — Insecure Deserialization in Python and Ruby
- Pipeline Integration
- Pipeline Integration means embedding the security scanning tools you learned earlier—like tfsec, checkov, or policy-as-code validators—directly into your CI/CD workflow.
- Lesson 2021 — IaC in CI/CD Pipelines: Security Gates and Approval Workflows
- pivot point
- A pivot point is a moment in an attack timeline where the attacker transitions from one phase to another or moves laterally to a new system.
- Lesson 2421 — Pivot Points and Indicators of Compromise
- PKCS#12
- PKCS#12 is a binary container format (.p12, .pfx) that bundles a certificate, its private key, and often the entire certificate chain into one password-protected file.
- Lesson 179 — Certificate Encoding: PEM, DER, PKCS#12, and Formats
- Platform authenticators
- Platform authenticators are built into your device—Touch ID on iPhones, Windows Hello, Android biometrics—making authentication seamless and hardware-backed.
- Lesson 745 — FIDO2 and WebAuthnLesson 752 — Platform and Roaming Authenticators
- Playbook Repository
- Your library of automated response procedures. Playbooks are pre-defined workflows that codify how to respond to specific security events—like "phishing email triage" or "malware containment." These are version-controlled, reusable templates that analysts can trigger manually or automatically based on SIEM alerts.
- Lesson 2326 — SOAR Architecture and Components
- Playbooks
- Playbooks are standardized decision trees that guide analysts through investigating specific alert types.
- Lesson 2311 — Playbooks and Standard Operating ProceduresLesson 2350 — Triage Playbooks and Runbooks
- Pod Security Standards
- Pod Security Standards (PSS) are three predefined security profiles that define what pod configurations are allowed:
- Lesson 1666 — Pod Security Standards and PoliciesLesson 1970 — Pod Security Standards and Policies
- policy definition
- A policy definition is the rule itself, written in JSON format.
- Lesson 1989 — Azure Policy and Blueprints
- Policy Engine
- The decision-making core that evaluates every access request against loaded security rules. This is the "rulebook" that contains thousands of allow/deny statements.
- Lesson 1453 — SELinux Architecture and Components
- polyglot file
- A polyglot file is a single file that is simultaneously valid in multiple file formats.
- Lesson 963 — Polyglot Files and Multi-Format Attack Prevention
- polyglot payload
- A polyglot payload is an XSS injection that executes successfully in multiple contexts simultaneously—HTML, JavaScript, attribute values, or even across different parsing engines.
- Lesson 656 — Polyglot Payloads and Mutation Fuzzing
- Port security
- Port security is a switch feature that restricts which MAC addresses can send traffic through a specific physical port.
- Lesson 409 — Switch Port Security and Defenses
- Possession
- Possession is about who has control of your data.
- Lesson 14 — The Parkerian Hexad: Extending the CIA Triad
- Post-Release Security Validation
- Post-Release Security Validation is the practice of verifying security controls in the live production environment immediately after deployment.
- Lesson 2068 — Post-Release Security Validation
- postMessage API
- The postMessage API is the browser's official solution: a secure messaging system that lets windows send data to each other across origins, but only if both sides explicitly participate.
- Lesson 1064 — postMessage API and Cross-Origin Communication
- Power analysis
- Measuring power consumption patterns to deduce cryptographic keys
- Lesson 2769 — Hardware Security Fundamentals and Threat Model
- pre-commit hook
- A pre-commit hook is a script that runs automatically before Git finalizes a commit.
- Lesson 1254 — Pre-commit Hooks for Secret Detection
- Pre-commit hooks
- Pre-commit hooks are automated scripts that run on a developer's machine before a commit is finalized.
- Lesson 1351 — Pre-commit Hooks for Secret PreventionLesson 1396 — Pre-commit and IDE Security ChecksLesson 1397 — Commit-Time Security GatesLesson 3003 — Version Control Security for IaC
- Pre-OS execution
- Pre-OS execution means no security tools are running yet
- Lesson 2759 — Firmware Fundamentals and Attack Surface
- Predictable storage and comparison
- You always know exactly how much space a hash will take. Comparing two hashes is always the same speed operation, regardless of the original data size.
- Lesson 204 — Fixed-Length Output Property
- preflight request
- A preflight request is a security checkpoint.
- Lesson 875 — CORS Request Types: Simple vs Preflight
- Preimage resistance
- Preimage resistance is a fundamental security property of cryptographic hash functions.
- Lesson 199 — Preimage Resistance
- PRESENT
- PRESENT is an ultra-compact 64-bit block cipher designed for hardware efficiency.
- Lesson 2793 — Lightweight Cryptographic Algorithms
- presigned URL
- A presigned URL is like a temporary key to a locked room.
- Lesson 1784 — Presigned URLs and Temporary Access Mechanisms
- principle of least privilege
- The Principle of Least Privilege means every user, process, application, or system component should have access only to the information and resources absolutely necessary to perform its legitimate function—nothing more.
- Lesson 1821 — Security Group Rule Design Best PracticesLesson 2663 — Principle of Least Privilege
- Prioritization
- Prioritization means deciding which threats deserve immediate attention and which can wait.
- Lesson 65 — Prioritizing STRIDE Threats
- Privacy amplification
- Privacy amplification is the principle that combining many updates makes it exponentially harder to infer information about any single participant.
- Lesson 2844 — Secure Aggregation and Privacy Amplification
- Privacy auditing
- Privacy auditing is the practice of empirically measuring whether a model leaks private training data, rather than just trusting theoretical guarantees.
- Lesson 2845 — Privacy Auditing and Empirical Measurement
- privacy budget
- Your privacy budget is the total amount of epsilon you can "spend" on a dataset before privacy guarantees degrade.
- Lesson 2914 — Privacy Budget and Epsilon
- Privacy-preserving identity
- Prove you're authorized without revealing which specific user you are (using techniques like ring signatures)
- Lesson 247 — ZKP Applications in Authentication
- private endpoint
- A private endpoint is provisioned in your chosen subnet
- Lesson 1848 — Private Link Architecture and Use Cases
- Private voting
- Votes are encrypted, tallied while encrypted, and only the final count is revealed.
- Lesson 2924 — Homomorphic Encryption Applications
- Privilege anomalies
- A standard user suddenly accessing admin-only resources
- Lesson 844 — Authorization Logging and Monitoring
- Privilege escalation
- A low-privilege user exploiting a shared component might affect high-privilege users
- Lesson 2670 — Least Common Mechanism
- Privilege Escalation Chains
- A compromised container in a multi-tenant environment presents a higher-value target. Attackers can leverage container escape vulnerabilities (covered earlier) to not only compromise the host but pivot to other tenants' workloads, multiplying the blast radius.
- Lesson 1631 — Multi-Tenancy Security Challenges
- Privilege Separation
- Privilege Separation is the technical version: different parts of a system run with only the permissions they absolutely need, isolated from each other.
- Lesson 7 — Separation of Duties and Privilege Separation
- Privileged Containers
- Running containers with the --privileged flag essentially disables most security boundaries, granting direct access to host devices and capabilities. This is like giving an apartment tenant the master key to the building.
- Lesson 1626 — Container Escape Vulnerabilities
- Proactive privacy
- Proactive privacy means anticipating privacy risks during design and implementation phases, building safeguards into systems from the start, and continuously monitoring for emerging threats before they materialize.
- Lesson 2881 — Proactive Not Reactive Privacy
- Proactive refresh
- Proactive refresh means updating cached secrets before they expire:
- Lesson 1334 — Secret Store Access Patterns
- Procedures
- Procedures are step-by-step operational instructions.
- Lesson 2488 — Policy Hierarchy: Policies, Standards, Procedures, Guidelines
- Protection from compromised users
- Protection from compromised users is essential—even root can't violate MAC policies
- Lesson 1450 — MAC vs DAC: Fundamental Differences
- Protocol analysis and reconstruction
- Protocol analysis and reconstruction is the process of taking fragmented packet captures and rebuilding them into coherent sessions, extracting files, and understanding what actually happened at the application layer (HTTP, FTP, SMTP, etc.).
- Lesson 2411 — Protocol Analysis and Reconstruction
- Protocol Flexibility
- While SMB is primary, CME also supports WinRM, MSSQL, LDAP, and SSH protocols, making it versatile across mixed environments.
- Lesson 2239 — CrackMapExec for Network Enumeration
- provenance
- Package provenance is the documented history of how a software package was built—who built it, from what source code, using which tools, and when.
- Lesson 1300 — Package Provenance and SLSALesson 1643 — Base Image Selection and ProvenanceLesson 2873 — Training Data Integrity and Provenance
- Provide Context
- An alert saying "Unusual API call detected" is useless. Instead: "User admin@example.com called DeleteBucket on production S3 bucket from IP 203.0.113.45 (first time from this IP)." Include who, what, where, when—everything needed to assess severity.
- Lesson 1896 — Cloud Alert Design Principles
- provisioning
- Getting PSKs onto devices is called provisioning:
- Lesson 2791 — Pre-Shared Key Authentication for IoT
- Proxychains
- Proxychains is a tool that forces any application's network connections through your SOCKS proxy chain.
- Lesson 2241 — Proxychains and SOCKS Tunneling
- Psychological Acceptability
- Psychological Acceptability means designing security mechanisms to be intuitive, convenient, and aligned with how users naturally think and work.
- Lesson 9 — Psychological Acceptability and Usable SecurityLesson 2669 — Psychological Acceptability
- Public Key
- In multivariate cryptography, the public key is a set of scrambled polynomial equations, while the private key contains a trapdoor (secret information) that makes solving them easy for the legitimate owner.
- Lesson 176 — Certificate Signing Requests (CSR)Lesson 275 — Multivariate Cryptography
- PublicKey
- The other peer's public key (for authentication)
- Lesson 494 — WireGuard Peer Configuration and Key Management
Q
- quasi-identifiers
- But here's the problem: quasi-identifiers are attributes that, while not uniquely identifying someone individually, can re-identify people when combined.
- Lesson 2904 — Quasi-Identifiers and Re-identification Risk
- Query access only
- The attacker can send inputs and receive predictions (black-box setting)
- Lesson 2827 — Model Extraction Attack Fundamentals
R
- radare2
- radare2 is a free, open-source framework offering command-line power for scripting analysis workflows and integrating with automated toolchains.
- Lesson 2762 — Reverse Engineering Firmware Binaries
- rainbow table
- A rainbow table is a massive precomputed database that maps millions or billions of common passwords to their hash values.
- Lesson 685 — Rainbow Tables and Why Simple Hashing Fails
- Range compression
- A "High" risk might represent wildly different actual exposures
- Lesson 2500 — Risk Calculation and Risk Matrices
- Rate Limiting
- The gateway tracks request counts per client, applying limits before requests consume backend resources. This protects against DoS attacks and API abuse without requiring each service to implement its own counters.
- Lesson 1043 — API Gateway and Defense Patterns
- Real-time communication matters
- Voice calls, video streams, or IoT sensors where data arrives continuously and latency is critical
- Lesson 121 — Stream Ciphers vs Block Ciphers: When to Use Each
- Real-time note-taking
- Real-time note-taking is non-negotiable.
- Lesson 2087 — Documentation and Note-Taking
- Rectification
- Rectification means you can request corrections to incomplete or inaccurate personal data.
- Lesson 2937 — Rights to Rectification and Restriction
- red team
- A red team is an independent security group that simulates real-world adversaries to test an organization's detection and response capabilities.
- Lesson 2169 — Red Team Operations and Objectives
- Red teaming
- Red teaming is like hiring professional burglars to test your entire security operation—not just the locks.
- Lesson 2085 — Penetration Testing vs Red Teaming
- Reduced attack surface
- Fewer peering connections means fewer trust relationships to secure
- Lesson 1243 — Stored Procedures and Database-Side SecurityLesson 1838 — Transit Gateway Architecture
- Redundancy
- Redundancy means having backup security controls—if one fails, another catches the threat.
- Lesson 28 — Redundancy and Diversity in Security
- Refresh tokens
- Refresh tokens are longer-lived credentials (days to months) used solely to request new access tokens.
- Lesson 760 — OAuth 2.0 Tokens: Access and Refresh
- Registry Auto-Run Keys
- Keys like HKLM\Software\Microsoft\Windows\CurrentVersion\Run specify programs to launch at startup. If these registry keys or the binaries they reference are writable by unprivileged users, attackers can hijack execution flow.
- Lesson 2134 — Scheduled Tasks and Startup Persistence Exploitation
- Reject
- Actively sends an error response (TCP RST or ICMP unreachable) back to the sender. This is faster for legitimate misconfigurations but tells attackers their traffic is being filtered.
- Lesson 462 — IPS Blocking Actions and Response
- Rejected connections
- A spike in rejected traffic to specific ports may indicate port scanning or brute-force attempts. For example, hundreds of rejected SSH attempts (port 22) from a single IP signals an attack.
- Lesson 1872 — VPC Flow Logs and Network Monitoring
- Rejecting
- Rejecting means refusing to process invalid input at all.
- Lesson 1155 — Rejecting vs Sanitizing Invalid Input
- RELATED
- A new connection, but linked to an existing one (like FTP data transfers spawned from a control connection)
- Lesson 440 — Stateful Firewall with Connection Tracking
- Relationships
- Components depend on other components. The SBOM should map these dependencies—which packages are direct dependencies versus transitive ones, and how they connect. This dependency graph reveals your true attack surface.
- Lesson 1279 — SBOM Contents and Metadata Quality
- Relevant
- The metric must tie to actual security or business goals. Measuring "total security events logged" matters less than "high-confidence security alerts requiring investigation."
- Lesson 2526 — Designing Effective Security Metrics
- Reliability
- Because you're using your operating system's standard connect() system call, this method works through most firewalls and doesn't require special privileges (no root/admin needed). If the connection succeeds, the port is definitively open.
- Lesson 339 — TCP Connect Scanning
- Remediation Capabilities
- Automated fixes are powerful but risky. Ensure you can control what runs automatically versus requiring human approval.
- Lesson 2011 — CSPM Vendor Selection and Deployment
- Remote port forwarding
- Remote port forwarding is the opposite of local forwarding.
- Lesson 501 — Remote Port Forwarding (-R)
- Repackaging
- Repackaging is the practice of taking an existing mobile app, decompiling it, modifying its code, then recompiling and re-signing it with a new certificate.
- Lesson 2731 — Repackaging and Code Injection Attacks
- Repeated failures
- A user hitting authorization blocks repeatedly may be probing boundaries
- Lesson 844 — Authorization Logging and Monitoring
- repudiation
- In security terms, repudiation means denying responsibility for an action.
- Lesson 58 — Repudiation Threats
- RequestReceived
- The API server received the request
- Lesson 1975 — Kubernetes Audit Logging and Monitoring
- requirements phase
- Threat modeling during the requirements phase means you identify security needs, constraints, and potential threats before you've committed to an architecture or written a single line of code.
- Lesson 77 — Threat Modeling in Requirements Phase
- Reseeding
- Reseeding is periodically adding fresh water from an unpredictable source.
- Lesson 291 — PRNG State and Reseeding
- Residual risk
- After you lock it to the table with a cable: Residual risk is lower, but someone could still cut the cable or steal the whole table
- Lesson 2166 — Retest and Validation ProcessLesson 2505 — Inherent vs Residual Risk
- Residual risk management
- Residual risk management is the ongoing process of monitoring these changes and reassessing whether your residual risk remains within acceptable tolerance levels.
- Lesson 2524 — Residual Risk Management
- Residual Risk Trend
- Monitor residual risk after controls are applied. This shows whether your risk treatment strategies are working.
- Lesson 2532 — Risk Posture and Trending Metrics
- Resource usage
- An EC2 instance that usually runs at 30% CPU spikes to 95% while making network connections to unknown IPs
- Lesson 1890 — Behavioral Analytics and Anomaly Detection
- Responder
- Responder is a tool that listens for LLMNR and NBT-NS queries, then responds claiming to be the requested resource.
- Lesson 2237 — Responder and LLMNR/NBT-NS Poisoning
- response handling
- After defending against SSRF attacks through validation and network controls, response handling is your last line of defense.
- Lesson 898 — Response Handling and Information Disclosure
- Restriction
- Restriction is like putting a "hold" sticker on your data.
- Lesson 2937 — Rights to Rectification and Restriction
- Resume support
- Resume support means tracking which chunks have been successfully transferred.
- Lesson 2971 — Large File Transfer Security
- Reverse Shells
- The compromised target connects back to your attacker machine:
- Lesson 2236 — Netcat and Socat for Network Pivoting
- reverse tunneling
- This technique is also called reverse tunneling when used to bypass restrictive firewalls.
- Lesson 501 — Remote Port Forwarding (-R)
- Revocation
- Revocation is reactive: "This certificate must stop working right now, even though it hasn't expired yet."
- Lesson 190 — Certificate Revocation Fundamentals
- right person
- Encrypting a file is only half the battle—sending it to the right person is equally critical.
- Lesson 2972 — Recipient Verification and Authentication
- ring buffer
- A ring buffer is a fixed-size memory area that acts like a circular recording device.
- Lesson 383 — Packet Capture Performance and Ring Buffers
- Risk acceptance
- Risk acceptance is the formal decision to acknowledge and live with these residual risks without further action.
- Lesson 2521 — Risk Acceptance and Documentation
- Risk exceeds organizational risk appetite
- The inherent risk is too high even after considering all feasible controls
- Lesson 2518 — Risk Avoidance Decisions
- risk register
- A risk register is your organization's central database of all identified security risks.
- Lesson 2506 — Risk Register Development
- Risk scoring
- Anomalies are scored based on severity and context
- Lesson 1900 — User and Entity Behavior Analytics (UEBA)
- Risks
- The key exists in plaintext during generation and wrapping in your environment—any compromise there undermines the entire model. You're also responsible for secure key transport, and if your wrapping process is flawed, keys could be exposed. Additionally, imported keys often can't be automatically rotated by the cloud provider.
- Lesson 1771 — Bring Your Own Key (BYOK) and Key Import
- Role checks on client-side only
- The UI hides admin buttons, but the API endpoint itself performs no server-side authorization validation.
- Lesson 1031 — API5:2023 - Broken Function Level Authorization
- Roleplay scenarios
- Roleplay scenarios are particularly effective.
- Lesson 2858 — Jailbreaking and Constraint Bypass
- Rollback attacks
- Preventing installation of older, vulnerable versions
- Lesson 1296 — PyPI Package Security
- Rollback Mechanisms
- Rollback Mechanisms are your safety net.
- Lesson 3045 — Remediation Workflows and Orchestration
- Rollback planning
- Rollback planning means having documented, tested procedures to quickly undo a problematic patch and restore normal operations—before you need them.
- Lesson 2458 — Patch Rollback and Recovery Planning
- root
- The root is the attacker's ultimate goal (e.g., "Exfiltrate customer PII")
- Lesson 2641 — Architecture-Level Attack Trees
- root node
- The root node represents the attacker's ultimate objective (e.g., "Steal customer database"), while child nodes represent the sub-goals or steps needed to accomplish it.
- Lesson 2515 — Attack Tree Analysis and Probability Calculation
- rootkit
- A rootkit is specialized malware designed to hide itself, other malware, or malicious activities from detection tools and system administrators.
- Lesson 1546 — Rootkit Definition and Classification
- Rotation
- Generate a new token after each sensitive request (like password changes or financial transactions) or after each page load. This per-request rotation means even if an attacker obtains a token, it's already stale by the time they try to use it.
- Lesson 871 — Token Rotation and LifecycleLesson 1499 — Audit Log Retention and Rotation
- route table
- A route table is like a GPS map for network packets—it contains rules (routes) that determine where traffic goes when it leaves a subnet.
- Lesson 1830 — Route Tables and Subnet Associations
- RP-Initiated Logout
- User clicks logout in an application → RP redirects to IdP's end_session_endpoint → IdP terminates its session and notifies all other RPs → user is logged out from all applications.
- Lesson 775 — OIDC Session Management and Single Logout
- runbook
- Think of a playbook as a strategic guide for handling an entire incident category, while a runbook is a tactical checklist for a specific action within that incident.
- Lesson 2372 — IR Playbooks and Runbooks
- Runbooks
- Runbooks are step-by-step technical instructions for executing specific actions during triage—the "how-to" manual.
- Lesson 2350 — Triage Playbooks and Runbooks
- Runtime injection
- Runtime injection means delivering secrets to your application only when it starts running or as it needs them.
- Lesson 1335 — Runtime Secret Injection Patterns
S
- Sale
- Sale means disclosing, releasing, or making personal information available to a third party for monetary or other valuable consideration.
- Lesson 2565 — Sale and Sharing of Personal Information
- salt
- A salt is a unique, random value added to each password before derivation.
- Lesson 140 — Salts in Key DerivationLesson 305 — Key Stretching and DerivationLesson 686 — Password Salting: Adding Uniqueness to Every HashLesson 2232 — Rainbow Tables and Time-Memory Tradeoffs
- SameSite
- Controls whether cookies accompany cross-origin requests. SameSite=Strict blocks cookies on all cross-site requests; SameSite=Lax allows them on top-level navigations (clicking links) but not embedded requests; SameSite=None requires Secure and permits all cross-site usage. This is your primary CSRF defense.
- Lesson 1074 — Cookie Security Attributes Deep Dive
- SameSite attribute
- The SameSite attribute is your defense against Cross-Site Request Forgery (CSRF).
- Lesson 1059 — Cookie Scoping and SameSite Attribute
- Sanitizing
- Sanitizing means attempting to transform invalid input into something acceptable.
- Lesson 1155 — Rejecting vs Sanitizing Invalid Input
- Scalability
- Most practical deployments involve 2-5 parties. Beyond that, communication explodes. Every additional party means more rounds of interaction and exponentially more complexity.
- Lesson 261 — Practical MPC Applications and Limitations
- Scan result management
- Scan result management is the process of sorting, prioritizing, and acting on these findings systematically, rather than treating every alert as equally urgent.
- Lesson 3034 — Scan Result Management and Triage
- Script Kiddies
- Script Kiddies are beginners using pre-made tools they barely understand.
- Lesson 47 — Understanding Adversary Types and Skill Levels
- scrypt
- scrypt is a password hashing algorithm designed to be memory-hard.
- Lesson 689 — scrypt: Memory-Hard Password Hashing
- Sealed sender
- Sealed sender is a mechanism that hides the sender's identity from the messaging service during transmission.
- Lesson 2954 — Sealed Sender and Sender Anonymity
- Sealed storage
- Encrypts data that can only be decrypted when specific system conditions are met
- Lesson 2771 — Hardware Root of Trust and TPM
- second-order injection
- Unlike direct SQL injection where malicious input attacks immediately, second-order injection is a delayed attack.
- Lesson 1242 — Second-Order SQL Injection in ORMs
- second-order SQL injection
- Unlike the SQL injection attacks you've learned so far where malicious input executes immediately, second-order SQL injection is a two-stage attack.
- Lesson 581 — Second-Order SQL Injection
- Secrets
- Secrets are sensitive pieces of information that grant access to systems, services, or data.
- Lesson 1310 — What Are Secrets and Why They Matter
- Secure by Default
- Secure by Default means security features are turned ON from the start, not something users must remember to enable later.
- Lesson 4 — Fail-Safe Defaults and Secure by Default
- Secure Enclave
- The Secure Enclave is a dedicated coprocessor built into Apple's System on Chip (SoC) that operates completely separately from the main processor.
- Lesson 2710 — Secure Enclave and Hardware Security
- Secure LDAP API Usage
- Secure LDAP API Usage means using library functions specifically designed to escape LDAP input rather than building queries with string concatenation.
- Lesson 615 — Preventing LDAP Injection
- Secure MLOps
- Secure MLOps means treating your ML pipeline like critical infrastructure:
- Lesson 2878 — ML Pipeline Security and Governance
- Secure Payment Flow Design
- Secure Payment Flow Design means enforcing proper state transitions.
- Lesson 927 — Preventing Payment Logic Vulnerabilities
- Secure Voting
- Estonia has explored MPC-based voting systems where votes are encrypted and tallied without any single party seeing individual ballots. Imagine counting votes by having three election officials each hold one piece of a puzzle—only together can they see the result.
- Lesson 261 — Practical MPC Applications and Limitations
- security architecture review
- A security architecture review is a formal, collaborative session where security stakeholders examine your system's design to identify vulnerabilities, gaps, and risks before implementation begins.
- Lesson 2036 — Security Architecture Review
- Security by Design
- Security by Design means integrating security considerations into every phase of the system development lifecycle—from initial requirements gathering through architecture, implementation, testing, and deployment.
- Lesson 2626 — What is Security by Design?
- security by obscurity
- This approach—called security by obscurity—is dangerously flawed.
- Lesson 1214 — Open Design and Security Through Transparency
- security choke point
- A security choke point is a mandatory passage where traffic, data, or requests must flow through, making it an ideal location to enforce multiple security controls at once.
- Lesson 29 — Security Choke Points
- security controls
- Security controls are the countermeasures you'll place at strategic points—authentication checks, input validation, encryption layers, rate limiting.
- Lesson 338 — Port Scanning FundamentalsLesson 2031 — Threat Modeling in Design Phase
- Security criterion
- In SOC 2 audits, the Security criterion is the foundation upon which other Trust Services Criteria rest.
- Lesson 2592 — Security Criterion Deep Dive
- Security foundation
- Attackers can't exploit services you haven't exposed. Unknown protocols, newly discovered ports, or misconfigured services are all blocked automatically.
- Lesson 428 — Default Deny Principle
- Security Groups
- All rules are evaluated together; if any rule allows the traffic, it passes. Rules are implicitly deny by default.
- Lesson 1819 — Security Groups vs Network ACLs: Fundamental Differences
- security incident
- A security incident is any violation of security policies or controls—these happen frequently (unauthorized access attempts, failed logins).
- Lesson 2588 — HIPAA Breach Notification Requirements
- Security labels
- Security labels are metadata tags that define:
- Lesson 1451 — Security Labels and Clearances
- Security liability
- More detailed data is more valuable to attackers
- Lesson 2898 — Granular Data Collection
- Security Metrics
- Security Metrics are any measurable data points about your security posture.
- Lesson 2525 — Understanding Security Metrics vs KPIs
- Security note
- This mechanism is deprecated and disabled in modern browsers due to abuse risks.
- Lesson 858 — SOP Exceptions and Relaxations
- security principal
- A security principal is any entity that can be authenticated: users, computers, or services.
- Lesson 1429 — Windows Access Tokens and Permissions
- Security Test Orchestration
- Security Test Orchestration is the practice of coordinating these tools into a harmonious workflow, managing their execution order, collecting results centrally, and intelligently deduplicating findings.
- Lesson 3015 — Security Test Orchestration
- Security Through Obscurity
- Security Through Obscurity is the opposite (and dangerous) approach: hoping that hiding how your system works will protect it.
- Lesson 6 — Open Design and Security Through Obscurity
- Security vulnerabilities
- A new version might contain an exploitable bug
- Lesson 1280 — Dependency Resolution and Lock Files
- seed
- Given the same starting value (called a seed), they always produce the exact same sequence of numbers.
- Lesson 284 — True vs Pseudo Random Number Generation
- Seeding
- Seeding is the process of giving your CSPRNG its initial random input.
- Lesson 298 — CSPRNG Initialization and Seeding
- Selective ingestion
- Selective ingestion is your first defense.
- Lesson 1883 — Scalability and Cost Optimization
- Selectors
- Selectors are subdomain labels that allow multiple DKIM keys for one domain.
- Lesson 2300 — DKIM Implementation and Key Management
- self-signed certificate
- A self-signed certificate is like writing "I am John Smith" on a piece of paper and signing it yourself—you're vouching for your own identity without independent verification.
- Lesson 178 — Self-Signed Certificates vs CA-Issued Certificates
- Self-synchronizing ciphers
- Self-synchronizing ciphers are more robust against transmission errors but propagate errors temporarily and are more complex to implement
- Lesson 120 — Synchronous vs Self-Synchronizing Stream Ciphers
- SELinux
- While seccomp filters syscalls, AppArmor and SELinux are mandatory access control frameworks that enforce what files, network ports, and capabilities a container process can access.
- Lesson 1654 — AppArmor and SELinux for Containers
- Separation of Concerns
- Separation of Concerns means dividing your application into distinct modules where each handles one responsibility.
- Lesson 1212 — Separation of Concerns for Security Boundaries
- Separation of Duties
- Separation of Duties means no single person or system should control an entire critical process from start to finish.
- Lesson 7 — Separation of Duties and Privilege Separation
- Separation of Privilege
- Separation of Privilege is a security design principle that requires multiple distinct conditions, credentials, or parties to be satisfied before a sensitive operation can proceed.
- Lesson 2631 — Separation of Privilege
- Serial Number
- A unique identifier assigned by the issuer—like a passport number
- Lesson 171 — X.509 Certificate Structure and Format
- Serialization
- Serialization is the process of converting complex objects (like classes, arrays, or data structures) into a simple format for storage or transmission—think JSON, XML, YAML, or binary formats.
- Lesson 1183 — Deserialization Fundamentals and Attack Surface
- Server-side
- Server-side is the security gold standard—attackers see only an opaque ID.
- Lesson 705 — Session Storage Mechanisms: Server-Side vs Client-Side
- Server-Side State Validation
- Every workflow transition must be verified server-side. Never rely on hidden form fields or client-supplied "step numbers" to determine what actions are allowed. The server must independently track where each user is in the workflow.
- Lesson 919 — Defensive Workflow State Management
- Server-Side Validation
- Server-Side Validation is your first line of defense.
- Lesson 927 — Preventing Payment Logic Vulnerabilities
- Service Accounts
- Kubernetes-native identities for pods. Each pod gets a token automatically mounted at /var/run/secrets/kubernetes.io/serviceaccount/token. The API server validates these JWT tokens using its own signing keys—pods prove who they are without manual credential management.
- Lesson 1663 — API Server Authentication MechanismsLesson 1969 — Kubernetes RBAC and Service Accounts
- Service integrations
- Grant S3 permission to invoke your function when objects are uploaded, or allow API Gateway to execute your function when endpoints are called.
- Lesson 1952 — Resource-Based Policies for Functions
- session
- A session is a server-side mechanism for maintaining state across multiple HTTP requests from the same user.
- Lesson 703 — What is a Session and Why Web Apps Need Them
- Session cookies
- Leveraging existing HTTP session authentication (ensure SameSite and Secure flags are set)
- Lesson 1069 — WebSocket Authentication and Authorization
- Session fixation
- Session fixation is an attack where the attacker sets a victim's session identifier before the victim authenticates.
- Lesson 714 — Session Fixation Attacks
- Session Handling
- Session Handling means the DAST scanner must maintain its authenticated state across hundreds or thousands of requests.
- Lesson 1373 — Authentication and Session Handling in DAST
- session key
- A unique session key is derived from this exchange
- Lesson 2979 — Implementing Forward Secrecy in TLS
- Session management
- Session management means tracking which devices are authorized.
- Lesson 2955 — Device Management and Multi-Device Security
- Session policies
- Session policies are inline policies you pass during role assumption that further restrict the permissions available in that session.
- Lesson 1732 — Role Chaining and Session Policies
- session token
- The session token is what distinguishes temporary credentials from permanent ones.
- Lesson 1730 — AWS STS and AssumeRole Mechanics
- sessionStorage
- sessionStorage is slightly better than localStorage (cleared on tab close) but still vulnerable to XSS
- Lesson 1080 — Sensitive Data Handling and Storage Alternatives
- Severity thresholds
- Block if any critical vulnerabilities are found, or if high-severity findings exceed a count (e.g., >5)
- Lesson 2052 — Security Gates and Failure Policies
- SHA-224
- Produces 224-bit hashes. Least common; used when slightly smaller outputs are acceptable.
- Lesson 209 — SHA-2 Family: SHA-224, SHA-256, SHA-384, SHA-512
- SHA-224 and SHA-384
- SHA-224 and SHA-384 are truncated versions (SHA-384 is actually SHA-512 with a different initialization and truncated output).
- Lesson 209 — SHA-2 Family: SHA-224, SHA-256, SHA-384, SHA-512
- SHA-256
- SHA-256 is the go-to choice for most applications — it balances security, performance, and widespread support.
- Lesson 202 — The Birthday Paradox and Collision ProbabilityLesson 209 — SHA-2 Family: SHA-224, SHA-256, SHA-384, SHA-512
- Shamir's Secret Sharing
- Shamir's Secret Sharing is a (t,n)-threshold scheme that splits a secret into n pieces (shares) such that:
- Lesson 322 — Shamir's Secret Sharing Scheme
- Shared Responsibility Model
- The Shared Responsibility Model is the foundational security framework that defines which security tasks belong to the cloud provider and which belong to you, the customer.
- Lesson 1684 — Shared Responsibility Model Fundamentals
- SHAttered
- Google researchers demonstrated the first practical SHA-1 collision attack, called SHAttered.
- Lesson 211 — Collision Attacks: Theory and Practice
- Shell extensions
- Shell extensions are more insidious—they're DLLs that extend Windows Explorer's functionality (context menus, property sheets, icon handlers).
- Lesson 1540 — Startup Folders and Shell Extensions
- Shift-left
- Shift-left means moving security testing earlier in the software development lifecycle:
- Lesson 3026 — Pipeline Security Scanning Overview
- Short Tokens
- A 32-bit session ID has only 4.3 billion possibilities—scannable with modern computing power, especially if many users are active simultaneously.
- Lesson 720 — Session Token Brute-Force and Enumeration
- Showback
- Showback means showing them the cost without billing.
- Lesson 2000 — Cost Allocation and Chargeback with Tags
- Signing
- The sender uses their private key to create a signature
- Lesson 147 — RSA Signature Generation and Verification
- SIM swapping
- SIM swapping is when an attacker convinces your mobile carrier (through social engineering or insider help) to transfer your phone number to a SIM card they control.
- Lesson 742 — SMS and Email-Based 2FA Weaknesses
- SIMON and SPECK
- SIMON and SPECK are NSA-designed cipher families optimized for both hardware and software implementations.
- Lesson 2793 — Lightweight Cryptographic Algorithms
- Simplicity
- Operations are mathematically elegant and efficient
- Lesson 89 — AES: Rijndael Selection and Design
- Single Logout
- Single Logout means when you log out from one place, you're logged out everywhere:
- Lesson 775 — OIDC Session Management and Single Logout
- Singles
- Singles are self-contained, complete payloads that don't need additional components.
- Lesson 2195 — Exploit Modules and Payloads
- Slack space
- Slack space is the unused portion between a file's actual end and the end of its allocated cluster.
- Lesson 2402 — File Carving and Deleted File Recovery
- SLSA 1
- Build process is documented and generates provenance metadata
- Lesson 1650 — Supply Chain Levels for Software Artifacts (SLSA)
- SLSA Level 1
- Build process is documented and provenance exists
- Lesson 1300 — Package Provenance and SLSA
- SLSA Level 2
- Builds use version control and are signed with cryptographic attestations
- Lesson 1300 — Package Provenance and SLSA
- SLSA Level 3
- Source and build platforms are hardened against tampering
- Lesson 1300 — Package Provenance and SLSA
- Smaller certificates
- ECDSA certificates are compact, reducing bandwidth
- Lesson 170 — ECC in Practice: TLS and Beyond
- Smaller keys
- 256-bit ECDSA vs 3072-bit RSA means faster transmission and less storage
- Lesson 227 — ECDSA: Elliptic Curve Digital Signature Algorithm
- Smaller packets
- CoAP headers are ~4 bytes vs. HTTP's hundreds
- Lesson 2783 — CoAP (Constrained Application Protocol)
- Sniffing IoT protocols
- Sniffing IoT protocols means capturing raw network traffic using tools like Wireshark or tcpdump, then dissecting packet structures to understand message formats, authentication tokens, and command sequences.
- Lesson 2788 — Protocol-Level Attacks and Reconnaissance
- SOC maturity model
- A SOC maturity model is a structured framework that evaluates how advanced your Security Operations Center is across key functional areas.
- Lesson 2313 — SOC Maturity Models
- Socat
- Socat is netcat's more powerful cousin, supporting encryption, multiple protocols, and advanced connection handling.
- Lesson 2236 — Netcat and Socat for Network Pivoting
- SOCKS
- SOCKS (Socket Secure) is a protocol that forwards network packets between client and server through a proxy.
- Lesson 2994 — Proxy Chains and SOCKS
- Software performance
- On devices without AES hardware acceleration (like smartphones or IoT devices), ChaCha20-Poly1305 is significantly faster than AES-GCM
- Lesson 127 — ChaCha20-Poly1305
- SPAN port
- A SPAN port is a software feature built into managed switches.
- Lesson 463 — Network TAPs vs SPAN Ports
- spear phishing
- While email-based phishing casts a wide net hoping someone will bite, spear phishing is the sniper rifle of social engineering.
- Lesson 2254 — Spear Phishing and Targeted Attacks
- Specific
- Clearly define what you're measuring. "Number of vulnerabilities" is vague; "Critical vulnerabilities in production environments" is specific.
- Lesson 761 — OAuth 2.0 Scopes and ConsentLesson 2526 — Designing Effective Security Metrics
- Specific columns
- Specific columns are encrypted before being written to storage
- Lesson 1794 — Column-Level and Field-Level Encryption
- Speed
- BLAKE2 is faster than MD5 while being cryptographically secure (remember, MD5 is broken). BLAKE3 pushes this further, often outperforming all other cryptographic hashes.
- Lesson 215 — Specialized Hash Functions: BLAKE2, BLAKE3
- Spontaneous Groups
- The signer can form a ring without asking permission from other members
- Lesson 236 — Ring Signatures and Group Anonymity
- Stage 2 audit
- The Stage 2 audit is the comprehensive assessment.
- Lesson 2609 — ISO 27001 Certification Process
- Stagers
- Stagers are small initial payloads designed to establish a connection back to your machine, then download the rest of the payload (the stage).
- Lesson 2195 — Exploit Modules and Payloads
- Stages
- Stages are the larger, feature-rich payloads delivered after the stager succeeds.
- Lesson 2195 — Exploit Modules and Payloads
- staging environment
- A staging environment is a replica of your production infrastructure where you can test patches without risk.
- Lesson 2455 — Patch Testing and Staging Environments
- Stakeholder involvement
- Stakeholder involvement is non-negotiable.
- Lesson 2494 — Policy Development and Approval Process
- Standard compliance
- frame-ancestors is part of CSP Level 2 and supported by modern browsers. When both headers are present, browsers prioritize frame-ancestors.
- Lesson 1136 — Content-Security-Policy frame-ancestors Directive
- Standard Scopes
- The openid scope triggers OIDC behavior; optional scopes like profile and email request specific claims
- Lesson 769 — OpenID Connect Overview and Relationship to OAuth 2.0
- Startup vs runtime failures
- At startup, fail fast if secrets are unavailable; during runtime, use cached values and alert
- Lesson 1334 — Secret Store Access Patterns
- State Blindness
- An API allows document editing if the user is an author, but fails to check whether the document is in "published" state where editing should be locked.
- Lesson 812 — Context-Dependent Authorization Failures
- State file comparison
- State file comparison is the foundation.
- Lesson 2024 — Drift Detection in Terraform and IaC Tools
- state-changing operations
- GET requests for state-changing operations are especially dangerous because they violate REST principles and maximize attack surface.
- Lesson 848 — GET vs POST CSRF Attacks
- Statements
- The actual authentication/authorization/attribute data
- Lesson 778 — SAML Assertions and Claims
- Static analysis
- Static analysis means reading through this code while it sits still—looking for security flaws, secrets, and dangerous patterns before the app ever executes.
- Lesson 2725 — Static Analysis of Mobile Applications
- Static MAC binding
- Manually specify which exact MAC addresses are allowed
- Lesson 414 — Port Security and MAC Filtering
- Statistical randomness
- Statistical randomness means the numbers look random when you analyze them mathematically.
- Lesson 285 — Cryptographic vs Statistical Randomness
- Stay in scope
- Testing out-of-scope systems is unauthorized access, potentially a felony
- Lesson 2084 — Legal and Ethical Considerations
- Stealth
- Victims simply browse normally; no suspicious URL is involved.
- Lesson 631 — Stored XSS: Persistent AttacksLesson 1127 — Web Cache Poisoning via Host Header
- Strategic tool placement
- Strategic tool placement means running fast checks early, expensive ones later.
- Lesson 3035 — Performance Optimization for Security Scans
- Stream Dependency Manipulation
- Attackers can create complex dependency chains where Stream B depends on Stream A, Stream C depends on B, and so on. When Stream A is delayed, all dependent streams wait, consuming server memory tracking these relationships. Imagine a pyramid scheme where each participant waits for the person above them—the server must remember everyone's position while nothing actually happens.
- Lesson 1098 — HTTP/2 Stream Vulnerabilities and Attacks
- Strict schemas
- You define exactly which fields and types are allowed before deserialization happens
- Lesson 1191 — Alternative Serialization Formats
- Strong authentication
- Built-in identity verification ensures members are who they claim to be
- Lesson 2950 — Message Layer Security (MLS) for Group Messaging
- Strong integrity
- Any bit-level modification is detectable
- Lesson 477 — Authentication Header (AH) Protocol
- Subject
- The subject is who (or what) is trying to perform an action.
- Lesson 171 — X.509 Certificate Structure and FormatLesson 795 — Access Control Fundamentals
- Subject Public Key Info
- The actual public key and its algorithm (RSA, ECC, etc.)
- Lesson 171 — X.509 Certificate Structure and Format
- subnets
- Subnetting divides your VPC's overall IP address space into smaller, isolated networks called subnets.
- Lesson 1828 — Subnetting in Cloud VPCs
- Supply chain attacks
- An attacker who compromises a dependency can inject malicious code into "updates"
- Lesson 1280 — Dependency Resolution and Lock Files
- Supply chain risk
- Supply chain risk refers to threats introduced through these external relationships.
- Lesson 2534 — Third-Party Risk Fundamentals
- suppression
- Suppression means completely removing or masking certain values—typically outliers or combinations that would otherwise require excessive generalization.
- Lesson 2906 — Generalization and Suppression
- SVG Files
- Scalable Vector Graphics files are XML-based. An attacker can upload a malicious SVG containing:
- Lesson 623 — XXE via File Upload and Content Types
- SVG images
- SVG images are pure XML that browsers and image libraries parse
- Lesson 973 — XXE in Document Processing
- Syft
- Syft is a popular multi-language tool from Anchore that scans container images, filesystems, and archives.
- Lesson 1278 — Generating SBOMs for Applications
- symbolic link
- A symbolic link is a special file that acts as a pointer or shortcut to another file or directory.
- Lesson 969 — Symbolic Link Attacks
- SYN scan
- A SYN scan (half-open) is stealthier than a TCP connect scan because it doesn't complete the handshake
- Lesson 366 — Stealth Scanning Fundamentals
- Synchronizer Token Pattern
- The Synchronizer Token Pattern is the most common defense against CSRF attacks.
- Lesson 865 — Synchronizer Token Pattern
- System architecture
- A web server runs with limited privileges and can't directly access the database—requests go through a separate, minimal-privilege API layer
- Lesson 7 — Separation of Duties and Privilege Separation
- System restore points
- System restore points are snapshots of system configuration taken before patching.
- Lesson 1605 — Patch Rollback and Emergency Procedures
- System-Assigned Managed Identities
- System-Assigned Managed Identities are tied 1:1 to a specific Azure resource.
- Lesson 1724 — Azure Managed Identities Deep Dive
T
- t-of-n threshold scheme
- A t-of-n threshold scheme means t out of n parties must cooperate.
- Lesson 262 — Threshold Cryptography Fundamentals
- Tags
- Tags are metadata key-value pairs (like Environment=Production, Owner=SecurityTeam, CostCenter=CC-1234) attached to cloud resources.
- Lesson 2019 — Resource Tagging, Naming, and Organizational Controls in IaC
- Taint analysis
- Taint analysis is the security-focused version of this: the tool marks untrusted input (like user data) as "tainted" and follows it through the AST.
- Lesson 1360 — Abstract Syntax Trees and Data Flow Analysis
- TAP
- A TAP is a dedicated hardware device physically inserted into a network cable.
- Lesson 463 — Network TAPs vs SPAN Ports
- Targeted policy
- Targeted policy is the most common default.
- Lesson 1454 — SELinux Modes and Policy Types
- TCP options ordering
- The sequence and combination of options varies by OS
- Lesson 363 — Passive OS Fingerprinting
- Temporal data minimization
- Temporal data minimization means retaining personal data only as long as necessary to fulfill its specified purpose, then securely deleting it.
- Lesson 2897 — Temporal Data Minimization
- Temporary badges
- Temporary badges are issued to visually identify non-employees.
- Lesson 2285 — Visitor Management and Temporary Access
- Temporary credentials
- Temporary credentials are like hotel key cards with an expiration time—they automatically become invalid after a set period (minutes to hours).
- Lesson 1729 — Temporary Credentials vs Long-Term Credentials
- Tenant Confusion
- A SaaS platform checks if a user has "admin" role but doesn't verify they're admin for the current tenant, allowing cross-tenant privilege escalation.
- Lesson 812 — Context-Dependent Authorization Failures
- Termination protection
- Termination protection is a flag you enable on critical instances that prevents accidental deletion.
- Lesson 1931 — Instance Termination Protection and Data Persistence
- terraform plan
- terraform plan is your first line of defense.
- Lesson 2024 — Drift Detection in Terraform and IaC Tools
- Terratest
- Terratest is a Go-based framework that deploys your Terraform code to a real (but isolated) environment, runs validation tests, then tears everything down.
- Lesson 2020 — Testing and Validation of IaC Security Controls
- Testing Before Deployment
- Testing Before Deployment is non-negotiable.
- Lesson 3047 — Automated Vulnerability Patching
- Think hybrid
- If you're connecting to on-premises networks via VPN or Direct Connect, ensure your VPC ranges don't collide with your data center's IP schemes. Coordination with network teams is critical.
- Lesson 1810 — VPC IP Addressing and CIDR Planning
- Thread State Analysis
- Examine what each thread is doing—running, waiting, suspended. Threads with unusual start addresses (not pointing to legitimate module code) or orphaned threads without parent processes signal injection. Check thread stacks to trace execution paths back to their origin.
- Lesson 2392 — Process and Thread Analysis
- threat event
- A threat event is the specific action that threat source takes—like phishing your employees, exploiting a software vulnerability, or physically stealing equipment.
- Lesson 2502 — Threat Identification and Modeling
- Threat intelligence integration
- Threat intelligence integration means enriching your security alerts with external data: known bad IPs, malicious domains, file hashes of malware, command-and-control server addresses, and tactics used by specific threat actor groups.
- Lesson 1894 — Threat Intelligence Integration
- threat landscape
- The threat landscape is the entire collection of potential attacks, vulnerabilities, and hostile actors targeting systems at any given time.
- Lesson 33 — Threat Landscape Evolution and Adaptive Security
- Threat Prevention
- Event Threat Detection analyzes Cloud Logging data to identify threats like cryptocurrency mining, brute-force attacks, IAM privilege escalation attempts, and data exfiltration patterns. Findings are prioritized by severity (Critical, High, Medium, Low).
- Lesson 1889 — GCP Security Command Center
- threat source
- A threat source is the origin of potential harm—it could be a cybercriminal group, malicious insider, nation-state actor, or even accidental human error.
- Lesson 2502 — Threat Identification and Modeling
- Threats
- Threats are the potential sources of harm that could damage or compromise your assets.
- Lesson 2498 — Risk Components: Assets, Threats, and Vulnerabilities
- Ticketing Systems
- Integration with ServiceNow or Jira means every security alert can automatically create a ticket, update status as the investigation progresses, and close when resolved.
- Lesson 2329 — Integration and Orchestration
- Timestamp authority signatures
- A trusted third party cryptographically proves when you signed (like a notary's date stamp)
- Lesson 231 — Document Signing and PDF Signatures
- timestamp synchronization
- In distributed environments, timestamp synchronization is critical.
- Lesson 1473 — Log Timestamp Synchronization
- Timing and rate limiting
- Timing and rate limiting means deliberately slowing down your scans by:
- Lesson 368 — Timing and Rate Limiting for Evasion
- Timing attacks
- The rhythm of communications is revealing. Encrypted messages sent every morning at 9 AM to the same recipient establish routine patterns. Deviations signal events worth investigating.
- Lesson 2755 — Physical Security Threats to IoT DevicesLesson 2976 — Traffic Analysis and Correlation Attacks
- Timing-based detection
- Timing-based detection is your first line of defense.
- Lesson 1114 — Testing and Tools for Request Smuggling
- TLS Termination at the Gateway
- TLS Termination at the Gateway means your API gateway handles the HTTPS handshake and decrypts incoming traffic.
- Lesson 1777 — API Gateway and Application-Level Encryption
- Traceroute
- Traceroute is a reconnaissance tool that reveals each of these intermediate stops, helping security professionals and attackers alike understand network structure.
- Lesson 350 — Traceroute and Path Discovery
- Tracking
- Every campaign action is logged: email opened, link clicked, data submitted, reported by user. This granular tracking reveals which users need additional training and which tactics are most effective.
- Lesson 2248 — GoPhish Phishing Framework
- Traffic Management
- The gateway can route requests based on version, filter malicious patterns, transform requests, and apply load balancing—all while enforcing security headers and CORS policies.
- Lesson 1043 — API Gateway and Defense Patterns
- transferability
- This property is called transferability, and it's one of the most concerning aspects of adversarial machine learning.
- Lesson 2817 — Transferability of Adversarial Examples
- transitive dependencies
- These are called transitive dependencies (or indirect dependencies), and you probably never reviewed their code or even knew they existed.
- Lesson 1259 — Understanding Software Dependencies and Transitive Risk
- Transparency
- Be honest about your assessment and remediation process. If you disagree that something is a vulnerability, explain why with technical reasoning. If fixes will take time, explain the complexity involved. Researchers appreciate honesty over radio silence.
- Lesson 89 — AES: Rijndael Selection and DesignLesson 2474 — Communicating with Security Researchers
- Transport protocols
- rsyslog supports both UDP (fast, connectionless) and TCP (reliable, connection-oriented). For security logs, TCP is preferred—you don't want to lose evidence of an attack.
- Lesson 1480 — Remote Logging with rsyslog
- Trend-based
- Fail if new vulnerabilities are introduced compared to the previous build
- Lesson 2052 — Security Gates and Failure Policies
- Triaging
- Triaging means categorizing findings by severity, exploitability, and business impact.
- Lesson 2053 — Test Result Management and Remediation Workflows
- Triggers
- Triggers are the events or circumstances that mandate conducting a PIA.
- Lesson 2888 — PIA Triggers and Scoping
- Trojan
- A Trojan (or Trojan horse) is malware that disguises itself as useful, legitimate software to deceive users into executing it.
- Lesson 1521 — Trojans: Deceptive Functionality
- trust anchor
- A trust anchor is a certificate (typically a root CA certificate) that your system has been configured to trust inherently, without needing validation from another authority.
- Lesson 182 — Trust Anchors and Root Certificate Stores
- Trust boundaries
- Trust Boundaries are invisible lines where data moves from one security context to another—like when a user request crosses from the internet into your internal network, or when your application queries a database.
- Lesson 41 — Assets, Entry Points, and Trust BoundariesLesson 2636 — Architectural Threat Modeling Fundamentals
- trust boundary
- A trust boundary is an invisible line in your application where data moves from an untrusted source (user input, external APIs, URL parameters) into a trusted context (your database, server logic, internal systems).
- Lesson 11 — Trust Boundaries and Implicit TrustLesson 1149 — Trust Boundaries and Data FlowLesson 2639 — Trust Boundary AnalysisLesson 2645 — Understanding Trust Boundaries
- Trusted Execution Environment
- A Trusted Execution Environment is a hardware-enforced secure enclave within a processor that isolates code and data from the rest of the system.
- Lesson 2927 — Trusted Execution Environments
- Trusted intermediary
- A mutual friend confirms both parties' fingerprints
- Lesson 2945 — Identity Verification in E2EE
- Trusted Platform Module
- A Trusted Platform Module is a specialized microchip (or firmware implementation) physically integrated into your computer's motherboard.
- Lesson 307 — Trusted Platform Modules (TPMs)Lesson 2771 — Hardware Root of Trust and TPM
- Turnstiles
- Turnstiles are rotating barriers (waist-high or full-height) that allow only one person per authentication event.
- Lesson 2282 — Mantrap and Turnstile Controls
- Type confusion
- Submit arrays ["value"] or objects {"key":"value"} where strings are expected
- Lesson 601 — Detecting and Testing for NoSQL Injection
- TypeScript
- TypeScript is significantly easier to analyze than JavaScript due to explicit type annotations—a reminder that language choice impacts security tooling effectiveness.
- Lesson 1364 — Language-Specific SAST Considerations
U
- Unauthorized Access
- Unauthorized Access is the foundation of most physical attacks.
- Lesson 2271 — Physical Security Threat Landscape
- Uniformly distributed
- All possible values are equally likely
- Lesson 134 — Generating Secure Random IVs and Nonces
- Unknown or missing licenses
- Dependencies without clear licenses pose legal risk. SCA identifies components where license information is absent or ambiguous.
- Lesson 1272 — License Compliance Scanning
- Unpatched Vulnerabilities
- Unpatched Vulnerabilities are known security flaws that haven't been fixed on a particular system.
- Lesson 1534 — Exploitation of Software Vulnerabilities
- Unpredictable
- An attacker can't guess the next value even knowing previous ones
- Lesson 134 — Generating Secure Random IVs and Nonces
- Unseen data
- Predictions are generally less confident, with higher uncertainty
- Lesson 2831 — Membership Inference Attacks
- Usage policies and compliance
- You must ensure the SaaS application is used according to your organization's policies and regulatory requirements.
- Lesson 1688 — Shared Responsibility in SaaS
- User-Assigned Managed Identities
- User-Assigned Managed Identities are standalone resources you create independently.
- Lesson 1724 — Azure Managed Identities Deep Dive
- UserInfo Endpoint
- A standardized API to retrieve additional user profile information
- Lesson 769 — OpenID Connect Overview and Relationship to OAuth 2.0
- Utility
- Utility means data is in a usable format.
- Lesson 14 — The Parkerian Hexad: Extending the CIA Triad
- UUIDs without authorization
- Even "random" IDs are vulnerable if not checked
- Lesson 813 — IDOR Fundamentals and Common Patterns
V
- Validate push authority
- Only accept pushed resources from origins that are authoritative for them
- Lesson 1100 — HTTP/2 Server Push Security Risks
- Validating Webhooks
- Validating Webhooks are HTTP callbacks that examine incoming requests and say "yes" or "no." They can reject a deployment if it requests privileged containers or lacks resource limits—essentially custom security gates.
- Lesson 1670 — Admission Controllers and Webhooks
- Validity period
- Validity period is proactive: "This certificate stops working on this date."
- Lesson 190 — Certificate Revocation Fundamentals
- Verification difficulty
- Complicated logic is harder to audit and test thoroughly
- Lesson 2667 — Economy of Mechanism
- Verifying
- Anyone with the sender's public key can verify the signature is authentic
- Lesson 147 — RSA Signature Generation and Verification
- Version string matching
- A system may report Apache 2.4.10 (which has known CVEs), but patches were backported without changing the version number
- Lesson 2441 — False Positives and Validation
- Version tracking
- Label secrets (v1, v2) so systems know which is current
- Lesson 1346 — Zero-Downtime Rotation Patterns
- Versions
- Exact version numbers are critical. Vague version info like "1.x" or "latest" makes vulnerability tracking impossible. You need pinpoint accuracy: "1.2.3" not "~1.2".
- Lesson 1279 — SBOM Contents and Metadata Quality
- Vertical privilege escalation
- A regular user performs admin functions (like deleting any account).
- Lesson 803 — Broken Access Control Overview
- Viewing angles
- The perturbation must work from multiple perspectives
- Lesson 2814 — Physical World Adversarial Examples
- virtual hosting
- Modern web servers often host multiple websites on a single IP address—a setup called virtual hosting.
- Lesson 1124 — Host Header Fundamentals and Purpose
- Virtual patching
- Virtual patching means placing security controls in front of vulnerable systems to block exploitation attempts without modifying the vulnerable application itself.
- Lesson 2462 — Virtual Patching and Temporary Mitigations
- VLAN fingerprinting
- VLAN fingerprinting is trickier since VLANs operate at Layer 2.
- Lesson 352 — Subnet and VLAN Discovery
- Volatility
- Volatility is the gold standard for memory forensics.
- Lesson 1564 — Rootkit Detection Tools and Frameworks
- Vulnerabilities
- Vulnerabilities are the weaknesses or gaps that make your assets susceptible to threats.
- Lesson 2498 — Risk Components: Assets, Threats, and Vulnerabilities
- Vulnerabilities found pre-production vs post-production
- Catching threats early is the goal.
- Lesson 84 — Measuring Threat Modeling Effectiveness
- vulnerability
- A vulnerability is a weakness; an exploit is the proof that the weakness can be abused.
- Lesson 2107 — Exploitation Fundamentals and Anatomy of an Exploit
- Vulnerability assessment and prioritization
- Vulnerability assessment and prioritization is the systematic process of identifying, evaluating, and ranking security weaknesses to determine remediation order.
- Lesson 1602 — Vulnerability Assessment and Prioritization
- Vulnerability Disclosure Policy
- A Vulnerability Disclosure Policy (VDP) is an organization's public document that explains how security researchers should report vulnerabilities, what systems are in scope, and what protections researchers receive.
- Lesson 2073 — Vulnerability Disclosure Policies
- Vulnerability scanning
- Vulnerability scanning is automated, broad, and reports potential issues:
- Lesson 2080 — What is Penetration Testing?
W
- WAF or security controls blocking attacks
- The scanner sees the block page and flags it as a vulnerability
- Lesson 1375 — False Positive Management in DAST
- Warm start
- The platform reuses an existing execution context. Faster, but any in-memory data, open connections, or /tmp files from the previous invocation may still exist.
- Lesson 1942 — Function Execution Context and Isolation
- Watermarking and fingerprinting
- Watermarking and fingerprinting are ownership-proving techniques that survive extraction and copying.
- Lesson 2835 — Watermarking and Model Fingerprinting
- web application vulnerability scanners
- While network vulnerability scanners (like those you've learned) probe hosts and services for OS-level flaws, web application vulnerability scanners are purpose-built for the dynamic, interactive world of web applications.
- Lesson 2438 — Web Application Vulnerability Scanners
- web cache
- A web cache is a temporary storage layer that sits between clients and origin servers, saving copies of responses to speed up future requests.
- Lesson 1115 — Web Cache Fundamentals and Architecture
- Web Workers
- Web Workers are dedicated to a single page, while Shared Workers can be accessed by multiple pages from the same origin.
- Lesson 1085 — Web Workers and Shared Workers Security
- White-box access
- White-box access means the attacker has complete knowledge: the model architecture, all trained weights, training data, and internal operations.
- Lesson 2809 — Threat Model for Adversarial Attacks
- who
- Even with end-to-end encryption, messaging services typically know who is talking to whom and when—this is metadata.
- Lesson 2954 — Sealed Sender and Sender Anonymity
- WHOIS
- WHOIS is a protocol and database system that lets you query who registered a domain, when, through which registrar, and what nameservers handle its DNS.
- Lesson 329 — WHOIS and Domain Registration Intelligence
- Why it matters
- Short expiration times (minutes to hours) limit damage if a token is stolen. The attacker's window shrinks dramatically.
- Lesson 791 — JWT Expiration and Revocation
- Wider blast radius
- The longer a secret lives, the more systems, logs, and people it touches, increasing exposure points
- Lesson 1343 — Secret Rotation Fundamentals
- Wildcard Vulnerabilities
- Rules like user ALL=(ALL) NOPASSWD: /bin/tar * seem safe but are dangerous. An attacker can abuse tar's checkpoint feature:
- Lesson 2142 — Sudo Misconfigurations and Exploits
- Window Size
- The initial TCP window size varies by OS and version
- Lesson 359 — TCP/IP Stack Fingerprinting
- Windows
- Trailing spaces and dots are ignored (shell.php. becomes shell.php)
- Lesson 950 — Bypassing Extension Blacklists
- Within the same account
- Either an identity-based policy or a resource-based policy granting access is sufficient (if no explicit deny exists).
- Lesson 1716 — Resource-Based vs Identity-Based Policies
- Work factor
- Work factor is the total cost to an attacker: time, specialized skills, tools, and risk of detection.
- Lesson 2672 — Work Factor and Economic Balance
- work factor and economic balance
- The principle of work factor and economic balance means calibrating your security investment so that the effort, time, and money an attacker must spend to breach your defenses exceeds the value of what they'd gain.
- Lesson 2672 — Work Factor and Economic Balance
- Works anywhere
- Agents function even when devices are off-network (remote workers, laptops), unlike network scanners that require connectivity to your scanning infrastructure.
- Lesson 2437 — Agent-Based Scanning
- Workspaces
- Workspaces are isolated containers within the database.
- Lesson 2200 — Database Integration and Workspaces
X
- XSS
- XSS is prevented by output encoding, Content Security Policy, input validation, and avoiding innerHTML with untrusted data
- Lesson 852 — CSRF vs XSS: Key Differences
- XSS Cookie Theft
- Reduced—even if XSS injects code, cross-origin exfiltration is harder
- Lesson 674 — SameSite Cookie Attribute
Z
- Zero-Day Exploits
- Zero-Day Exploits are attacks against vulnerabilities unknown to the software vendor.
- Lesson 1534 — Exploitation of Software Vulnerabilities