cloud-config · git:20260929.29bbcb8 · 2026-09-29 · sha256 d88f5b3265104426
cloud-config git:20260929.29bbcb8B
Immutable. This exact content never changes and is served at /api/v1/blob/d88f5b3265104426.
No tool to install first
claude plugin marketplace add https://markdownregistry.com/mp/a/art_pzyyxts6n3ealusk/d88f5b32651044262586162734eb8a09dec03f3ad17e85dd8f8497571402df15.json
Then /plugin install cloud-config@markdownregistry-pzyyxts6n3ealusk in Claude Code. It installs this exact version, the one graded B here, pinned to the commit it was graded at, and leaves it there.
---
name: cloud-config
description: Cloud and platform configuration assessment — object storage public access, over-permissive IAM, instance metadata reachability, exposed Kubernetes and container registry APIs, managed identity trust, and secret material in the open. Read-only assessment methods; see IMPACT BOUNDARY.
---
# CLOUD AND PLATFORM CONFIGURATION
**Core:** most cloud findings are **read-only reachability tests**. You prove a
misconfiguration exists from outside. You do not use the access it grants.
The line between "assessing a cloud misconfiguration" and "using stolen cloud
credentials" is the entire legal and ethical boundary of this skill, and it is
not a grey area.
---
## PART 1 — WHAT IS IN SCOPE
A cloud misconfiguration is only in scope if the **cloud account is named in the
scope file**, or the program states that cloud infrastructure is in scope.
Many bug bounty programs scope only the web application and explicitly exclude
third-party SaaS and cloud accounts.
```
READ the program policy for:
- "cloud infrastructure" / "hosted services" in scope?
- explicit exclusions: "no testing of our cloud account",
"AWS/GCP/Azure out of scope", "no credential testing"
- safe-harbor wording that covers configuration review
```
**If the cloud account is not named, stop.** An S3 bucket found via a
subdomain is still the company's asset, but the authorization comes from the
program policy, not from the fact that you found it. Check before you probe.
---
## PART 2 — OBJECT STORAGE
```bash
# Anonymous listing — a 200 with keys is the finding
curl -s "https://<bucket>.s3.amazonaws.com/" | head -30
curl -s "https://storage.googleapis.com/storage/v1/b/<bucket>/o" | head -30
curl -s "https://<account>.blob.core.windows.net/<container>?restype=container&comp=list"
# Single known object — does the bucket deny by default?
curl -so /dev/null -w "%{http_code}\n" "https://<bucket>.s3.amazonaws.com/known-key"
```
```
READ: 403 Access Denied on list -> correct. Not a finding.
READ: 200 with object keys -> public listing. Report the policy.
READ: 403 list but 200 on a known key -> public objects, private listing.
Still a finding; note the distinction precisely.
```
**What makes this a strong report:** the *policy*, stated as a fact, plus the
object classes exposed (`access_logs/`, `backups/`, `user-uploads/`, `*.csv`),
plus whether writes are permitted. Do not download the contents. The listing
you already have is the evidence.
---
## PART 3 — INSTANCE METADATA (read-only reachability)
If you find any SSRF, the first question is *which cloud*, because the metadata
endpoint is the highest-value target — and also the clearest boundary.
```bash
# AWS / GCP — a 200 with these keys means SSRF reaches credentials
curl -s http://169.254.169.254/latest/meta-data/
curl -s http://169.254.169.254/latest/meta-data/iam/security-credentials/
curl -s http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/
# Azure
curl -s -H "Metadata: true" "http://169.254.169.254/metadata/instance?api-version=2021-02-01"
```
```
ALLOWED prove reachability with ONE request that returns the role name or the
list of credential names.
"SSRF returns the instance role name from the metadata service" is a
complete, high-severity finding. It is the finding.
STOPPED Do NOT fetch the access key id, secret, or session token.
Do NOT use them against any API.
```
This is the clearest line in the skill. **A metadata `RoleName` in the report
is a critical finding. The `SecretAccessKey` is evidence of a crime.** There is
no scenario in an authorized engagement where you need the secret to make the
report valid.
---
## PART 4 — EXPOSED MANAGEMENT APIS
```bash
# Kubernetes API — often reachable and unauthenticated on a bad network path
curl -sk https://<k8s-host>/version
curl -sk https://<k8s-host>/api/v1/namespaces
curl -sk https://<k8s-host>/api/v1/secrets # 403 = correct
# If 200 on /version and /api, the cluster is exposed — that is the finding.
# Container registry
curl -s https://<registry>/v2/ # 401 = correct
curl -s https://<registry>/v2/_catalog # 200 = enumerable
# Common admin panels — fingerprint only, no auth bypass attempts
/admin /actuator /actuator/env /actuator/health /debug/pprof /metrics
/jmx-console /solr /phpmyadmin /adminer
/swagger /openapi.json /graphql /_debug /server-status
```
```
/actuator/env exposing secrets, or /actuator/heapdump -> Critical, and the
report is just the endpoint and the fact. Do not read the dump.
```
---
## PART 5 — IAM AND TRUST POLICY REVIEW
Where source code or a public config is available, the finding is in the
policy. Read the policy; test nothing.
```json
{ "Effect": "Allow", "Action": "s3:*", "Resource": "*" }
{ "Effect": "Allow", "Action": "iam:PassRole", "Resource": "*" }
{ "Effect": "Allow", "Action": "sts:AssumeRole", "Resource": "*" }
```
```
FINDING: wildcard action on wildcard resource in a trust or access policy
SEVERITY: Critical if attached to a reachable principal; Medium if theoretical
EVIDENCE: the policy document. Nothing else is needed.
```
Wildcard-resource policies are routinely shipped to production and rarely
flagged by the team, so they are genuinely valuable findings — and reading a
policy is free and safe.
---
## IMPACT BOUNDARY
```
Metadata reachable -> one request, role name only. STOP.
Bucket public -> list keys, read nothing. STOP.
K8s API exposed -> GET /version, GET /api. STOP before /api/v1/secrets.
Exposed admin panel -> fingerprint and report. No auth bypass attempts.
IAM policy -> read and report. Test nothing.
Exposed secret in repo -> report the location and type. Do not authenticate with it.
```
**Never use a credential to prove you could.** An owner who reads "your
instance role is reachable via SSRF and grants `s3:*` on `*`, here is the
request that demonstrates the reach" has everything they need, and no incident.
The report that includes stolen keys is the one that ends the relationship.
---
## SEVERITY
```
SSRF reaching instance metadata with a privileged role -> Critical
Public bucket with PII, backups, or credentials -> Critical
Exposed admin panel leaking secrets (actuator/env, heapdump)-> Critical
Unauthenticated Kubernetes API -> Critical
Wildcard IAM policy in a reachable context -> High (Critical if live)
Public bucket with only public content -> Low
Container registry anonymously enumerable -> Medium
Exposed instance type, region, public IP via metadata -> Low
```
Use `severity-engine`. Cloud findings are scored on **what the misconfiguration
exposes**, and the report should lead with the policy or endpoint — a reviewer
can verify it in seconds, which is why these triage fast when reported honestly.