A cloud configuration audit is largely won or lost before the first API call. Poorly scoped access, a vague perimeter or a security team that was not told, and engagement time is lost. Conversely, rigorous preparation turns a raw list of findings into a useful action plan.
This article is written so your teams can reuse it as is: it describes how the audit runs, the prerequisites for each provider, the most frequent weaknesses in our engagements on AWS, Microsoft Azure and Google Cloud, and ends with tips and a checklist.
What a cloud configuration audit is
A configuration audit examines, from the inside and with read-only rights, how your cloud environments are set up: identities and permissions, network exposure, storage, logging, encryption, governance guardrails. Unlike a penetration test, it does not try to exploit vulnerabilities: it compares what is configured with what should be, and measures the gap.
Auditors rely on recognized baselines (CIS Benchmarks for AWS, Azure and Google Cloud, provider and ANSSI recommendations, your own security policy), on automated collection tools (Prowler, ScoutSuite, or native services such as AWS Security Hub, Microsoft Defender for Cloud and Security Command Center) and, above all, on manual review. Tools produce hundreds of lines; the value of the audit lies in prioritization and in finding the attack paths tools do not see, such as a privilege escalation chain across two accounts.
Why start with a kickoff interview
It is tempting to hand over access and let the auditors "run the tools". That is the most expensive mistake. A tool does not know that a public bucket deliberately serves a static website, that a subscription is a sandbox with no data, or that half the admin accounts are managed by an outsourcer. Without context, the report mixes real risks with deliberate choices, and the team wears itself out sorting them.
The kickoff interview is used to:
- set the exact scope: AWS organization, Entra ID tenant and Azure management groups, Google Cloud organization, and the list of accounts, subscriptions and projects in or out of scope;
- understand the architecture: environments (production, staging, test), landing zones, hybrid connections to the internal network, internet-facing services;
- map identities: identity provider, federation, break-glass accounts, service accounts, third parties administering the environment;
- identify sensitive topics: health or personal data, regulatory requirements (HDS, SecNumCloud, NIS 2), past incidents, team concerns;
- learn about deliberate choices: intentionally public resources, approved exceptions, known technical debt already planned;
- agree on logistics: access, schedule, SOC notification, report format and recipients.
Come to the interview with an architecture diagram, even a rough one, the list of accounts, subscriptions and projects, and at least one person who works with the platform day to day (cloud architect, platform or DevOps team).
Prerequisites: read-only access
A configuration audit is performed with read-only rights, granted at the highest level of the hierarchy to cover the whole scope at once. The roles below give access to configuration metadata, not to the content of your business data.
| Provider | Recommended access | Assignment level |
|---|---|---|
| AWS | Dedicated IAM role assumable by the auditor, with the managed policies SecurityAudit and ViewOnlyAccess, an external ID condition and MFA required | Deployed in every account of the organization (StackSets), plus read access to organization policies (SCPs) from the management account or a delegated administrator account |
| Microsoft Azure | Reader and Security Reader roles on resources, Entra ID Global Reader role for the directory, Conditional Access and privileged roles | Tenant root management group, so it is inherited by all subscriptions |
| Google Cloud | Roles roles/iam.securityReviewer, roles/cloudasset.viewer, roles/orgpolicy.policyViewer and roles/viewer | Organization node, so it is inherited by all folders and projects |
Whatever the provider, access should be:
- named: one account per auditor, ideally a federated guest or an identity in your identity provider, never a shared account;
- protected by MFA and, where possible, restricted to the provider's IP addresses;
- time-limited: expiry date aligned with the end of the engagement, or a role activated on demand (PIM on Azure);
- tested before day one: a check session ahead of time keeps the engagement from stalling at launch.
Beyond access, gather:
- the inventory of accounts, subscriptions and projects, with their environment and owner;
- the architecture diagram and interconnection flows with the internal network;
- the security policy or cloud security policy, and approved exceptions;
- read access to infrastructure code (Terraform, Bicep, CloudFormation), if you want directly applicable recommendations;
- a technical contact available throughout the engagement.
The audit in seven steps
- Scoping and kickoff interview. Scope, context, baselines, deliverables, schedule.
- Access setup and testing. Accounts and roles created, coverage verified across the whole scope.
- Automated collection. Configuration extraction and first tool-based checks, with no changes made.
- Manual review and analysis. Triage of results, search for privilege escalation and exposure paths, assessment of each gap in light of the context gathered.
- Follow-up interviews. Short exchanges with the teams to confirm a use case, understand an exception, avoid a false positive.
- Debrief and report. Prioritized findings, evidence, provider-specific recommendations, executive summary.
- Remediation and retest. Fixes by your teams, then targeted verification of critical points.
Audit effort depends less on the raw number of resources than on the number of heterogeneous environments and the complexity of identities.
Lessons learned: the most frequent weaknesses
The same families of weaknesses come up across providers. The table below summarizes what we encounter most often, with a typical example per platform.
| Area | AWS | Azure | Google Cloud |
|---|---|---|---|
| Excessive privileges | AdministratorAccess or *:* policies widely assigned, roles assumable from third-party accounts with no condition | Too many subscription Owners and Entra ID Global Administrators, permanent assignments without PIM | Basic Owner / Editor roles at organization or folder level, default service account with Editor |
| Long-lived secrets | IAM user access keys never rotated, sometimes on the root account | Service principals with non-expiring secrets, storage account keys and long-lived SAS tokens | Service account keys downloaded and never revoked |
| Escalation paths | iam:PassRole or policy modification left to application roles | Ownership of an Entra application allowing a secret to be added to a privileged principal | iam.serviceAccounts.actAs or key creation on a privileged service account |
| Network exposure | Security groups open to 0.0.0.0/0 on SSH or RDP, public RDS databases | NSGs allowing administration from the internet, PaaS services without private endpoints | default network rules allowing SSH and RDP from anywhere, instances with public IPs |
| Exposed storage | S3 buckets outside Block Public Access, EBS or RDS snapshots shared publicly | Older storage accounts allowing anonymous blob access | Buckets granted to allUsers or allAuthenticatedUsers |
| Logging | CloudTrail trail missing on some regions or accounts, logs neither centralized nor protected | Activity and Entra sign-in logs not exported, so kept only for a short time | Data Access audit logs disabled (the default for most services) |
| Guardrails | No SCPs to block unused regions or CloudTrail being disabled | Azure Policy in audit mode only, never deny | Missing organization policy constraints (key creation, public IPs, allowed domains) |
Three cross-cutting findings deserve particular attention:
- Secrets in configuration. Passwords and keys in function environment variables, virtual machine user data, application settings, or a Terraform state file stored in a bucket readable by too many people.
- Forgotten environments. Accounts, subscriptions or projects created for a test or an old project, outside the landing zone, with no owner or guardrails, and sometimes connected to the production network.
- Detection without response. GuardDuty, Defender for Cloud or Security Command Center are enabled, but nobody reads the alerts, or they never reach the SOC.
Conversely, encryption at rest is rarely the real issue: it is enabled by default on all three providers. Gaps are more about key management (who can use them, delete them, disable their rotation).
Ten tips for a useful audit
- Audit at organization level, not account by account. The most serious weaknesses often sit between accounts: trust relationships, inherited roles, peered networks.
- Do not limit scope to production. Test environments often share identities, and sometimes the network, with production, under weaker controls.
- Include the directory. On Azure, most of the risk is in Entra ID; on AWS and Google Cloud, in federation with your identity provider.
- List your exceptions before the audit. Every documented deliberate choice is one less false positive in the report.
- Do not "clean up" just before. Rushed fixes the day before distort the snapshot and rob the audit of its value as a measurement. Fix afterwards, based on the report.
- Run your own native tools beforehand. Security Hub, Defender for Cloud or Security Command Center give you a free first view and let the audit focus on what they miss.
- Share the infrastructure code. A recommendation written in Terraform or Bicep is applied quickly; one written as console clicks is forgotten.
- Ask for prioritization by attack path. Ten medium findings that chain up to administrator matter more than an isolated, unexploitable "critical" one.
- Plan access revocation. Record from day one the date and the person responsible for removing the auditor's accounts and roles.
- Schedule the retest from the start. A targeted check after the remediation phase turns recommendations into actual fixes.
Preparation checklist
- Audit objective and expected baselines defined (CIS, security policy, regulatory requirement)
- Kickoff interview scheduled with someone who knows the platform
- Inventory of AWS accounts, Azure subscriptions and Google Cloud projects, with environment and owner
- In-scope / out-of-scope perimeter approved in writing
- Architecture diagram and interconnections with the internal network
- List of exceptions and deliberate choices
- Read-only access created at organization / root management group level
- Directory access (Entra ID, federation, identity provider) included
- Named accounts, MFA, IP restriction and expiry date in place
- Login tested across the whole scope before day one
- SOC, managed service provider and operations teams notified
- Read access to infrastructure code (optional)
- Technical contact appointed for the whole engagement
- Access revocation date and retest scheduled
If the configuration audit is followed by a penetration test, most of these items carry over; our article Preparing for a penetration test: 7 decisions completes this preparation.
← All articles