● Talk to a security engineer: +92 323 8295031info@protonyte.com  ·  PCSF batch enrolling now

Cloud penetration testing for AWS, Azure and Google Cloud

A configuration review tells you which settings are wrong. A cloud penetration test tells you what somebody can do with them. Protonyte starts from a low-privileged identity - a developer key, a compromised function, an exposed container - and tries to reach your data and your billing, the way a real intrusion in a cloud account actually unfolds.

one developer key pipeline roleprod account the data

ENGAGEMENT SCOPEtypical 1 - 2 week test

Identity and privilege escalation pathsIN SCOPE
Exposed storage and public resourcesIN SCOPE
Compute, container and Kubernetes escapeIN SCOPE
Serverless functions and their rolesIN SCOPE
Network and security group boundariesIN SCOPE
Full CIS configuration reviewOPTIONAL
// the basics

Where this ends and a configuration review begins

These are two different jobs and it is worth being plain about which you need. Our cloud security assessment goes across the whole account and measures it against the CIS benchmark: every bucket, every role, every log setting, scored and listed. It is the right starting point if you have never had one.

This page is the other job. We are given one small foothold and we try to get somewhere with it, the way an attacker would. Not "this role is over-permissive" but "this role let us read the deployment pipeline, which held a key to the production account". Most organizations should have the review first and this second - and we will say so rather than sell you the wrong one.

  • 01Starts from a footholdA low-privileged key or a compromised workload, which is how cloud intrusions actually begin.
  • 02Paths, not settingsThe report is a route from where we started to what we reached, with every step evidenced.
  • 03All three providersAWS, Azure and Google Cloud, including the places where the three behave differently.
  • 04Within the rulesEach provider sets out what customers may test. We stay inside it, and we tell you where the line is.
// coverage

What we go after

Identity first, because in a cloud account almost every path runs through a permission somebody granted and nobody revisited.

// the real target

Identity and privilege escalation

The cloud equivalent of Active Directory, and just as productive.

  • Role assumption and trust-policy abuse
  • PassRole, policy-version and similar escalations
  • Over-permissive managed policies
  • Stale keys, users and service principals
// the data

Storage and exposure

What can be read, listed or written by someone who should not.

  • Public and misconfigured buckets and blobs
  • Snapshots, images and backups left open
  • Database and cache exposure
  • Secrets in environment variables and user data
// the workloads

Compute and containers

Breaking out of the thing you landed in.

  • Metadata service abuse from a workload
  • Container escape and host access
  • Kubernetes RBAC and service accounts
  • Image registry and supply-chain exposure
// the glue

Serverless and automation

Functions and pipelines hold more privilege than anyone remembers granting.

  • Function execution roles
  • Event and trigger injection
  • CI/CD pipeline credentials
  • Infrastructure-as-code secrets
// the edges

Network boundaries

Whether the account is as separated as the diagram says.

  • Security group and NSG reality
  • Peering, transit and private endpoints
  • Reachability between accounts and subscriptions
  • Egress from a compromised workload
// who noticed

Logging and detection

What your trail recorded while we were in there.

  • CloudTrail, Activity Log and Audit Log coverage
  • Actions that generated no record
  • Alerting on key escalation events
  • Gaps handed to whoever watches them
// methodology

How the work runs

  1. 1

    Scope and the provider rules

    We agree the accounts, the starting foothold, and what each provider permits before anything begins.

    • Accounts, subscriptions or projects
    • The identity we start from
    • Provider testing policy checked
    • Written authorisation from the account owner
  2. 2

    Map the account

    Read-only enumeration of what exists and who can touch it.

    • Resource and identity inventory
    • Policy and trust relationships
    • Public exposure across the estate
    • Paths worth trying, ranked
  3. 3

    Escalate

    From the foothold outward, one permission at a time.

    • Privilege escalation within the account
    • Movement between accounts and tenants
    • Workload breakout and metadata abuse
    • Reach into pipelines and secrets
  4. 4

    Reach the data

    The point of the exercise: what an attacker would leave with.

    • Data stores reachable from the path
    • Proof of access without taking a copy
    • Billing and account-level control
    • Persistence an attacker could leave behind
  5. 5

    Report and retest

    The route, the permissions that allowed it, and the smallest change that breaks it.

    • Attack path with every step evidenced
    • Fixes ranked by how many paths they close
    • Detection notes for your logs
    • Retest and closure summary
// the deliverable

What you are left holding

Two documents and a conversation. Written so the person who signs the invoice and the person who writes the fix can both use them.

  • Executive summary in plain language, with the business risk first
  • Technical findings with the evidence that proves each one
  • CVSS score and a risk rating that reflects your business, not a template
  • Remediation written for the stack you actually run
  • A free retest, and a closure summary you can hand to a customer
  • A debrief call with the tester who did the work, not an account manager
Ask for a sample report
// the standards

Measured against something

The work follows CIS Benchmarks, MITRE ATT&CK for Cloud, NIST SP 800-115 and OWASP Top 10, so the coverage can be checked rather than taken on trust, and the report maps to what your auditor or your enterprise customer already recognises.

This page is one part of our penetration testing service. Where a finding needs a different kind of engagement to answer properly, we say so in the report rather than selling you the test we happen to be running.

// faq

Common questions

Is cloud penetration testing the same as a cloud security assessment?

No, and buying the wrong one is a common waste of money. An assessment measures your whole account against a benchmark and lists what is wrong; a penetration test starts from one foothold and shows what can be reached with it. If you have never had either, have the assessment first.

Do we need permission from AWS, Azure or Google?

For ordinary penetration testing of your own resources, the major providers permit it under their published customer testing policies without prior approval, with specific exclusions - denial of service being the main one. Some activities still require notice. We check the current policy for your provider during scoping and keep the test inside it.

What access do you need?

Less than people expect. A deliberately low-privileged identity is the most useful starting point, because it is what an attacker would have. For a wider review we also ask for read-only audit access, which lets us see paths we could not have discovered from the foothold alone.

Can you test Kubernetes?

Yes. Cluster RBAC, service-account token exposure, workload isolation, admission control and the path from a compromised pod to the node and then to the cloud account are all in scope, on EKS, AKS, GKE or self-managed.

Will anything be deleted or changed?

No. We prove access rather than use it: a file is read, not copied out; a privilege is obtained, not exercised against your data. Anything we create for the test is listed in the report and removed at the end.

// start here

Let's protect your business together.

Tell us what you need tested. Our team will reply with a clear scope and quote.

By submitting, you agree to our Terms of Use and Privacy Statement.