Domain 4: Secure AI Architecture, Engineering, and Identity and Access Management (IAM) (18% of exam)
4.1 Apply AI Architecture and Secure Design Principles
AI-specific security strategies: Zero Trust (ZT — verify everything, trust nothing by default), Defense-in-Depth (DiD — layered controls so no single failure is catastrophic), Privacy-by-Design (built in from the start), Secure Defaults (safest configuration out of the box, not opt-in security).
AI threat modeling across architectural components: applying threat modeling specifically to RAG pipelines, vector databases, and inference endpoints — each has distinct attack surfaces (e.g., RAG = poisoned retrieval content; vector DB = embedding leakage; inference = query-based extraction).
Architectural trade-offs: latency vs. explainability vs. cost — e.g., a more explainable model may be slower or more expensive to run; you're expected to recognize these tensions exist, not calculate them.
Build vs. buy: evaluating hosted (vendor-managed, less control, faster to deploy) vs. self-managed (more control, more security burden) AI solutions.
Secure integration for tools/APIs/plugins: MCP (Model Context Protocol — a standard for connecting AI models to external tools/data sources) and A2A (Agent-to-Agent — protocols for agents communicating with each other); both are relatively new named standards worth recognizing by name even without deep technical detail.
4.2 Architect Secure AI Infrastructure and Platforms
Hardening cloud/on-prem/hybrid AI deployments: applying standard infrastructure hardening practices to wherever AI workloads run.
Isolation and sandboxing: separating training and inference workloads from each other and from other systems, so a compromise in one doesn't cascade.
Availability controls against resource exhaustion: rate limiting and compute throttling to prevent a single user/attacker from starving the system of GPU/compute resources.
Isolated accelerator capacity: dedicating/segmenting GPU/TPU resources so workloads (especially multi-tenant ones) can't interfere with or snoop on each other.
Physical/environmental security: data center power, cooling, rack security, fire suppression — standard physical security, called out here because AI hardware (dense GPU clusters) has unique power/cooling demands.
4.3 Secure Data and Model Deployment Pipelines (MLOps/LLMOps)
Secure CI/CD and model deployment pipelines: packaging and containerization of models with the same security rigor as application code pipelines.
Integrity/confidentiality controls for data ingestion/transformation: protecting data as it moves through the pipeline stages, not just at rest.
Lineage tracking for fine-tuning: knowing exactly what data and base model went into a fine-tuned version — critical for audit and for tracing problems back to their source.
Validation checkpoints and pipeline gating: automated gates (tests, approvals) a model must pass before moving to the next pipeline stage — stops bad models from reaching production.
Data unlearning capabilities: the ability to make a trained model "forget" specific data it learned from (connects to the Domain 2 "right to erasure" problem — this is the technical mechanism that attempts to solve it).
4.4 Design and Implement AI Guardrails and Controls
AI input/output handling: prompt sanitization, content filtering, context boundary validation — technical implementation of the "guardrails" concept from Domain 1.6.
Architectural guardrails for autonomous behavior: a "harness" (the structural wrapper constraining what an agent can do) and orchestration (coordinating multi-step/multi-agent behavior within defined limits).
Functional/performance/load testing: confirming the AI system works correctly and performs acceptably under expected and peak conditions.
Stress testing and exception handling validation: confirming the system fails safely (doesn't do something dangerous) when pushed beyond normal limits or hit with unexpected input.
4.5 Implement AI Identification and Authentication Strategies
Human vs. non-human identity classification: a core new concept for this exam — agents, workloads, services, and tools now need their own identities, distinct from human user accounts.
Identity architectures for non-repudiation/accountability: ensuring every action (including an agent's) can be tied back to a verifiable identity — "the agent did it" isn't good enough; you need to know which agent, under whose authorization.
M2M (Machine-to-Machine) authentication and API tokens: how non-human identities actually authenticate to each other — this is your existing IAM knowledge applied directly.
Federated identities, MFA, SSO: standard identity concepts, now extended to cover AI agents/services as well as humans where applicable.
Secrets and key management for AI platforms: protecting the credentials/keys that AI systems and agents use to authenticate — same discipline as traditional secrets management, higher stakes given agent autonomy.
4.6 Design and Enforce AI Authorization and Access Controls
PoLP and SoD across AI/agentic workflows: Least Privilege (give only the access needed) and Separation of Duties (no single agent/person should control an entire sensitive process alone) — applied to models and agents, not just humans.
Authorization methodologies: RBAC (Role-Based — access tied to a defined role), ABAC (Attribute-Based — access tied to dynamic attributes like time/location/data sensitivity), PBAC (Policy-Based — access governed by broader organizational policy rules); JIT (Just-in-Time) access = granting elevated access only for the specific time window it's needed, then revoking it.
Execution boundaries and API scope limitations: restricting exactly what actions/API calls an agent is permitted to make, even if broader access exists technically.
Excessive agency / over-delegation / lateral movement prevention: a uniquely agentic-AI risk — an agent given too much autonomy or too broad a scope can take unintended actions or pivot beyond its intended task, similar in spirit to lateral movement in traditional security but driven by autonomous decision-making rather than an attacker's hands-on-keyboard actions.
4.7 Manage Identity Lifecycle and Auditing
AI identity inventories: maintaining a complete list of both human and non-human (agent/service) identities — same "you can't govern what you haven't inventoried" principle from Domain 2's use-case inventory, now applied to identities specifically.
Provisioning/deprovisioning: creating and — critically — fully removing access when an agent/service/human no longer needs it (deprovisioning is often the weaker link in practice).
Periodic access reviews and ISPM (Identity Security Posture Management): regularly re-validating that granted access is still appropriate; ISPM is the continuous, tool-driven version of this practice.
Audit of AI resource utilization: tracking token accounting, rate limits, and session timeouts — both a cost-control and a security-monitoring practice (unusual token usage can itself be a sign of misuse or compromise).