Skip to content

Modul 18: Security: Krypto, OAuth2 & Supply Chain

Security in Go von der Kryptografie bis zur Supply Chain: AES-GCM und Argon2id aus dem crypto-Paket richtig einsetzen, JWTs mit golang-jwt/v5 signieren, prüfen und rotieren, OAuth2/OIDC-Flows mit golang.org/x/oauth2 und go-oidc inklusive PKCE, Secrets-Management mit Vault und SOPS jenseits der env-Fallstricke — und die Lieferkette abgesichert mit govulncheck, GOPRIVATE und SBOM.

Fortschritt0/5 Lektionen
86

crypto-Paket richtig: AES-GCM, Argon2 & SecureRandom

Lektion 86 von 100

Der Pentest-Brief: Kundendaten im Klartext

Es ist ein Dienstag, als »Kant & Kurve« den Bericht des externen Pentesters bekommt. Befund 3: Die Daten der Treuekarten-Kunden liegen unverschlüsselt auf der Platte. Befund 4: Das Passwort-Hashing der Mitarbeiter-Konten beruht noch auf einem einzelnen SHA-256-Durchlauf. Der Betrieb will zwei Dinge von dir: sensible Felder verschlüsseln und Passwörter ordentlich hashen. Die gute Nachricht für Go-Entwickler: Der Großteil dessen, was dafür nötig ist, kommt aus der Standardbibliothek — crypto/aes, crypto/cipher, crypto/rand — plus einem einzigen Paket aus der x-Reihe: golang.org/x/crypto/argon2.

Bevor irgendwelcher Code entsteht, die wichtigste Weichenstellung: Verschlüsselung und Hashing sind zwei verschiedene Werkzeuge für zwei verschiedene Fragen. Verschlüsselung (AES-GCM) ist umkehrbar — der Klartext soll später wieder herauskommen, etwa um eine Adresse anzuzeigen. Hashing (Argon2id) ist bewusst nicht umkehrbar — beim Passwortwillst du nur prüfen, nie zurückholen. Wer Passwörter »verschlüsselt« statt hasht, hat die Frage nicht verstanden; wer Kundendaten hasht, die die Buchhandlung später braucht, hat die Daten zerstört.

AES-GCM verschlüsselt und siegelt zugleich

AES allein ist nur ein Block-Chiffre. Der GCM-Modus (Galois/Counter Mode) baut daraus authentifizierte Verschlüsselung: Der Geheimtext trägt einen Authentifizierungs-Tag, der beim Öffnen geprüft wird. Manipulierte oder vertauschte Geheimtexte führen beim Entschlüsseln zu einem Fehler, nicht zu Müll-Daten. Deshalb ist cipher.NewGCM in Go der Standard-Weg für symmetrische Verschlüsselung — CBC ohne MAC ist angreifbar (Padding-Oracle) und gehört nicht mehr in neuen Code.

Erstens die Feldverschlüsselung für die Treuekarten-Daten. Der Schlüssel kommt hier aus einer 32-Byte-Quelle (hex), das Nonce wird frisch aus crypto/rand gezogen und dem Geheimtext vorangestellt — so braucht die Datenbank nur eine Spalte:

// internal/crypto/aesgcm.go — AES-256-GCM: verschlüsseln mit frischem Nonce
package crypto

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"errors"
	"io"
)

func Encrypt(key, plaintext []byte) ([]byte, error) {
	block, err := aes.NewCipher(key) // key muss 16, 24 oder 32 Bytes lang sein
	if err != nil {
		return nil, err
	}
	gcm, err := cipher.NewGCM(block)
	if err != nil {
		return nil, err
	}
	nonce := make([]byte, gcm.NonceSize()) // 12 Bytes im Standard-GCM
	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
		return nil, err
	}
	// Seal hängt den Tag hinten an; das Nonce stellen wir voran
	return gcm.Seal(nonce, nonce, plaintext, nil), nil
}

func Decrypt(key, sealed []byte) ([]byte, error) {
	block, err := aes.NewCipher(key)
	if err != nil {
		return nil, err
	}
	gcm, err := cipher.NewGCM(block)
	if err != nil {
		return nil, err
	}
	if len(sealed) < gcm.NonceSize() {
		return nil, errors.New("geheimtext zu kurz")
	}
	nonce, ciphertext := sealed[:gcm.NonceSize()], sealed[gcm.NonceSize():]
	return gcm.Open(nil, nonce, ciphertext, nil) // Tag-Prüfung inklusive
}

// Terminal: go test ./internal/crypto/ -run TestRoundTrip -v
// → === RUN   TestRoundTrip
// → --- PASS: TestRoundTrip (0.00s) — 24 Bytes Klartext, 12 Nonce + 16 Tag oben drauf

