Öffentlicher S3-Bucket: KI-Terraform hebelt AWS-Schutz aus
KI-Tools schreiben Terraform, das S3 Block Public Access abschaltet, und einen Go-Handler, der Objekte öffentlich macht. So läuft der Exploit, so der Fix.
Wir auditieren KI-generierte Codebasen, und die schlimmsten Befunde stecken im Storage, weil dort niemand hinschaut. Lassen Sie ein Coding-Modell File-Uploads auf S3 einrichten, bekommen Sie oft einen öffentlichen S3-Bucket aus zwei Dateien, die zueinander passen: Terraform, das den Bucket zum Internet öffnet, und einen Go-Handler, der jedes Objekt mit einer public-read-ACL und einem vom Client gewählten Key schreibt. Wir nennen das die Public-Bucket-Falle. Hochgeladene Pässe, Rechnungen und unterschriebene Verträge liegen dann unter URLs, die jeder erraten und ohne Zugangsdaten abrufen kann. Das ist kein AWS-Problem. Seit April 2023 blockiert AWS den öffentlichen Zugriff auf neue Buckets standardmäßig. Das Modell schreibt den Code, der diesen Schutz wieder abschaltet, vermutlich weil viele der Beispiele, aus denen es gelernt hat, älter sind als die Änderung. Der Fix betrifft beide Dateien.
Ein öffentlicher S3-Bucket und erratbare Keys genügen dem Angreifer
Damit ein Angreifer den Upload eines anderen Nutzers lesen kann, müssen zwei Dinge zutreffen, und das Modell liefert beide. Der Bucket beantwortet anonyme Anfragen, und die Object-Keys sind vorhersehbar genug, um sie zu erraten. Das Erste erledigt das Terraform. Das Zweite erledigt der Go-Handler, indem er den Client die Datei benennen lässt.
Das Terraform schaltet alle drei AWS-Sperren ab
Das bekommen Sie auf „Terraform to host user uploads on S3“. Die Variablennamen wechseln zwischen den Tools, die Form bleibt.
resource "aws_s3_bucket" "uploads" {
bucket = "acme-user-uploads"
}
# Re-enables object ACLs, which AWS disables by default since April 2023.
resource "aws_s3_bucket_ownership_controls" "uploads" {
bucket = aws_s3_bucket.uploads.id
rule {
object_ownership = "BucketOwnerPreferred"
}
}
# Turns off Block Public Access, which AWS enables by default since April 2023.
resource "aws_s3_bucket_public_access_block" "uploads" {
bucket = aws_s3_bucket.uploads.id
block_public_acls = false
block_public_policy = false
ignore_public_acls = false
restrict_public_buckets = false
}
# Grants every anonymous caller read on every object.
resource "aws_s3_bucket_policy" "uploads" {
bucket = aws_s3_bucket.uploads.id
policy = jsonencode({
Version = "2012-10-17"
Statement = [{
Sid = "PublicReadGetObject"
Effect = "Allow"
Principal = "*"
Action = "s3:GetObject"
Resource = "${aws_s3_bucket.uploads.arn}/*"
}]
})
}
Liest man die Kommentare der Reihe nach, ist das Problem offensichtlich. AWS liefert drei Sperren. Diese Konfiguration macht alle drei rückgängig: Sie aktiviert ACLs wieder, schaltet Block Public Access ab und hängt eine Policy an, die s3:GetObject für Principal = "*" freigibt. Die Sid verrät es. PublicReadGetObject ist der wörtliche Name aus der AWS-Anleitung zu den Berechtigungen für statische Websites, ein Rezept, das das Modell sehr wahrscheinlich oft gesehen hat. Nichts im Prompt sagt ihm, ob es einen öffentlichen Bucket mit CSS-Dateien oder einen privaten Bucket mit Nutzerdokumenten vor sich hat, also greift es zum Rezept.
Der Go-Handler stempelt jedes Objekt öffentlich
Der Upload-Handler verlässt sich darauf, dass der Bucket öffentlich ist, und darauf, dass der Client die Datei benennt:
func (s *Server) handleUpload(w http.ResponseWriter, r *http.Request) {
file, header, err := r.FormFile("file")
if err != nil {
http.Error(w, "no file", http.StatusBadRequest)
return
}
defer file.Close()
key := header.Filename // whatever the browser sent
_, err = s.s3.PutObject(r.Context(), &s3.PutObjectInput{
Bucket: aws.String("acme-user-uploads"),
Key: aws.String(key),
Body: file,
ACL: types.ObjectCannedACLPublicRead,
})
if err != nil {
http.Error(w, "upload failed", http.StatusInternalServerError)
return
}
url := fmt.Sprintf("https://acme-user-uploads.s3.amazonaws.com/%s", key)
fmt.Fprintf(w, `{"url":%q}`, url)
}
Drei Entscheidungen, alle falsch:
key := header.Filename. Der Client wählt den Object-Key. Zwei Nutzer, die beideinvoice.pdfhochladen, kollidieren, und ein Angreifer kann Ihre Datei überschreiben, indem er mit Ihrem Key hochlädt.ACL: public-read. Selbst bei einer strengeren Bucket-Policy wird jedes Objekt beim Schreiben als weltweit lesbar markiert.- Die Antwort liefert die öffentliche URL, und damit sieht der Aufrufer genau, wie der Key-Namespace aussieht.
Der Exploit ist ein GET
Sie laden über Ihren eigenen Account eine Datei hoch. Die Antwort verrät die Form der URL:
https://acme-user-uploads.s3.amazonaws.com/invoice.pdf
Der Key ist nur ein Dateiname. Also raten Sie weitere Dateinamen:
curl https://acme-user-uploads.s3.amazonaws.com/passport.jpg
curl https://acme-user-uploads.s3.amazonaws.com/contract-acme.pdf
curl https://acme-user-uploads.s3.amazonaws.com/resume.pdf
Keine Signatur, kein Token, keine Session. Jede vorhandene Datei kommt mit 200 samt Inhalt zurück. Gewährt die generierte Policy zusätzlich s3:ListBucket, was ein Prompt wie „give my app full access to the bucket“ erzeugen kann, entfällt das Raten ganz:
aws s3 ls s3://acme-user-uploads --recursive --no-sign-request
Der Befehl braucht keinen AWS-Account. --no-sign-request heißt anonym. Er gibt den vollständigen Index aller Dateien aus, die je ein Nutzer hochgeladen hat.
Der Fix beginnt im Terraform: S3 Block Public Access bleibt an
Hören Sie auf, die Defaults rückgängig zu machen, und gehen Sie einen Schritt weiter: Machen Sie Object-ACLs unmöglich, sodass der public-read-Aufruf des alten Handlers laut fehlschlägt, statt still eine Datei offenzulegen.
resource "aws_s3_bucket" "uploads" {
bucket = "acme-user-uploads"
}
# BucketOwnerEnforced disables ACLs entirely. The PutObject ACL call
# in the old handler now returns an error instead of a public object.
resource "aws_s3_bucket_ownership_controls" "uploads" {
bucket = aws_s3_bucket.uploads.id
rule {
object_ownership = "BucketOwnerEnforced"
}
}
# All four on. This is the default; the only correct change is to leave it.
resource "aws_s3_bucket_public_access_block" "uploads" {
bucket = aws_s3_bucket.uploads.id
block_public_acls = true
block_public_policy = true
ignore_public_acls = true
restrict_public_buckets = true
}
resource "aws_s3_bucket_server_side_encryption_configuration" "uploads" {
bucket = aws_s3_bucket.uploads.id
rule {
apply_server_side_encryption_by_default {
sse_algorithm = "aws:kms"
}
}
}
resource "aws_s3_bucket_versioning" "uploads" {
bucket = aws_s3_bucket.uploads.id
versioning_configuration {
status = "Enabled"
}
}
Hier gibt es keine aws_s3_bucket_policy. Der Bucket ist privat. Nichts Anonymes liest daraus. BucketOwnerEnforced ist die tragende Zeile. Mit deaktivierten ACLs schlägt ein PUT mit öffentlicher ACL mit 400 und AccessControlListNotSupported fehl. So wird aus dem stillen Fehler des alten Handlers ein Fehler beim ersten Upload, und den bemerkt man. Versioning gibt Ihnen einen Weg zurück, wenn jemand ein Objekt überschreibt, und die KMS-Verschlüsselung ist ein Konfigurationsblock, den Sie sich beim Incident-Review wünschen werden.
Block Public Access auf Account-Ebene verhindert, dass ein Bucket ausschert
Die Sperre auf Bucket-Ebene hält nur bis zur nächsten Terraform-Änderung daran. S3 wendet die restriktivste Kombination aus Account- und Bucket-Einstellungen an, und AWS empfiehlt, alle vier für den Account einzuschalten. Dann macht ein späteres block_public_policy = false einen einzelnen Bucket nicht öffentlich:
resource "aws_s3_account_public_access_block" "this" {
block_public_acls = true
block_public_policy = true
ignore_public_acls = true
restrict_public_buckets = true
}
Nennen Sie alle vier. Die Terraform-Ressource setzt jede davon standardmäßig auf false, und ein Account kann nur eine solche Konfiguration haben. Hostet derselbe Account eine öffentliche statische Website, blockiert das auch diese; AWS schlägt dafür CloudFront vor einem privaten Bucket vor.
Die Defaults von 2023 haben an bestehenden Buckets nichts geändert. Prüfen Sie ältere Buckets also, statt es anzunehmen:
aws s3api get-public-access-block --bucket acme-user-uploads
aws s3api get-bucket-policy-status --bucket acme-user-uploads
Sie wollen alle vier Einstellungen auf true und IsPublic auf false. Der erste Befehl liefert nur die Konfiguration auf Bucket-Ebene, die Einstellungen des Accounts können das effektive Ergebnis also noch ändern.
Der Go-Handler vertraut dem Client nicht mehr
Der Server vergibt den Key. Der Server kennt die Identität. Das Objekt wird privat abgelegt, und gelesen wird über eine kurzlebige URL, die erst nach einer Ownership-Prüfung entsteht.
import "crypto/rand"
func newKey(userID string) string {
// rand.Text returns a fresh, unguessable token (Go 1.24+).
return fmt.Sprintf("uploads/%s/%s", userID, rand.Text())
}
func (s *Server) handleUpload(w http.ResponseWriter, r *http.Request) {
userID := s.userFromContext(r) // server-side identity, never the body
file, _, err := r.FormFile("file")
if err != nil {
http.Error(w, "no file", http.StatusBadRequest)
return
}
defer file.Close()
key := newKey(userID) // the server names the file, not the client
_, err = s.s3.PutObject(r.Context(), &s3.PutObjectInput{
Bucket: aws.String(s.bucket),
Key: aws.String(key),
Body: file,
// no ACL: the bucket rejects them, objects are private
})
if err != nil {
http.Error(w, "upload failed", http.StatusInternalServerError)
return
}
if err := s.store.SaveUpload(r.Context(), userID, key); err != nil {
http.Error(w, "save failed", http.StatusInternalServerError)
return
}
fmt.Fprintf(w, `{"key":%q}`, key)
}
Beim Lesen liegt die eigentliche Vertrauensgrenze. Ein gültiger Object-Key ist keine Leseberechtigung. Prüfen Sie erst die Ownership und stellen Sie dann eine URL aus, die abläuft:
func (s *Server) handleDownload(w http.ResponseWriter, r *http.Request) {
userID := s.userFromContext(r)
key := r.PathValue("key")
// The key is not authorization. Look up who owns it.
owner, err := s.store.OwnerOf(r.Context(), key)
if err != nil || owner != userID {
http.Error(w, "not found", http.StatusNotFound)
return
}
ps := s3.NewPresignClient(s.s3)
req, err := ps.PresignGetObject(r.Context(), &s3.GetObjectInput{
Bucket: aws.String(s.bucket),
Key: aws.String(key),
}, s3.WithPresignExpires(5*time.Minute))
if err != nil {
http.Error(w, "error", http.StatusInternalServerError)
return
}
http.Redirect(w, r, req.URL, http.StatusFound)
}
Geben Sie 404 zurück, nicht 403, wenn der Eigentümer nicht passt. Ein 403 bestätigt, dass der Key existiert, und liefert einem Angreifer ein Enumeration-Orakel. Das ist derselbe Defekt, den wir an verschiedenen Stellen immer wieder finden: der unsignierte Webhook als Default, ausgelieferte Apps mit deaktivierter RLS und der Page-vs-API-Split sind alle eine Vertrauensgrenze, die eine Schicht von der Stelle entfernt liegt, an der die Daten tatsächlich liegen.
Die Negativtests, die KI nicht schreibt
Drei Prüfungen. Führen Sie sie gegen den deployten Bucket und die deployte API aus:
# 1. A direct object URL must be denied now.
curl -s -o /dev/null -w "%{http_code}\n" \
https://acme-user-uploads.s3.amazonaws.com/uploads/some/key
# Expect: 403
# 2. Anonymous listing must be denied.
aws s3 ls s3://acme-user-uploads --no-sign-request
# Expect: AccessDenied
# 3. Another user's key, requested through your own API, must 404.
curl -H "Authorization: Bearer <user-B-token>" \
https://api.acme.com/files/uploads/<user-A-key>
# Expect: 404
Liefern die ersten beiden etwas anderes als eine Ablehnung, hat Ihr Terraform noch einen öffentlichen Pfad. Liefert der dritte die Datei, fehlt Ihre Ownership-Prüfung, und der private Bucket hat Ihnen nichts gebracht.
Eine Presigned URL bleibt ein Bearer-Token
Sie funktioniert für jeden, der sie hat, solange sie gültig ist. Halten Sie die TTL kurz und loggen Sie nie die vollständige URL, sonst haben Sie das Leck nur von S3 in Ihren Log-Aggregator verschoben. Signierte Lesezugriffe sagen auch nichts darüber, was hochgeladen wurde: Dateityp-Prüfung, Größenlimits und Malware-Scans sind eigene Probleme, die dieser Fix nicht berührt. Auch Block Public Access deckt nicht alles ab. AWS rät, identitätsbasierte Policies und KMS-Key-Policies separat zu prüfen. Und wenn Sie Supabase Storage statt S3 nutzen: Buckets sind dort standardmäßig privat, aber derselbe Fehler ist nur eine Einstellung entfernt. Ein öffentlicher Bucket überspringt dort die Zugriffskontrolle beim Lesen, und jeder mit dem Link bekommt die Datei.
Öffentlich ist eine Entscheidung, die das Modell für Sie getroffen hat
Ein weltweit lesbarer Bucket ist der kürzeste Weg vom Prompt zum funktionierenden Upload. Drehen Sie das um. Nichts im Object Storage sollte erreichbar sein, wenn nicht Ihr eigener Code genau diesen Lesezugriff autorisiert, für diesen Nutzer, bei jeder Anfrage. Die einzige Frage, die sich bei einem Bucket lohnt, lautet: Kann jemand, der die URL kennt, die Datei dahinter abrufen? Lautet die Antwort ja, spielt alles andere, was Sie an diesem Bucket konfiguriert haben, keine Rolle.