Moving workloads to Amazon Web Services does not move the responsibility for security onto Amazon. Under the shared responsibility model, AWS secures the cloud itself, but everything you build inside it, the IAM policies, the S3 buckets, the Lambda functions, the security groups, belongs to you. That is exactly where attackers look first, and it is exactly where a well-scoped AWS penetration test earns its keep.
This guide walks through what the AWS penetration testing policy actually permits, how to scope an engagement so it is both legal and useful, and the SaaS-style misconfigurations that show up again and again in real assessments. Expect real commands, real tooling, and the kind of detail your engineers can act on.
Traditional network penetration testing assumes a perimeter: a block of IP addresses, a handful of exposed services, and a clear line between inside and outside. AWS dissolves that perimeter. An EC2 instance can be reached from the public internet one minute and tucked behind a NAT gateway the next. A single leaked access key can grant more reach than any open port ever could.
AWS penetration testing therefore focuses less on remote exploits and more on identity, configuration, and trust relationships. The questions change. Instead of "which port is open," testers ask "which role can assume which other role," "which bucket policy is world-readable," and "which Lambda function holds a hardcoded secret." The attack surface is defined by API permissions, not network segments.
Because of that shift, the methodology leans heavily on the AWS control plane. Testers interrogate the environment through the same APIs your developers use, enumerate identities and resources, then map the paths an adversary could chain together. If your team has never seen a cloud-specific assessment, the structured approach used by Redfox Cybersecurity is a good reference point for how deep this work can and should go.
Yes, within limits. As of its current customer support policy, AWS permits customers to perform security testing against a defined list of their own services without requesting permission first. This was a major change from the older model where every test needed a signed authorization form and a scheduling window.
The permitted services generally include the resources you provision and control directly:
For these, you can run vulnerability scans, attempt exploitation, and probe your own application logic, provided the targets belong to your account.
Some activities remain off-limits regardless of who owns the account. Denial of service and distributed denial of service simulations, port flooding, protocol flooding, and request flooding against AWS infrastructure all require a separate, explicit engagement with AWS. Testing other customers' resources is never allowed, and neither is pivoting into the underlying AWS-managed infrastructure. If an engagement needs load or stress testing, that is a separate conversation with Amazon before any packets fly.
The practical takeaway: an authenticated configuration and identity review, the heart of most AWS assessments, falls squarely inside the permitted zone. A heavy DoS simulation does not. Scoping has to respect that line, which brings us to the next section.
Scope is where cloud engagements succeed or fail. A vague scope produces a report full of informational findings. A sharp scope produces a report that changes how your engineers build.
Start by naming the accounts in play. A modern AWS estate is rarely one account; it is an AWS Organization with separate accounts for production, staging, security tooling, and logging. Decide which accounts are in scope and whether cross-account trust relationships should be followed when discovered.
Most mature cloud tests run in an assumed breach model. Rather than spending days trying to phish a credential, you grant the tester a low-privilege starting identity and ask the real question: from here, how far can an attacker get? This mirrors how cloud breaches actually unfold, where a single exposed key or a compromised CI runner becomes the foothold.
Give testers a dedicated principal, not a shared admin key. A read-oriented reviewer role plus a scoped set of write permissions for specific proof-of-concept actions keeps the blast radius controlled. A minimal starting policy for an enumeration-focused reviewer looks like this:
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ReadOnlyRecon",
"Effect": "Allow",
"Action": [
"iam:List*",
"iam:Get*",
"s3:ListAllMyBuckets",
"s3:GetBucketPolicy",
"ec2:Describe*",
"lambda:List*",
"sts:GetCallerIdentity"
],
"Resource": "*"
}
]
}
[cta]
Before any tooling runs, confirm the identity you have actually landed on. This one command settles who you are, which account you are in, and whether your credentials are even valid:
aws sts get-caller-identity --output json
[cta]
If you are weighing how broad or narrow that starting identity should be, the scoping specialists at Redfox Cybersecurity can help you model a realistic foothold rather than an artificial one that either over-permits the tester or hides real risk.
Once you have a foothold, the first job is understanding what that identity can do. Permissions in AWS are rarely documented accurately, so you brute-force the question by asking the API directly. The open-source tool enumerate-iam probes hundreds of read-only calls to map what your principal is allowed to touch:
python3 enumerate-iam.py \
--access-key AKIAEXAMPLE1234567 \
--secret-key wJalrXUtnFEMIexampleKEY \
--region us-east-1
[cta]
The output tells you which services respond, which is the raw material for everything that follows. From there, CloudFox is purpose-built to turn that access into an attacker's map of the environment, surfacing exploitable paths, secrets, and resources an adversary would prize:
cloudfox aws --profile pentest-recon all-checks
[cta]
CloudFox will flag things like instances with attached roles, public endpoints, and interesting permission combinations, saving hours of manual Describe calls. Treat its output as leads to verify, not conclusions, since context decides whether a finding is a real risk or an accepted design choice.
Across hundreds of cloud assessments, the same handful of misconfigurations account for the majority of serious findings. They are rarely exotic. They are defaults left unchanged, permissions granted too broadly, and secrets left where code can reach them.
The S3 bucket remains the most famous cloud mistake for a reason. A single misapplied ACL or bucket policy can expose customer data to the entire internet. During a test, you enumerate buckets, then check each one's access posture:
aws s3api get-bucket-acl --bucket client-prod-assets
aws s3api get-public-access-block --bucket client-prod-assets
aws s3 ls s3://client-prod-assets --no-sign-request
[cta]
That final command is the telling one. If --no-sign-request returns a listing, the bucket is readable with no credentials at all, meaning anyone on the planet can do the same. For unauthenticated discovery across a naming convention, s3scanner sweeps candidate names and reports which exist and which are open:
s3scanner scan --bucket-file candidate-buckets.txt --enumerate
[cta]
The fix is layered: enable S3 Block Public Access at the account level, audit every bucket policy, and treat any public bucket as a finding until proven intentional. If your team is unsure how to audit storage exposure at scale, Redfox Cybersecurity's cloud testing practice builds this enumeration into every AWS engagement so nothing is assumed safe by default.
The second recurring theme is identity sprawl. Policies written with "Action": "*" and "Resource": "*" are convenient during development and catastrophic in production. A role meant to read one bucket ends up able to rewrite IAM, launch instances, or read every secret in the account.
Pacu, an AWS exploitation framework, includes modules that enumerate your permissions and then actively test for privilege escalation paths. After importing your test keys, the escalation module probes dozens of known techniques:
pacu
> set_keys
> run iam__enum_permissions
> run iam__privesc_scan
[cta]
The iam__privesc_scan module looks for combinations like iam:CreatePolicyVersion, iam:PassRole paired with service creation, or lambda:CreateFunction with an attachable admin role. Any one of these lets a low-privilege user climb to full administrator. These are not theoretical; they are among the most common paths to account takeover in real incidents, which is why mapping them deliberately is central to how Redfox Cybersecurity assesses cloud identity risk.
SaaS applications built on AWS leak secrets constantly: database passwords baked into Lambda environment variables, API tokens in user data scripts, and long-lived access keys committed to source control. Pulling a function's configuration often reveals more than it should:
aws lambda get-function-configuration \
--function-name process-payments \
--query 'Environment.Variables'
[cta]
Instance metadata is another rich target. On an EC2 host with the older metadata service enabled, temporary role credentials are one request away, and from a vulnerable application an attacker reaches them through server-side request forgery:
TOKEN=$(curl -s -X PUT "http://169.254.169.254/latest/api/token" \
-H "X-aws-ec2-metadata-token-ttl-seconds: 21600")
curl -s -H "X-aws-ec2-metadata-token: $TOKEN" \
http://169.254.169.254/latest/meta-data/iam/security-credentials/
[cta]
For code and configuration at rest, trufflehog scans repositories and filesystems for high-entropy strings and known credential patterns, catching secrets before they become breaches:
trufflehog filesystem ./app-source --only-verified
[cta]
The remediation is consistent: move secrets into AWS Secrets Manager or Parameter Store, enforce IMDSv2 so the metadata service demands a session token, and rotate anything that has ever touched a repository.
Backups leak as readily as live data. An RDS snapshot or EBS volume shared publicly, sometimes by accident during a troubleshooting session, hands an attacker a full copy of your database. Checking snapshot visibility is quick:
aws rds describe-db-snapshots \
--snapshot-type public \
--query 'DBSnapshots[*].DBSnapshotIdentifier'
[cta]
If anything returns here that belongs to you, treat it as an active data exposure. Private snapshots that are over-shared with specific external account IDs are just as dangerous and far easier to miss.
The cloud equivalent of leaving a door unlocked is a security group allowing 0.0.0.0/0 on a sensitive port. Databases, SSH, and RDP exposed to the entire internet remain shockingly common. A single query surfaces the worst offenders:
aws ec2 describe-security-groups \
--filters Name=ip-permission.cidr,Values=0.0.0.0/0 \
--query 'SecurityGroups[*].{Name:GroupName,Id:GroupId}'
[cta]
Each result deserves scrutiny. Port 443 open to the world may be intentional for a web server; port 3306 open to the world almost never is.
Manual enumeration finds the deep, chained issues, but automated scanners give you breadth and a baseline fast. Two tools dominate here, and running both gives complementary coverage.
Prowler checks an account against hundreds of controls mapped to CIS benchmarks, GDPR, HIPAA and more, producing findings you can hand straight to an engineering team:
prowler aws \
--profile pentest-recon \
--severity critical high \
--output-formats html json-ocsf
[cta]
ScoutSuite takes a different angle, generating an interactive HTML dashboard of your entire account posture that is excellent for walking stakeholders through risk visually:
scout aws --profile pentest-recon --report-dir ./scout-report
[cta]
The discipline that separates a checkbox scan from a real assessment is triage. Automated tools generate noise, and a mature engagement filters that output, validates exploitability, and chains individual findings into attack narratives. A world-readable bucket is a finding; a world-readable bucket containing a credentials file that unlocks an admin role is a breach story. Turning raw scanner output into that kind of prioritized, validated narrative is the core value that Redfox Cybersecurity delivers beyond any single tool.
Pricing depends on the size of the estate, the number of accounts, and the depth of testing, but published starting points give a useful anchor. Redfox Cybersecurity lists cloud penetration testing from $2,400 for a single cloud account, covering a configuration and identity review, delivered over roughly four business days. Final pricing is scoped per environment and fixed before any work begins, so there are no surprises mid-engagement.
For organizations running more than cloud, broader starting points are published too: external network testing from $1,600 for up to 50 internet-facing IPs, web application and API testing from $4,000 for one application and one API with authenticated roles, and internal network testing from $4,000 for an assumed-breach review of up to 500 IPs. Teams that want coverage across several of these in a single consolidated report can scope an audit bundle that combines web, API, external and cloud testing, priced per environment.
The relevant comparison is not the invoice; it is the cost of the breach the test prevents. A single exposed snapshot or an over-permissive role can end in a regulatory fine and months of incident response that dwarf the price of the assessment. For current scoping and a fixed quote tailored to your account structure, the team at Redfox Cybersecurity can turn a rough description of your environment into a defined engagement.
A once-a-year test is better than none, but cloud environments change daily. Every new Terraform apply, every new Lambda, every new IAM policy is a chance to reintroduce the exact misconfigurations covered above. The strongest programs pair periodic deep-dive penetration tests with continuous configuration monitoring, so regressions are caught in days rather than at the next annual review.
Practically, that means wiring tools like Prowler into a pipeline for baseline coverage, reserving human-led testing for the identity chains and business-logic flaws that scanners miss, and retesting after major architecture changes. The goal is to make secure configuration the default state of the account, not a condition you rediscover once a year.
AWS penetration testing is a discipline of identity, configuration, and trust far more than one of ports and exploits. The current AWS policy lets you test your own in-scope services without prior approval, while keeping denial-of-service simulation behind a separate request, so scope has to respect that boundary from the start. The misconfigurations that matter are rarely exotic: public S3 buckets, wildcard IAM policies, hardcoded secrets, exposed snapshots, and wide-open security groups account for most serious findings, and each has a clear command to detect it and a clear path to fix it.
Automated scanners like Prowler and ScoutSuite give you breadth, frameworks like Pacu and CloudFox give you depth, but the real value comes from chaining findings into attack narratives and prioritizing what to fix first. That is the work that protects real data. If you want a fixed-scope AWS assessment that goes beyond a checkbox scan, starting from $2,400 for a single cloud account, Redfox Cybersecurity can scope it against your actual environment and hand your engineers a report they can act on.