Study guide
3.1 Adversarial Evasion Attacks and Perturbations
CompTIA SecAI+ CY0-001
Track your progress as you read
Finished sections get a check mark.
1 Chapter 1: AI and Machine Learning Foundations
1.1 Core AI/ML Paradigms: Supervised, Unsupervised, and Reinforcement Learning 1.2 Deep Learning Architectures and Neural Network Fundamentals 1.3 Foundation Models, Large Language Models (LLMs), and Tokenization 1.4 Prompting, Data Security, and the AI Lifecycle
2 Chapter 2: Modern AI System Architectures in Security
2.1 Embeddings, Vector Spaces, and Vector Databases 2.2 Retrieval-Augmented Generation (RAG) Architectures and Data Flow 2.3 Autonomous AI Agents, Tool Execution, and Orchestration
3 Chapter 3: Adversarial Machine Learning & Evasion Attacks
3.1 Adversarial Evasion Attacks and Perturbations 3.2 Defenses Against Evasion and Adversarial Robustness 3.3 Data Poisoning and Backdoor Attacks
4 Chapter 4: Model Privacy, Confidentiality & Inversion Attacks
4.1 Model Inversion and Training Data Extraction 4.2 Membership Inference Attacks and Differential Privacy 4.3 Model Theft, Extraction, and IP Protection
5 Chapter 5: LLM Vulnerabilities & CY0-001 OWASP 2023-24 Taxonomy (Part 1)
5.1 CY0-001 / OWASP 2023-24 LLM01: Prompt Injection 5.2 CY0-001 / OWASP 2023-24 LLM02 & LLM07: Output and Plug-ins 5.3 CY0-001 / OWASP 2023-24 LLM03 & LLM05: Poisoning and Supply Chain 5.4 CY0-001 / OWASP 2023-24 LLM04 & LLM06: DoS and Disclosure
6 Chapter 6: CY0-001 OWASP 2023-24 Taxonomy (Part 2) & Secure MLOps
6.1 CY0-001 / OWASP 2023-24 LLM08-LLM10: Agency, Overreliance, and Theft 6.2 Secure MLOps Pipeline Architecture and Hardening 6.3 Runtime AI Monitoring, Guardrails, and Drift Detection 6.4 AI Access, Data, Input, Output, and Audit Controls 6.5 AI Attack Types, Evidence, and Compensating Controls
7 Chapter 7: AI in Threat Detection and SOC Automation
7.1 AI for SOC Alert Triage and Incident Prioritization 7.2 Anomaly Detection and Behavioral Analytics (UEBA) 7.3 AI-Driven Phishing Detection and Email Security
8 Chapter 8: AI in Threat Intelligence, Hunting & Vulnerability Management
8.1 Cyber Threat Intelligence (CTI) Enrichment and Summarization 8.2 AI-Assisted Threat Hunting and Query Generation 8.3 AI in Secure Code Review and Vulnerability Detection 8.4 AI Security Tools, Attack Discovery, and Workflow Automation
9 Chapter 9: Operational Risks and Limitations of AI-Assisted Security
9.1 Hallucinations, Confabulation, and False Positives in SOC AI 9.2 Model Degradation: Data Drift, Concept Drift, and Monitoring Metrics 9.3 Dual-Use Risks: Adversary Exploitation of AI
10 Chapter 10: AI Risk Frameworks, Regulations & Standards
10.1 NIST AI Risk Management Framework (AI RMF 1.0) 10.2 ISO/IEC 42001 and International AI Standards 10.3 The EU AI Act and Global Legal Requirements 10.4 MITRE ATLAS: Adversarial Threat Landscape for AI Systems
11 Chapter 11: AI Red Teaming, Ethics & Enterprise Governance
11.1 AI Red Teaming and Adversarial Probing Methodologies 11.2 Transparency, Model Documentation, and Explainability 11.3 Enterprise AI Governance, Acceptable Use Policies & Data Privacy 11.4 Governance Roles, Risk Taxonomies, and Compliance Operations
3.1 Adversarial Evasion Attacks and Perturbations
Key Takeaways Explain This Topic AI
Adversarial evasion attacks occur strictly at test or inference time, crafting an input perturbation delta to cause misclassification without altering the underlying model weights.
Threat models dictate attacker capabilities: white-box adversaries possess full access to weights and gradients, gray-box adversaries hold partial architecture or pipeline knowledge, and black-box adversaries rely on queries and transferability.
Perturbations are mathematically constrained using Lp norms: L0 bounds the count of altered features (sparsity), L2 bounds Euclidean distance (energy), and L-infinity bounds the maximum single-coordinate change (imperceptibility).
The Fast Gradient Sign Method (FGSM) calculates a one-step perturbation via the sign of the loss gradient, whereas Projected Gradient Descent (PGD) applies iterative multi-step gradient ascent with projection into an epsilon-ball.
Adversarial transferability allows perturbations crafted on surrogate white-box models to deceive black-box models, enabling real-world physical attacks such as adversarial patches and malware binary padding.
Last updated: September 2026
3.1 Adversarial Evasion Attacks and Perturbations
Adversarial machine learning represents a fundamental shift in how security professionals analyze software vulnerabilities. While traditional software security identifies flaws in control flow, memory safety, or input validation logic, machine learning security addresses vulnerabilities inherent in high-dimensional statistical optimization. Adversarial evasion attacks (often called exploratory attacks) occur exclusively at inference time (test time). In an evasion attack, the target model's training process has completed, its parameters θ \theta θ are frozen, and the attacker crafts a maliciously modified input x a d v = x + δ x_{adv} = x + \delta x a d v = x + δ designed to force an erroneous prediction while keeping the perturbation δ \delta δ imperceptible or semantically inconsequential.
Evasion attacks fall into two operational categories:
Untargeted Evasion : The attacker seeks any incorrect classification: f ( x a d v ) ≠ y t r u e f(x_{adv}) \neq y_{true} f ( x a d v ) = y t r u e . For example, forcing an intrusion detection system (IDS) to classify a malicious command-and-control beacon as any benign protocol.
Targeted Evasion : The attacker forces the model to output a specific malicious label selected in advance: f ( x a d v ) = y t a r g e t f(x_{adv}) = y_{target} f ( x a d v ) = y t a r g e t where y t a r g e t ≠ y t r u e y_{target} \neq y_{true} y t a r g e t = y t r u e . For example, inducing an autonomous vehicle's vision model to classify a Stop Sign specifically as a Speed Limit 45 sign.
Adversarial Threat Models: Access and Knowledge
Security engineers evaluate adversarial robustness against formalized threat models that define what an attacker knows and what interfaces they can access:
Threat Model Knowledge of Model Internals Attacker Access & Capabilities Typical Attack Methodology
White-Box Complete : Architecture, weights θ \theta θ , loss function L \mathcal{L} L , hyperparameters, training distribution, and defense mechanisms. Direct computation of analytical loss gradients with respect to input: ∇ x L ( θ , x , y ) \nabla_x \mathcal{L}(\theta, x, y) ∇ x L ( θ , x , y ) . Fast Gradient Sign Method (FGSM), Projected Gradient Descent (PGD), Carlini-Wagner (C&W).
Gray-Box Partial : May know model family (e.g., ResNet-50, XGBoost), feature extraction logic, or dataset distribution, but lacks exact trained weights or random seeds. Query access; ability to train identical architectures on surrogate data matching the target distribution. Surrogate model gradient calculation, boundary estimation, feature-space matching.
Black-Box Zero : No knowledge of architecture, weights, or pipeline internals. Model treated as an opaque oracle y = f ( x ) y = f(x) y = f ( x ) . Restricted to querying inputs and observing outputs. Subtypes: score-based (continuous probabilities/logits returned) or decision-based (hard top-1 label only). Transferability attacks via surrogate models, Zeroth-Order Optimization (ZOO), Natural Evolution Strategies (NES), HopSkipJump boundary attacks.
In score-based black-box attacks , adversaries exploit output confidence scores to approximate gradients numerically using finite differences ( [ f ( x + h ⋅ u ) − f ( x ) ] / h [f(x + h \cdot u) - f(x)] / h [ f ( x + h ⋅ u ) − f ( x )] / h ). In decision-based (label-only) attacks , adversaries observe only discrete class labels, walking along the classification boundary (e.g., using HopSkipJump) to find the minimal perturbation crossing the decision threshold.
Mathematical Bounding: L p L_p L p Norms in Adversarial ML
To ensure an adversarial input remains valid, functional, or stealthy, perturbations are constrained within an allowable perturbation set Δ \Delta Δ defined by an L p L_p L p norm . Given a perturbation vector δ = x a d v − x ∈ R d \delta = x_{adv} - x \in \mathbb{R}^d δ = x a d v − x ∈ R d , the L p L_p L p norm measures its magnitude: ∥ δ ∥ p = ( ∑ i = 1 d ∣ δ i ∣ p ) 1 / p \|\delta\|_p = \left( \sum_{i=1}^d |\delta_i|^p \right)^{1/p} ∥ δ ∥ p = ( i = 1 ∑ d ∣ δ i ∣ p ) 1/ p
CompTIA SecAI+ emphasizes three primary L p L_p L p norms used in security evaluations:
1. L 0 L_0 L 0 Norm (Sparsity Metric) ∥ δ ∥ 0 = ∑ i = 1 d I ( δ i ≠ 0 ) \|\delta\|_0 = \sum_{i=1}^d \mathbb{I}(\delta_i \neq 0) ∥ δ ∥ 0 = i = 1 ∑ d I ( δ i = 0 )
Mechanism : The L 0 L_0 L 0 pseudo-norm counts the number of altered features or dimensions , regardless of how large each individual alteration is. Here, I \mathbb{I} I is the indicator function.
Security Application : Ideal for attacks where an adversary can only manipulate a few specific inputs. Examples include modifying only 5 pixels in a high-resolution biometric image, changing 3 specific words in a phishing email to evade an NLP spam filter, or altering 4 specific registry key calls in an endpoint detection and response (EDR) behavioral vector.
2. L 2 L_2 L 2 Norm (Euclidean Distance / Energy Metric) ∥ δ ∥ 2 = ∑ i = 1 d δ i 2 \|\delta\|_2 = \sqrt{\sum_{i=1}^d \delta_i^2} ∥ δ ∥ 2 = i = 1 ∑ d δ i 2
Mechanism : Computes standard geometric distance, measuring the total accumulated energy of the perturbation across all dimensions.
Security Application : Common in physical signal processing, audio speech-to-text evasion (e.g., adding low-amplitude white noise across acoustic frequencies to trick voice assistants), and biometric facial verification where total structural distortion must remain small.
3. L ∞ L_\infty L ∞ Norm (Chebyshev Distance / Worst-Case Peak Metric) ∥ δ ∥ ∞ = max 1 ≤ i ≤ d ∣ δ i ∣ \|\delta\|_\infty = \max_{1 \le i \le d} |\delta_i| ∥ δ ∥ ∞ = 1 ≤ i ≤ d max ∣ δ i ∣
Mechanism : Measures the maximum absolute change in any single feature dimension . If ∥ δ ∥ ∞ ≤ ϵ \|\delta\|_\infty \le \epsilon ∥ δ ∥ ∞ ≤ ϵ , every single feature i i i satisfies ∣ x a d v , i − x i ∣ ≤ ϵ |x_{adv, i} - x_i| \le \epsilon ∣ x a d v , i − x i ∣ ≤ ϵ .
Security Application : The most widespread benchmark in computer vision and sensory machine learning. When images are normalized to pixel values between 0.0 0.0 0.0 and 1.0 1.0 1.0 (or 0 0 0 to 255 255 255 ), choosing ϵ = 8 / 255 ≈ 0.031 \epsilon = 8/255 \approx 0.031 ϵ = 8/255 ≈ 0.031 ensures that no color channel of any pixel changes by more than 8 intensity levels out of 255—rendering the perturbation completely imperceptible to human visual inspection.
Norm Formal Definition Perturbation Shape in 2D Primary Cybersecurity Use Case
L 0 L_0 L 0 Count of non-zero entries Cross / Axis-aligned star Sparse manipulation: word substitutions, specific packet fields, malware opcodes.
L 2 L_2 L 2 ∑ δ i 2 \sqrt{\sum \delta_i^2} ∑ δ i 2 Circle / Hypersphere Acoustic perturbation, physical sensor noise, biometric face template evasion.
L ∞ L_\infty L ∞ max i ∣ δ i ∣ \max_i \vert\delta_i\vert max i ∣ δ i ∣ Square / Hypercube Vision-based autonomous systems, pixel-wide imperceptible noise, sensor grid spoofing.
Canonical Evasion Attack Algorithms
Adversarial perturbations are computed by optimizing the model's loss function L ( θ , x , y ) \mathcal{L}(\theta, x, y) L ( θ , x , y ) with respect to the input x x x . Rather than adjusting weights θ \theta θ to minimize loss (standard training), the adversary freezes θ \theta θ and adjusts input x x x to maximize loss . Standard ML Training: min_θ L(θ, x, y) [Updates weights θ]
- Adversarial Evasion: max_δ L(θ, x + δ, y) [Updates input x, subject to ||δ||_p ≤ ε]
- Fast Gradient Sign Method (FGSM)
Introduced by Goodfellow et al. (2014), FGSM is a fast, one-step white-box attack designed for L ∞ L_\infty L ∞ bounded perturbations: x a d v = x + ϵ ⋅ sign ( ∇ x L ( θ , x , y ) ) x_{adv} = x + \epsilon \cdot \text{sign}\left( \nabla_x \mathcal{L}(\theta, x, y) \right) x a d v = x + ϵ ⋅ sign ( ∇ x L ( θ , x , y ) )
Mechanism : The attacker calculates the analytical gradient of the classification loss with respect to the input vector x x x . The sign() function extracts the polarity ( + 1 +1 + 1 or − 1 -1 − 1 ) of each dimension's gradient. Multiplying by ϵ \epsilon ϵ takes a single uniform step of magnitude ϵ \epsilon ϵ in the direction that most rapidly increases the model's loss.
Computational Complexity : O ( 1 ) \mathcal{O}(1) O ( 1 ) backward passes (extremely fast, requires only a single backpropagation).
Limitations : Because it relies on a first-order linear approximation of the loss surface around x x x , FGSM frequently under-optimizes on complex, highly curved loss surfaces. It represents a coarse attack and is easily defended by adversarial training.
Projected Gradient Descent (PGD)
Introduced by Madry et al. (2017), PGD is an iterative multi-step attack that represents the standard empirical benchmark for worst-case first-order adversaries under L ∞ L_\infty L ∞ or L 2 L_2 L 2 bounds: x ( t + 1 ) = Π x + S ( x ( t ) + α ⋅ sign ( ∇ x L ( θ , x ( t ) , y ) ) ) x^{(t+1)} = \Pi_{x + \mathcal{S}}\left( x^{(t)} + \alpha \cdot \text{sign}\left( \nabla_x \mathcal{L}(\theta, x^{(t)}, y) \right) \right) x ( t + 1 ) = Π x + S ( x ( t ) + α ⋅ sign ( ∇ x L ( θ , x ( t ) , y ) ) )
Mechanism :
Random Initialization : Rather than starting at x x x , PGD initializes x ( 0 ) x^{(0)} x ( 0 ) with a uniform random perturbation within the ϵ \epsilon ϵ -ball S = { δ : ∥ δ ∥ ∞ ≤ ϵ } \mathcal{S} = \{ \delta : \|\delta\|_\infty \le \epsilon \} S = { δ : ∥ δ ∥ ∞ ≤ ϵ } . This random restart prevents the attack from becoming trapped in flat local loss plateaus.
Iterative Steps : At each step t t t , the attack computes the loss gradient and advances by a small step size α \alpha α (typically α = ϵ / 4 \alpha = \epsilon / 4 α = ϵ /4 or ϵ / 10 \epsilon / 10 ϵ /10 ).
Projection Operator ( Π \Pi Π ) : After each step, the projection operator clips the perturbed values back into the bounded ϵ \epsilon ϵ -ball around x x x and clamps them to the valid input range (e.g., [ 0 , 1 ] [0, 1] [ 0 , 1 ] or [ 0 , 255 ] [0, 255] [ 0 , 255 ] ).
Computational Complexity : Requires K K K backpropagation passes (typically K = 10 , 20 , 40 K = 10, 20, 40 K = 10 , 20 , 40 iterations).
Carlini-Wagner (C&W) Attack
Formulated by Nicholas Carlini and David Wagner (2017), the C&W attack is an optimization-based attack designed to defeat defensive distillation and heuristic defenses. Instead of directly maximizing cross-entropy loss, C&W reframes the attack as a constrained optimization problem: min δ ( ∥ δ ∥ p + c ⋅ f ( x + δ ) ) \min_{\delta} \left( \|\delta\|_p + c \cdot f(x + \delta) \right) δ min ( ∥ δ ∥ p + c ⋅ f ( x + δ ) )
Where f ( x ′ ) f(x') f ( x ′ ) is an objective function designed such that f ( x ′ ) ≤ 0 f(x') \le 0 f ( x ′ ) ≤ 0 if and only if the model misclassifies x ′ x' x ′ into the target class t t t : f ( x ′ ) = max ( max i ≠ t Z ( x ′ ) i − Z ( x ′ ) t , − κ ) f(x') = \max\left( \max_{i \neq t} Z(x')_i - Z(x')_t, -\kappa \right) f ( x ′ ) = max ( i = t max Z ( x ′ ) i − Z ( x ′ ) t , − κ )
Here, Z ( x ′ ) Z(x') Z ( x ′ ) represents the raw unnormalized logits (pre-softmax outputs), and κ ≥ 0 \kappa \ge 0 κ ≥ 0 controls the attack's confidence margin .
To enforce box constraints ( x + δ ∈ [ 0 , 1 ] x + \delta \in [0, 1] x + δ ∈ [ 0 , 1 ] ) without clipping artifacts, C&W applies a change of variables: x + δ = 1 2 ( tanh ( w ) + 1 ) x + \delta = \frac{1}{2}(\tanh(w) + 1) x + δ = 2 1 ( tanh ( w ) + 1 ) , optimizing over unconstrained variable w w w .
Impact : C&W finds minimal-distortion adversarial examples ( L 0 , L 2 , L ∞ L_0, L_2, L_\infty L 0 , L 2 , L ∞ ) and systematically broke defensive distillation by operating directly on logits rather than vanishing softmax gradients.
- Attack Optimization Type Number of Steps Primary Metric Primary Defensive Countermeasure
- FGSM One-step gradient ascent 1 pass L ∞ L_\infty L ∞ Adversarial training (basic), gradient regularization
PGD Iterative projected ascent 10 to 100 passes L ∞ , L 2 L_\infty, L_2 L ∞ , L 2 Min-max robust adversarial training (Madry)
C&W Lagrangian optimization Hundreds of steps L 2 , L 0 , L ∞ L_2, L_0, L_\infty L 2 , L 0 , L ∞ Certified defenses, randomized smoothing
Adversarial Transferability and Physical-World Exploits
One of the most dangerous empirical properties of adversarial examples is transferability : an adversarial sample x a d v x_{adv} x a d v generated on a known, white-box surrogate model M A M_A M A will frequently fool an entirely different, unseen target model M B M_B M B , even when M B M_B M B :
Uses a completely different architecture (e.g., M A M_A M A is a Convolutional Neural Network like ResNet, while M B M_B M B is a Vision Transformer or Random Forest).
Was trained on a disjoint subset of training data.
Operates in a proprietary, black-box cloud API.
Transferability occurs because deep learning models trained on similar tasks learn fundamentally similar decision boundaries, projecting data onto shared, low-dimensional manifold representations. Attack vectors aligned along high-loss dimensions of M A M_A M A often align with high-loss directions of M B M_B M B .
Physical-World Adversarial Examples
In cybersecurity and physical infrastructure, attackers cannot inject digital pixel arrays directly into network pipelines. Instead, they must survive physical capture through cameras, microphones, or radio sensors:
Adversarial Patches (Brown et al., 2017): Highly textured, colorful visual stickers designed to dominate a classifier's attention. Placed anywhere in the camera's field of view, an adversarial patch can force an object detector to fail to detect a person (cloaking) or misclassify a stop sign as a toaster, regardless of camera angle or distance.
Expectation Over Transformation (EOT) (Athalye et al., 2018): Physical attacks must withstand environmental noise (rotations, scaling, lighting changes, camera lens distortions, distance). EOT optimizes the perturbation across a distribution of transformations T T T : max δ E t ∼ T [ L ( θ , t ( x + δ ) , y ) ] \max_\delta \mathbb{E}_{t \sim T}\left[ \mathcal{L}(\theta, t(x + \delta), y) \right] δ max E t ∼ T [ L ( θ , t ( x + δ ) , y ) ] EOT allows adversaries to 3D-print physical adversarial objects (such as a toy turtle classified as a rifle from any viewing angle).
Malware PE Evasion via Byte Padding : In endpoint security, ML-based antivirus (ML-AV) inspects Portable Executable (PE) binaries. Attackers generate adversarial byte perturbations and inject them into unused binary regions (e.g., the DOS header slack space, new non-functional PE sections, or overlay bytes appended to the end of the file). Because these regions are never executed by the Windows PE loader, the malware's malicious functionality remains intact while its global byte histogram and structural feature vectors shift into the ML-AV's "benign" classification space.
- Worked Scenario: Evading Autonomous Vision and Traffic Sign Classification
- Incident Context
A municipal transit authority deploys an autonomous shuttle fleet equipped with a deep learning vision system. The perception stack uses a convolutional neural network ( f θ f_\theta f θ ) to classify roadside signs. During a scheduled red team exercise, security engineers evaluate the shuttle's vulnerability to physical evasion. Original Image (x): Stop Sign (Ground Truth: Label 14)
- Target Malicious Class (y*): Speed Limit 45 (Label 4)
- Perturbation Bound: L_infinity <= 12/255
- Physical Medium: Adversarial Sticker Overlay on Sign Face
- Execution Steps
Surrogate Model Selection : The red team trains a surrogate ResNet-34 classifier using publicly available street sign datasets (GTSRB), matching the input dimensions ( 224 × 224 × 3 224 \times 224 \times 3 224 × 224 × 3 ) of the target vehicle's vision system.
Optimization via PGD with EOT : Using PGD, the engineers optimize a localized perturbation sticker δ \delta δ over 40 iterations with a step size α = 2 / 255 \alpha = 2/255 α = 2/255 . To survive physical conditions, they apply EOT across simulated brightness variations ( 0.7 × 0.7 \times 0.7 × to 1.3 × 1.3 \times 1.3 × ), perspective tilts ( − 15 ∘ -15^\circ − 1 5 ∘ to + 15 ∘ +15^\circ + 1 5 ∘ ), and blur kernels: δ ( t + 1 ) = Π S ( δ ( t ) − α ⋅ sign ( ∇ δ E t ∼ T [ L C E ( f s u r r ( t ( x + δ ) ) , Target: 45 ) ] ) ) \delta^{(t+1)} = \Pi_{\mathcal{S}}\left( \delta^{(t)} - \alpha \cdot \text{sign}\left( \nabla_\delta \mathbb{E}_{t \sim T} [\mathcal{L}_{CE}(f_{surr}(t(x + \delta)), \text{Target: 45})] \right) \right) δ ( t + 1 ) = Π S ( δ ( t ) − α ⋅ sign ( ∇ δ E t ∼ T [ L CE ( f s u rr ( t ( x + δ )) , Target: 45 )] ) )
Physical Deployment : The optimized perturbation is printed using a standard commercial inkjet printer onto weather-resistant matte vinyl and affixed across the center face of a standard 30-inch octagonal Stop Sign.
Inference Outcome : As the shuttle approaches the intersection at 25 MPH, its camera captures the sign. The onboard vision model classifies the sign as Speed Limit 45 with 94.2% confidence . The shuttle accelerates through the intersection without braking, confirming a critical physical evasion vulnerability.
Exam Traps and Architectural Pitfalls
Trap 1: Confusing Evasion with Poisoning : Exam questions frequently test whether an attack occurs at training time or inference time. Evasion attacks occur strictly at inference/test time on frozen model parameters θ \theta θ . If the question describes an attacker injecting corrupted samples into a training database or altering weights, it is a data poisoning or backdoor attack, not evasion.
Trap 2: Misinterpreting L 0 L_0 L 0 as Bounding Magnitude : Candidates often assume L 0 L_0 L 0 limits how drastically a feature can change. L 0 L_0 L 0 measures sparsity (the count of altered coordinates) , not the size of the change. Modifying a single pixel from pitch black ( 0 0 0 ) to pure white ( 255 255 255 ) has an L 0 L_0 L 0 norm of exactly 1 1 1 , even though the L ∞ L_\infty L ∞ change is at maximum ( 255 255 255 ).
Trap 3: The Black-Box Immunity Fallacy : Organizations frequently believe keeping their model architecture, weights, and APIs private provides sufficient protection against evasion. This is false: adversarial transferability allows adversaries to train local white-box surrogates and transfer attacks with high success rates, while score-based and decision-based black-box algorithms can extract decision boundaries without ever viewing model code.