AWS service logging every API call (who/what/when/where/result); Azure Activity+Entra logs; GCP Cloud Audit Logs
Container
A lightweight, isolated unit packaging an app + dependencies (introduced here; image scanning in Ch. 31)
Serverless
Run code without managing servers (e.g., Lambda); a PaaS pattern where you own only code + config + access
Shared responsibility — who secures what, by model
Layer
On-Prem
IaaS
PaaS
SaaS
Data + classification
You
You
You
You
Identity & access (IAM)
You
You
You
You
Application logic
You
You
You
Provider
Runtime / middleware
You
You
Provider
Provider
Operating system
You
You
Provider
Provider
Virtualization / host
You
Provider
Provider
Provider
Physical network + datacenter
You
Provider
Provider
Provider
Rule: your share shrinks moving up the stack, but data and identity are ALWAYS yours — which is why
most cloud breaches live in those two layers. "Shared" duties (e.g., encryption at rest) are the trap:
provider supplies the capability; you must turn it on.
The top cloud misconfigurations (find these on sight)
Misconfig
What it looks like
Exploit
Prevent / detect
Public storage
Bucket ACL grants AllUsers READ (or WRITE)
Automated scanners enumerate + download via HTTP GET
Block Public Access (guardrail); default private + encrypt; CSPM; alert on PutBucketAcl/PutBucketPolicy
Over-broad IAM
"Action":"*" + "Resource":"*" on Allow
Leaked credential = total account compromise
Least privilege; access-analyzer right-sizing; deny * policies; require MFA; prefer roles over long-lived keys
Open security group
0.0.0.0/0 on 22 / 3389 / 3306 / 5432
Continuous brute-force of admin/DB ports
Restrict source to app subnet / bastion; SCP denying 0.0.0.0/0 on sensitive ports; CSPM
Exposed metadata
SSRF + un-hardened IMDS at 169.254.169.254 + wildcard role
Protects the running workload (vuln scan, runtime threat detection, malware)
Protective
Order:prevent with guardrails, detect with CSPM, protect workloads with CWPP — defense in depth on the
control plane. Guardrail vs. gate: a guardrail auto-blocks only the unsafe action (engineers move fast); a
gate halts a deployment for a human (bottleneck, gets bypassed). Guardrails scale in the cloud.
Turn logging on in all regions, make it comprehensive, and protect it from deletion (separate
locked-down account + object-lock). A log an attacker can erase is theater.
Decision aid — "which control when?"
If you want to…
Use…
Because…
Make a dangerous config impossible
a guardrail (Block Public Access, SCP, policy-as-code)
prevention scales; no human in the loop per change
Find misconfigs that already exist
CSPM
detective backstop for what guardrails miss or don't cover
control-plane evidence; the basis of every investigation
Know who read the data in a bucket
data-plane access logging (e.g., S3 access logs)
CloudTrail does NOT record object reads; without this you assume the worst
Bound a leaked credential's damage
least-privilege IAM + roles/short-lived creds
the policy is often the only thing behind a leaked key
Stop a stolen password from acting
MFA via policy condition
turns a credential into a dead end
Give a VM credentials safely
an attached IAM role (not a long-lived AKIA... key)
no durable secret to leak
Shortcut reflex: see AllUsers on a bucket → public, fix + guardrail. See "Action":"*"/"Resource":"*"
→ admin-equivalent, right-size. See 0.0.0.0/0 on 22/3389/3306/5432 → internet-exposed admin/DB, restrict
source. See StopLogging/DeleteTrail → page someone now.
Certification crosswalk
Concept
CompTIA Security+
(ISC)² CISSP domain
Shared responsibility; IaaS/PaaS/SaaS
3.0 Security Architecture
Security Architecture & Engineering
Cloud misconfiguration; public storage; SGs
2.0 Threats/Vulns; 3.0 Architecture
Security Architecture; Security Operations
Cloud IAM; least privilege
4.0 Security Operations
Identity & Access Management
CSPM / CWPP / guardrails
3.0 Architecture; 4.0 Operations
Security Operations
Cloud logging (CloudTrail) & detection
4.0 Security Operations
Security Operations
Project additions this chapter
Meridian program: cloud security baseline — Block Public Access (guardrail), all-region delete-proof
CloudTrail, least-privilege IAM (no *, MFA, no long-lived keys), SCP denying 0.0.0.0/0 on sensitive
ports, default encryption, CSPM against the CIS AWS Benchmark wired to the SOC.
bluekit toolkit:cloudpost.py — s3_public(acl) (public-bucket check) and iam_overbroad(policy)
(wildcard-policy check).
Common pitfalls
Assuming a secure provider means a secure deployment (it does not — your config is your job).
Misreading a shared duty (encryption at rest) as the provider's — leaving data unencrypted.
The "Action":"*" policy "to get it working," never tightened — total compromise if the credential leaks.
A 0.0.0.0/0 rule on an admin/DB port — a breach with a countdown timer.
Buying a CSPM tool and treating the 4,000-finding dashboard as "the work" (the unwatched-SIEM trap).
Running CloudTrail but never monitoring it — or running it where an attacker can delete it.
"A researcher found it, not an attacker" — backwards; it proves the exposure was trivially discoverable.
We use cookies to improve your experience and show relevant ads. Privacy Policy