Zweitens das Passwort-Hashing für die Mitarbeiter-Konten. Argon2id — aus golang.org/x/crypto/argon2 — ist der aktuelle OWASP-Empfehlungs-Standard, weil es Schlüssel ableitet, die teuer sind in beiden Dimensionen: Rechenzeit und Speicher. Damit sind GPU- und ASIC-Farmen ausgebremst, mit denen SHA-256 in Mikrosekunden durchgerechnet wird. Und weil die Parameter später mitwandern müssen (bessere Hardware → härtere Parameter), speichert man sie gleich im PHC-String-Format mit:

// internal/crypto/password.go — Argon2id-Hash mit Parametern im PHC-Format
package crypto

import (
	"crypto/rand"
	"crypto/subtle"
	"fmt"

	"golang.org/x/crypto/argon2"
)

const (
	argonTime    = 1         // Durchläufe
	argonMemory  = 64 * 1024 // 64 MiB Speicher pro Hash — OWASP-Größenordnung
	argonThreads = 4
)

func HashPassword(password string) (string, error) {
	salt := make([]byte, 16)
	if _, err := rand.Read(salt); err != nil {
		return "", err
	}
	key := argon2.IDKey([]byte(password), salt,
		argonTime, argonMemory, argonThreads, 32)

	// Parameter MITspeichern — sonst kannst du später nichts mehr prüfen
	return fmt.Sprintf("$argon2id$v=19$m=%d,t=%d,p=%d$%x$%x",
		argonMemory, argonTime, argonThreads, salt, key), nil
}

func VerifyPassword(password, phc string) bool {
	var m uint32
	var t uint32
	var p uint8
	var salt, key []byte
	if _, err := fmt.Sscanf(phc, "$argon2id$v=19$m=%d,t=%d,p=%d$%x$%x",
		&m, &t, &p, &salt, &key); err != nil {
		return false
	}
	got := argon2.IDKey([]byte(password), salt, t, m, p, uint32(len(key)))
	return subtle.ConstantTimeCompare(got, key) == 1 // zeitkonstanter Vergleich
}

// Terminal: go test ./internal/crypto/ -run TestPassword -v
// → Hash:   $argon2id$v=19$m=65536,t=1,p=4$9f12…$a3b7…
// → Verify: richtiges Passwort → true, Tippfehler → false (in konstanter Zeit)

Der Vollständigkeit halber die dritte Zutat, die im Briefing oft untergeht: SecureRandom. Schlüssel, Nonces und Salts brauchen Zufall, den ein Angreifer nicht vorhersagen kann. Dafür gibt es crypto/rand — math/rand ist es nicht, auch wenn es seit Go 1.20 automatisch gesät wird: Es ist für Simulationen und Tests gebaut, nicht gegen Angreifer. Die Faustregel: Alles, was geheim bleiben oder einzigartig sein muss, kommt aus crypto/rand; alles andere darf aus math/rand (bzw. math/rand/v2 seit Go 1.22) kommen.

Was übrigens verschlüsselt werden muss und was nicht, und wo genau die Grenze zwischen dem vertrauenswürdigen Kern und der weiten Welt verläuft, ist keine Go-Frage, sondern eine Architektur-Frage — die Trust-Boundaries und Schichtenzonen behandelt Modul 9 des Architektur-Kurses. Der Go-Teil daraus ist schlicht: Der Schlüssel lebt NIE neben den Daten, die er schützt — sonst verschlüsselst du den Tresor und klebst den Schlüssel dran.

⚠ Häufiger Fehler: Das Nonce fest verdrahten oder aus einem deterministischen Zähler ableiten, »damit die Tests reproduzierbar sind«. GCM bricht bei Nonce-Wiederverwendung mit demselben Schlüssel gleich doppelt: Zwei Geheimtexte mit gleichem Nonce ergeben ein Two-Time-Pad, aus dem sich Klartext rekonstruieren lässt — und schlimmer noch, die Authentifizierungs-Funktion leakt ihren Schlüsselteil, sodass Angreifer anschließend gültige Geheimtexte fälschen können. Nonces sind Einweg: frisch aus crypto/rand, 12 Bytes, pro Verschlüsselung neu. Für reproduzierbare Tests den Zufall injizieren (eigenes Interface statt direktem rand.Reader), niemals die Produktion deterministisch machen.

✅ Wichtige Erkenntnisse

Haken setzen, um deinen Lernfortschritt zu markieren:

    87

    JWTs sicher: golang-jwt/v5, Claims & Rotation

    Lektion 87 von 100

    Sessions ohne Datenbank-Roundtrip — aber richtig

    Die Middleware aus Lektion 57 prüft Bearer-Tokens gegen die Datenbank — bei jedem Request ein Query. Mit wachsendem Traffic will das Team diese Abfrage loswerden und setzt auf JWTs: Der Login stellt ein signiertes Token aus, jede nachfolgende Middleware prüft nur noch die Signatur. Zustandslos, schnell, horizontal skalierend. Aber nur, wenn drei Dinge stimmen: die Bibliothek, die Prüfung und die Lebensdauer.

    Zur Bibliothek zuerst, weil hier ein Stück Go-Geschichte irritiert: Das uralt bekannte github.com/dgrijalva/jwt-go wird seit Jahren nicht mehr gepflegt und hat mit CVE-2020-26160 eine Lücke in der Audience-Prüfung. Die Community hat das Projekt geforkt; der gepflegte Pfad heißt heute github.com/golang-jwt/jwt/v5 — major-versioniertes Modul, aktiv betreut, API-Brüche gegenüber dem Ur-Fork sauber in v5 gebündelt. Neuer Code importiert ausschließlich v5.

    Ein JWT ist ein unterschriebener Umschlag, kein verschlossener Tresor

    Ein JWS-Token besteht aus drei Base64-Teilen: Header, Payload, Signatur. Signiert heißt: veränderungssicher gegen Dritte. Es heißt NICHT geheim — jeder, der das Token in die Finger bekommt, kann den Payload lesen (einfach base64-dekodieren). Passwörter, Geheimnisse oder Interna gehören deshalb nie in die Claims. Wer Vertraulichkeit braucht, braucht Verschlüsselung (JWE) — ein anderes Werkzeug.

    Zuerst das Ausstellen. Die Claims sitzen in einem eigenen Struct, das jwt.RegisteredClaims einbettet — die Standard-Felder iss, sub, exp, iat sind damit typsicher gesetzt statt als lose Strings:

    // internal/auth/issue.go — Access-Token ausstellen, 15 Minuten gültig
    package auth
    
    import (
    	"time"
    
    	"github.com/golang-jwt/jwt/v5"
    )
    
    type StaffClaims struct {
    	Role string `json:"role"` // "lager" oder "admin" — Autorisierung folgt in Lektion 57-Manier
    	jwt.RegisteredClaims
    }
    
    func IssueAccessToken(secret []byte, user, role string) (string, error) {
    	now := time.Now()
    	claims := StaffClaims{
    		Role: role,
    		RegisteredClaims: jwt.RegisteredClaims{
    			Issuer:    "bookstore",
    			Subject:   user,
    			IssuedAt:  jwt.NewNumericDate(now),
    			ExpiresAt: jwt.NewNumericDate(now.Add(15 * time.Minute)), // bewusst kurz
    		},
    	}
    	return jwt.NewWithClaims(jwt.SigningMethodHS256, claims).SignedString(secret)
    }
    
    // Terminal: Token für Lena ausstellen und ansehen
    // → eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoiYWRtaW4iLCJpc3MiOiJib29rc3RvcmUiLCJzdWIiOiJsZW5hIn0.kQ9…
    // → (base64 des Mittelteils: role=admin, iss=bookstore, sub=lena, exp=… — für jeden lesbar!)
    

    Dann das Prüfen — und hier sitzen die eigentlichen Fallstricke. ParseWithClaims mit einer Keyfunc, Algorithmus auf HS256 gepinnt, Ablauf erzwingen:

    // internal/auth/verify.go — Token prüfen: Alg gepinnt, exp erzwungen
    package auth
    
    import (
    	"context"
    	"errors"
    
    	"github.com/golang-jwt/jwt/v5"
    )
    
    func VerifyAccessToken(secret []byte, raw string) (StaffClaims, error) {
    	claims := &StaffClaims{}
    	_, err := jwt.ParseWithClaims(raw, claims,
    		func(t *jwt.Token) (interface{}, error) { return secret, nil },
    		jwt.WithValidMethods([]string{"HS256"}), // vertraue NICHT dem alg aus dem Header
    		jwt.WithExpirationRequired(),            // v5-Option: fehlendes exp = Fehler
    	)
    	if err != nil {
    		switch {
    		case errors.Is(err, jwt.ErrTokenExpired):
    			return StaffClaims{}, errors.New("Token abgelaufen — Refresh fahren")
    		default:
    			return StaffClaims{}, errors.New("Token ungültig")
    		}
    	}
    	return *claims, nil
    }
    
    // Middleware-Anschluss (Gin, in der Nachfolge von Lektion 57):
    // claims, err := auth.VerifyAccessToken(secret, bearer)
    // → gültiges Token:  claims = {Role: admin, Subject: lena} → Request läuft durch
    // → abgelaufen:      401 {"error":"Token abgelaufen — Refresh fahren"}
    // → fremde Signatur: 401 {"error":"Token ungültig"}
    

    v5 validiert exp und nbf automatisch, sobald die Felder vorhanden sind — WithExpirationRequired schärft das nach: Fehlt exp komplett, wird das Token abgelehnt statt still akzeptiert. Kleine, teure Option.

    Drittens die Rotation, denn zustandslos heißt nicht ewig gültig. Das bewährte Muster kombiniert zwei Token-Arten: ein Access-Token mit Minuten-Haltbarkeit (oben: 15) und ein Refresh-Token mit Tagen, das serverseitig in der Datenbank liegt und dort widerrufen werden kann. Läuft das Access-Token ab, tauscht der Client das Refresh-Token gegen ein neues Paar — und der Server dreht dabei auch das Refresh-Token selbst (Rotation on use), sodass ein gestohlener Refresh nur bis zum nächsten Refresh lebt. Wird der Schlüssel selbst rotiert, hilft der kid-Header: Der Server veröffentlicht seine Schlüssel als JWKS (JSON Web Key Set) unter einer bekannten URL, Tokens nennen im Header ihre Schlüssel-ID, und alte Schlüssel bleiben für eine Übergangsfrist gültig. Mit HS256 (symmetrisch) muss jede prüfende Instanz das Geheimnis kennen — ist der Prüfer ein anderer Service, wechselt man auf RS256/EdDSA, wo nur der Aussteller den privaten Schlüssel hält.

    ⚠ Häufiger Fehler: Die Keyfunc so schreiben, dass sie blind das zurückgibt, was zum Header-Algorithmus passt — und jwt.WithValidMethods weglassen. Der Klassiker: Der Server signiert mit RS256, die Prüfung holt den öffentlichen Schlüssel; ein Angreifer fälscht den Header auf alg: HS256 und signiert das Token per HMAC mit eben diesem öffentlichen Schlüssel (der ja bekannt sein darf). Die Prüfung reicht ihn als HMAC-Geheimnis her und akzeptiert das gefälschte Token. Das ist die historische Alg-Confusion-Lücke mehrerer Frameworks. Passe die erlaubten Methoden immer explizit an — dann wehrt die Bibliothek den Header-Trick für dich ab.

    ✅ Wichtige Erkenntnisse

    Haken setzen, um deinen Lernfortschritt zu markieren:

      88

      OAuth2/OIDC-Flows mit golang.org/x/oauth2

      Lektion 88 von 100

      Kunden sollen sich mit ihrem Konto anmelden — nicht mit unserem Passwort-Speicher

      »Kant & Kurve« plant die Kunden-Plattform, und die Produktleitung stellt die vernünftige Frage: Warum sollen wir überhaupt Kunden-Passwörter speichern? Die Buchhandholds-Kooperative hat längst einen zentralen Identity Provider (IdP) — »Buchhaus ID«. Kunden melden sich dort an, und der Shop bekommt delegiert die Erlaubnis, sie zu erkennen. Das ist genau das Terrain von OAuth2 (Delegation von Zugriff) und OpenID Connect (OIDC, Authentifizierung des Nutzers), und in Go ist die Standard-Besetzung golang.org/x/oauth2 für die Flows plus github.com/coreos/go-oidc/v3/oidc für die ID-Token-Prüfung.

      Die Flow-Landschaft in drei Sätzen: Authorization Code mit PKCE ist der Standard-Flow für Web-Apps und SPAs — der Browser holt einen Code beim IdP, das Backend tauscht ihn gegen Tokens. Client Credentials ist der Flow von Service zu Service ohne Nutzer — der Buchhaltungs-Service holt sich selbst ein Token. Der Implicit Flow ist tot (OAuth 2.1 begräbt ihn endgültig), und auch der Password Grant ist aus der Mode: Beide haben historisch Tokens durch den Browser geschleust bzw. die Passwörter durch die App.

      OAuth2 delegiert, OIDC authentifiziert — verwechsle die Token nicht

      Das Access-Token ist der Schlüssel zu einer API: Es sagt nichts Verlässliches darüber, WER da handelt. Die Identität steht im ID-Token — einem JWT, das der IdP ausstellt und das gegen dessen öffentliche Schlüssel (JWKS) verifiziert werden muss. Wer das Access-Token einfach base64-dekodiert und die Claims als Identität liest, hat ein Token gelesen, das jede beliebige App für jeden beliebigen Nutzer hätte besorgen können.

      Der erste Block zeigt den Start des Authorization-Code-Flows inklusive der zwei Pflicht-Extras: state (CSRF-Schutz) und PKCE (Proof Key for Code Exchange, seit 2023 mit oauth2.GenerateVerifier und oauth2.S256ChallengeOption direkt in golang.org/x/oauth2 drin):

      // internal/idp/login.go — Redirect zum IdP: state + PKCE
      package idp
      
      import (
      	"crypto/rand"
      	"encoding/hex"
      	"net/http"
      
      	"golang.org/x/oauth2"
      )
      
      func Login(cfg oauth2.Config) http.HandlerFunc {
      	return func(w http.ResponseWriter, r *http.Request) {
      		// state: einmaliger Wert, in der Session gespeichert — prüfen wir im Callback
      		state := make([]byte, 16)
      		rand.Read(state)
      		stateHex := hex.EncodeToString(state)
      
      		verifier := oauth2.GenerateVerifier() // 43+ Zeichen, bleibt serverseitig
      
      		url := cfg.AuthCodeURL(stateHex,
      			oauth2.S256ChallengeOption(verifier)) // challenge im Query, Verifier geheim
      		http.Redirect(w, r, url, http.StatusFound)
      	}
      }
      
      // Terminal: curl -s -i localhost:8080/login | grep Location
      // → Location: https://idp.buchhaus.example/authorize?client_id=bookstore-shop
      // →   &redirect_uri=…&response_type=code&scope=openid+email&state=8f3a9c…
      // →   &code_challenge=YkQz…&code_challenge_method=S256
      

      Der Callback prüft den state, tauscht Code plus PKCE-Verifier gegen Tokens und verifiziert das ID-Token mit go-oidc:

      // internal/idp/callback.go — Code eintauschen, ID-Token verifizieren
      package idp
      
      import (
      	"context"
      	"net/http"
      
      	"github.com/coreos/go-oidc/v3/oidc"
      	"golang.org/x/oauth2"
      )
      
      func Callback(cfg oauth2.Config, provider *oidc.Provider, sessions SessionStore) http.HandlerFunc {
      	verifier := provider.Verifier(&oidc.Config{ClientID: cfg.ClientID})
      	return func(w http.ResponseWriter, r *http.Request) {
      		ctx := r.Context()
      
      		// 1. state gegen die Session prüfen — NICHT überspringen
      		if !sessions.CheckState(r, r.URL.Query().Get("state")) {
      			http.Error(w, "state stimmt nicht", http.StatusBadRequest)
      			return
      		}
      
      		// 2. Code + PKCE-Verifier gegen Tokens tauschen (Scope openid war Pflicht)
      		tok, err := cfg.Exchange(ctx, r.URL.Query().Get("code"),
      			oauth2.VerifierOption(sessions.PopVerifier(r)))
      		if err != nil {
      			http.Error(w, "Code-Austausch fehlgeschlagen", http.StatusBadGateway)
      			return
      		}
      
      		// 3. ID-Token verifizieren: Signatur gegen die JWKS des IdP, iss, aud, exp
      		rawIDToken, _ := tok.Extra("id_token").(string)
      		idToken, err := verifier.Verify(ctx, rawIDToken)
      		if err != nil {
      			http.Error(w, "ID-Token ungültig", http.StatusUnauthorized)
      			return
      		}
      		var user struct {
      			Email string `json:"email"`
      		}
      		idToken.Claims(&user) // jetzt, und erst jetzt: Identität
      		sessions.Login(w, r, user.Email)
      	}
      }
      
      // Terminal: Browser folgt dem Redirect, Nutzer meldet sich an, IdP leitet zurück
      // → GET /callback?code=abc123&state=8f3a9c… → 303 See Other, Cookie gesetzt
      // → Nutzer erkannt als: ada@buchhaus.example
      

      Für Service-zu-Service-Anmeldefälle gibt es den Client-Credentials-Flow — und hier zeigt golang.org/x/oauth2 seine bequemste Seite: Die TokenSource erneuert ablaufende Tokens automatisch, ohne dass der Aufrufer etwas davon merkt:

      // internal/billing/client.go — Client Credentials: Token-Beschaffung unsichtbar
      package billing
      
      import (
      	"context"
      	"fmt"
      	"net/http"
      
      	"golang.org/x/oauth2"
      	"golang.org/x/oauth2/clientcredentials"
      )
      
      func NewClient(ctx context.Context, cfg clientcredentials.Config) *http.Client {
      	// TokenSource holt, cached und erneuert Tokens — inklusive Retry auf 401
      	return oauth2.NewClient(ctx, cfg.TokenSource(ctx))
      }
      
      // Terminal: Billing-Service ruft die Buchungs-API auf
      // → GET /v1/invoices → 200 (Token-Beschaffung + Refresh liefen automatisch mit)
      // → Debug-Log: oauth2: token expired, refreshing (passiert genau einmal, still)
      

      Wo AuthN endet und AuthZ beginnt, wie Schichten von Authentifizierung und Berechtigung übereinandergelegt werden und was innerhalb einer Trust-Boundary noch geprüft werden muss — das ist Architektur-Terrain, behandelt in Modul 9 des Architektur-Kurses. Der Go-Teil hier liefert die Bausteine: verifiziertes ID-Token für AuthN, Claims im Access-Token für AuthZ.

      ⚠ Häufiger Fehler: Den Callback ohne state-Gegenprobe implementieren, weil der IdP ja der einzige ist, der redirected. Login-CSRF funktioniert trotzdem: Der Angreifer loggt sich selbst beim IdP ein, fängt den Callback-Code ab und lockt das Opfer auf die vollständige Callback-URL — das Opfer landet in einer Session, die dem Angreifer gehört (Session-Fixation-Variante). Die state-Prüfung ist zwei Zeilen: Wert vor dem Redirect erzeugen und in der Session ablegen, im Callback gegen den Query-Parameter vergleichen. In dem Code oben ist sie Schritt 1 — bewusst vor dem Token-Austausch.

      ✅ Wichtige Erkenntnisse

      Haken setzen, um deinen Lernfortschritt zu markieren:

        89

        Secrets-Management: Vault, SOPS & Env-Fallstricke

        Lektion 89 von 100

        Der Audit-Befund, der alles dreht: das Passwort liegt in der Git-History

        Befund 1 des Pentest-Berichts ist der peinlichste: Eine frühe Version der Buchhaltung hat ein .env mit dem PostgreSQL-Passwort ins Repo committet — vor zwei Jahren, gelöscht nach drei Wochen, aber in der Git-History unsterblich. Befund 2 direkt dahinter: dasselbe Passwort steht als Umgebungsvariable im Deployment und erscheint wortwörtlich in docker inspect. Die Konsequenz des Betriebs: alle Secrets rotieren, und ein System her, das Rotation, Audit und Verteilung ernst nimmt.

        Zuerst die ehrliche Einordnung der Umgebungsvariablen, denn die 12-Factor-App predigt sie ja: Für KONFIGURATION (Ports, Log-Level, Feature-Flags) ist env genau richtig — nicht geheim, nicht kritisch. Für SECRETS kippt die Rechnung: Env-Variablen sind an den Prozess gefesselt und damit in /proc/PID/environ lesbar für jeden mit Shell-Zugriff auf dem Host, sie werden an Kind-Prozesse vererbt (auch an die, die sie nie brauchten), sie landen in Crash-Dumps, in docker inspect, in Support-Tickets mit Copy-paste aus env. Und: Es gibt kein Audit-Log, wer ein Secret wann gelesen hat, und keine Rotation ohne Neustart des Prozesses.

        Ein Secret-Manager macht Secrets zu Leihgaben

        Systeme wie HashiCorp Vault drehen das Besitzverhältnis um: Der Service besitzt kein Passwort mehr, er LEIHT sich eins — mit eigener Identität (AppRole, Kubernetes-Service-Account), für begrenzte Zeit, jeden Zugriff protokolliert. Dynamische Datenbank-Credentials, die Vault pro Lease erzeugt, machen Rotation zum Dauerzustand statt zum quartalsweisen Großeinsatz: Läuft die Lease ab, holt der Service frische Credentials, das alte Passwort existiert schlicht nicht mehr.

        Der Go-Zugriff auf Vault geht über github.com/hashicorp/vault/api — hier mit AppRole-Login und einem KV-v2-Read:

        // internal/secrets/vault.go — AppRole-Login und KV-v2-Read
        package secrets
        
        import (
        	"context"
        	"fmt"
        
        	"github.com/hashicorp/vault/api"
        )
        
        func DatabasePassword(ctx context.Context, cfg Config) (string, error) {
        	client, err := api.NewClient(&api.Config{Address: cfg.Address})
        	if err != nil {
        		return "", err
        	}
        	// Der Service authentifiziert sich SELBST — keine Menschen-Creds im Code
        	login, err := client.Logical().Write("auth/approle/login", map[string]interface{}{
        		"role_id":   cfg.RoleID,
        		"secret_id": cfg.SecretID,
        	})
        	if err != nil {
        		return "", fmt.Errorf("approle-login: %w", err)
        	}
        	client.SetToken(login.Auth.ClientToken)
        
        	// KV v2: der Pfad enthält /data/ — häufiger Stolperer beim Migrieren von v1
        	secret, err := client.Logical().Read("secret/data/bookstore/postgres")
        	if err != nil {
        		return "", err
        	}
        	data, _ := secret.Data["data"].(map[string]interface{})
        	pw, _ := data["password"].(string)
        	if pw == "" {
        		return "", fmt.Errorf("secret leer oder Pfad falsch")
        	}
        	return pw, nil
        }
        
        // Terminal: bookstore serve (Startup)
        // → approle-login: ok (lease 2764800s) — read secret/data/bookstore/postgres ok
        // → postgres-Passwort geladen: 32 Zeichen, aus Vault, niemals in einer Datei
        

        Für Werte, die mit im Repo leben müssen (Pipeline-Konfiguration, TLS-Zertifikate kleiner Umgebungen), ist SOPS (github.com/getsops/sops, seit dem Mozilla-Handover bei GetSops gepflegt) das etablierte Werkzeug: Die Datei bleibt im Git, aber nur die WERTETE sind verschlüsselt — mit age-Schlüsseln oder Cloud-KMS. Die Struktur bleibt diff-bar, Merge-Konflikte bleiben lesbar, und das Review sieht, WELCHE Schlüssel sich ändern, nur nicht womit:

        // Terminal: Workflow mit SOPS + age (Struktur im Repo, Werte verschlüsselt)
        // → $ sops --encrypt --age age1… config/secrets.yaml > config/secrets.enc.yaml
        // → $ git diff config/secrets.enc.yaml
        // →   bookstore:
        // → -    password: ENC[AES256_GCM,data:kQ9f…,tag:…]
        // → +    password: ENC[AES256_GCM,data:7mP2…,tag:…]
        // → $ sops --decrypt config/secrets.enc.yaml | bookstore seed   (Pipeline injiziert)
        

        Und noch eine Go-seitige Härtung, die der Pentester ausdrücklich lobt: ein eigener Secret-Typ, der sich beim Loggen selbst schwärzt. Das Struct aus Lektion 59 wird ergänzt — und slog respektiert über LogValue die Rotstift-Logik automatisch:

        // internal/config/secret.go — Secrets, die nicht loggen können
        package config
        
        import (
        	"log/slog"
        	"os"
        )
        
        type Secret string
        
        func (s Secret) LogValue() slog.Value {
        	return slog.StringValue("[REDACTED]") // gilt für Info, Warn, Error …
        }
        
        func DbPasswordFromEnv() (Secret, error) {
        	v, ok := os.LookupEnv("BOOKSTORE_DB_PASSWORD") // runtime-injiziert, nie im Image
        	if !ok || v == "" {
        		return "", ErrMissingSecret // fail-fast statt leerem String durch die Gegend
        	}
        	return Secret(v), nil
        }
        
        // Terminal: bookstore serve
        // → {"level":"INFO","msg":"config geladen","addr":":8080","db_password":"[REDACTED]"}
        // → (statt wie zuvor: "db_password":"pgSuperSecret2024" — Befund 2 aus dem Report)
        

        ⚠ Häufiger Fehler: Beim Startup-Schwafeln das ganze Config-Struct ins Log kippen — logger.Info("starte", "cfg", cfg) — und sich wundern, warum das Token im Logstream landet. JSON-Handler serialisieren jedes exportierte Feld; Stringer-Panik gibt es nicht, nur Klartext. Die Abhilfe ist die Disziplin oben: Secrets in einen eigenen Typ, der per LogValue nur [REDACTED] von sich gibt, und Einzel-Felder loggen statt der Formatierung ganzer Structs. In Kubernetes kommt dieselbe Disziplin bei Pod-Events und Fehlermeldungen zum Zug.

        ✅ Wichtige Erkenntnisse

        Haken setzen, um deinen Lernfortschritt zu markieren:

          90

          Supply Chain: govulncheck, GOPRIVATE & SBOM

          Lektion 90 von 100

          Eine CVE-Mail am Freitag, 16:55 Uhr

          Die Mail kommt vom Sicherheitsteam der Kooperative: In einem YAML-Parser, drei Ebenen tief in den Abhängigkeiten der Bookstore-API, ist eine Remote-Code-Execution gemeldet. Fragen in drei Richtungen: Sind wir betroffen (erreicht unser Code die verwundbare Stelle überhaupt)? Und gleich daneben ein zweites Problem: Die Build-Pipeline bricht seit dem neuen internen Modul git.corp.example.com/buchhaus/lager ab — die Checksummen-Datenbank kennt interne Module nicht, und ein Kollege schlägt schon vor, halt global GOSUMDB=off zu setzen. Beides heute: geliefert.

          Der Held der ersten Frage ist govulncheck (golang.org/x/vuln/cmd/govulncheck) — das offizielle Vulnerability-Scanner-Tool der Go-Welt. Sein Unterschied zu CVE-Grep-Scannern (die go.sum durchsuchen) ist der Call-Graph: govulncheck analysiert, ob dein Code die verwundbaren SYMBOLE tatsächlich aufruft. Ein CVE in einer Funktion, die du nie erreichst, ist kein akuter Befund — das Filtern spart wochenweise Panik-Upgrades:

          // Terminal: govulncheck — Installation und Lauf
          // → $ go install golang.org/x/vuln/cmd/govulncheck@latest
          // → $ govulncheck ./...
          // → === Symbol Results ===
          // → Vulnerability #1: GO-2026-1234 in gopkg.in/yaml.v3
          // →     Call stacks in your code:
          // →     #1: internal/pricing.loadRules → yaml.Unmarshal → …Decoder.Decode
          // →     Found in: gopkg.in/yaml.v3@v3.0.0
          // →     Fixed in: gopkg.in/yaml.v3@v3.0.1
          // → Your code is affected by 1 vulnerability.
          // →
          // → (Ein zweiter Treffer aus go.sum — im Encode-Pfad des Parsers — taucht NICHT auf: nicht erreichbar)
          

          Das zweite Problem, interne Module: go mod tidy scheitert, weil das Modul weder im Proxy noch in der Checksummen-Datenbank (sum.golang.org) existieren kann — es ist ja privat. Die richtige Antwort ist GOPRIVATE, das den privaten Namensraum an beiden Stellen ausnimmt — vom Proxy UND von der Checksummen-Prüfung — während alle öffentlichen Module weiter verifiziert werden:

          // Terminal: GOPRIVATE statt GOSUMDB=off
          // → $ go env -w GOPRIVATE=git.corp.example.com/*
          // → $ git config --global url."https://oauth2:$GITLAB_TOKEN@git.corp.example.com".insteadOf "https://git.corp.example.com"
          // → $ go mod tidy
          // → go: downloading git.corp.example.com/buchhaus/lager v1.4.2 (direkt vom Git, ohne Proxy)
          // → go: verified github.com/gin-gonic/gin@v1.10.0 against sum.golang.org   (weiterhin geprüft!)
          // → $ go env GOPRIVATE
          // → git.corp.example.com/*
          

          Der Unterschied zum Kollegen-Vorschlag ist Sicherheits-relevant: GOSUMDB=off global schaltet die Signatur-Prüfung für ALLE Module ab — ein kompromittierter Mirror könnte dir ab da unbemerkt veränderte Public-Pakete unterschieben. GOPRIVATE begrenzt die Ausnahme auf den privaten Namensraum und ist zugleich der Default für GONOPROXY und GONOSUMDB; feinjustieren kannst du mit den beiden einzeln.

          Drittens die Inventar-Frage: Ein Großkunde der Kooperative verlangt für seine Ausschreibung eine SBOM (Software Bill of Materials) — ein maschinenlesbares Inhaltsverzeichnis aller Abhängigkeiten samt Versionen und Lizenzen. In der Go-Welt erzeugen das z. B. syft (github.com/anchore/syft) als SPDX- oder CycloneDX-Dokument; cosign (Sigstore) kann es zusätzlich signieren und attestieren. Und das Beste: Go-Binaries tragen ihr eigenes Inventar — eingebettet via runtime/debug, abfragbar ohne die Original-Builds:

          // cmd/bookstore/version.go — das Binary kennt seine eigenen Abhängigkeiten
          package main
          
          import (
          	"fmt"
          	"runtime/debug"
          )
          
          func printSBOM() {
          	bi, ok := debug.ReadBuildInfo()
          	if !ok {
          		return // go run statt go build — keine Build-Info vorhanden
          	}
          	fmt.Println("module:", bi.Main.Path, bi.Main.Version)
          	for _, d := range bi.Deps {
          		extra := ""
          		if d.Replace != nil {
          			extra = " (replace → " + d.Replace.Path + " " + d.Replace.Version + ")"
          		}
          		fmt.Println("  dep:", d.Path, d.Version+extra)
          	}
          }
          
          // Terminal: bookstore version
          // → module: bookshop.example/kant-kurve v1.8.3
          // →   dep: github.com/gin-gonic/gin v1.10.0
          // →   dep: github.com/jackc/pgx/v5 v5.7.1
          // →   dep: gopkg.in/yaml.v3 v3.0.1        (der Fix aus Befund 1 — angekommen)
          //
          // Terminal: syft scan . -o spdx-json > sbom.spdx.json && wc -l sbom.spdx.json
          // → 412 sbom.spdx.json — unterschrieben per cosign attest, angehängt ans Image
          

          Supply Chain ist Inventory plus Verifikation plus Erreichbarkeit

          Die drei Werkzeuge der Lektion decken drei Fragen ab: go.sum (plus sum.golang.org) verifiziert, DASS ein Modul unverändert ist — GOPRIVATE ausgenommen nur, was der Namensraum hergibt. govulncheck beantwortet, OB eine bekannte Schwachstelle für dich RELEVANT ist. Die SBOM beantwortet, WAS überhaupt in dir drinsteckt — die Voraussetzung, um bei der nächsten CVE-Mail am Freitag in Minuten statt Tagen zu antworten. Alle drei zusammen, automatisiert in CI: govulncheck ./... im Nightly, SBOM-Attest pro Release-Tag.

          ⚠ Häufiger Fehler: Weil der Build an einem privaten Modul hängt, GOSUMDB=off (und oft gleich GOFLAGS=-insecure dazu) global setzen — auf dem Entwicklungsrechner UND im CI-Runner. Damit entfällt die Checksummen-Verifikation für jedes öffentliche Modul aller Projekte auf dieser Maschine: Der nächste go get vertraut blind dem Proxy-Mirror. Der Kollege meint es gut, aber die Lösung ist punktgenau statt flächendeckend: GOPRIVATE=git.corp.example.com/* genau für den privaten Namensraum, öffentliche Abhängigkeiten bleiben signatur-geprüft.

          ✅ Wichtige Erkenntnisse

          Haken setzen, um deinen Lernfortschritt zu markieren:

            This site uses essential cookies for Stripe payments. No tracking cookies.