Zum Inhalt springen
Trainingslager IT-Trainingslager

Anhang B: Abschlussprüfung

Ziel: Nachweisen, dass du ein Go-Tool allein von der Spezifikation bis zum grünen Prüfskript baust und die Konzepte erklären kannst · Dauer: 120 min Praxis + 20 min Fragen · Voraussetzung: Tag 15

Regeln

  • Go 1.26, golangci-lint per ~/go-lab/bin/lint (Tag 0), Ollama wird nicht gebraucht. Nur Standardbibliothek.
  • Erlaubt: go doc, Anhang A, go.dev. Nicht erlaubt: Code aus den Kapiteln kopieren oder die Musterlösung am Ende dieses Anhangs vor Ablauf der Zeit lesen.
  • Die vorgegebenen Tests und das Prüfskript werden nicht verändert.
  • Bestanden: Teil 1 mindestens 70 von 100 Punkten und Teil 2 mindestens 18 von 25.

Teil 1: Praktische Prüfung – secretscan

Baue secretscan, ein CLI, das einen Ordner nach versehentlich eingecheckten Secrets durchsucht – den Scanner, den du vor llm-commit (Tag 15) laufen lassen würdest.

Spezifikation

  • Modul example.com/secretscan in ~/go-lab/pruefung-secretscan, Paket internal/scan, Kommando cmd/secretscan.
  • Regeln (Name: Muster):
    • aws-access-key: AKIA plus 16 Großbuchstaben/Ziffern, als ganzes Wort
    • github-token: ghp_, gho_, ghu_, ghs_ oder ghr_ plus 36 Buchstaben/Ziffern, als ganzes Wort
    • private-key: -----BEGIN … PRIVATE KEY----- (beliebige Großbuchstaben und Leerzeichen dazwischen)
    • api-key: sk- plus mindestens 20 Zeichen aus Buchstaben, Ziffern, _ und -
  • scan.Line(line) liefert die Treffer einer Zeile ([]scan.Finding, nur Rule und Match gesetzt), sortiert nach Position. Enthält die Zeile secretscan:ignore, gibt es keine Treffer.
  • scan.Mask(s) zeigt die ersten vier Zeichen, … und die Länge in Zeichen: AKIA…(20); bei höchstens vier Zeichen nur …(3). Nie das ganze Secret ausgeben.
  • scan.File(path) prüft eine Datei Zeile für Zeile (Zeilennummern ab 1). Dateien mit einem NUL-Byte in den ersten 512 Byte gelten als binär und liefern nichts.
  • scan.Dir(ctx, root, workers) durchsucht root rekursiv mit workers Goroutines, überspringt die Ordner .git, node_modules und vendor sowie Dateien über 1 MiB und Nicht-Dateien (Symlinks …). Finding.File ist relativ zu root mit /; Ergebnis sortiert nach Datei und Zeile, gleich für 1 und 8 Worker. Abgebrochener ctx liefert context.Canceled, fehlender Ordner os.ErrNotExist.
  • scan.Finding hat die JSON-Namen file, line, rule, match.
  • CLI: secretscan [-w N] [-json] ORDNER. Text: eine Zeile datei:zeile: regel maske pro Treffer, zuletzt N Treffer. JSON: ein Array (leer: [], nie null). Exit 0 = nichts gefunden, 1 = Treffer, 2 = falscher Aufruf oder Lesefehler.

Vorgegebene Tests

mkdir -p ~/go-lab/pruefung-secretscan/{cmd/secretscan,internal/scan}
cd ~/go-lab/pruefung-secretscan
go mod init example.com/secretscan
printf 'version: "2"\nlinters:\n  exclusions:\n    presets: [%s]\n' \
  std-error-handling > .golangci.yml
cat > internal/scan/scan_test.go <<'EOF'
package scan

import (
    "context"
    "errors"
    "os"
    "path/filepath"
    "reflect"
    "strings"
    "testing"
)

// Lab-Werte, zusammengesetzt, damit dieser Test selbst keinen Treffer liefert.
var (
    awsKey = "AKIA" + "LABEXAMPLE000000"
    ghTok  = "ghp_" + strings.Repeat("a", 36)
    pemKey = "-----BEGIN " + "RSA PRIVATE KEY-----"
    skKey  = "sk-" + "lab-master-1234567890"
)

func TestLine(t *testing.T) {
    tests := []struct {
        line string
        want []string // Regeln
    }{
        {"aws_key = " + awsKey, []string{"aws-access-key"}},
        {"token: " + ghTok, []string{"github-token"}},
        {pemKey, []string{"private-key"}},
        {`OPENAI_API_KEY="` + skKey + `"`, []string{"api-key"}},
        {awsKey + " " + ghTok, []string{"aws-access-key", "github-token"}},
        {"aws_key = " + awsKey + " // secretscan:ignore", nil},
        {"AKIA zu kurz, ghp_kurz, sk-x", nil},
    }
    for _, tt := range tests {
        var got []string
        for _, f := range Line(tt.line) {
            got = append(got, f.Rule)
        }
        if !reflect.DeepEqual(got, tt.want) {
            t.Errorf("Line(%q) = %v, will %v", tt.line, got, tt.want)
        }
    }
}

func TestMask(t *testing.T) {
    if got := Mask(awsKey); got != "AKIA…(20)" {
        t.Errorf("Mask = %q", got)
    }
    if got := Mask("abc"); got != "…(3)" {
        t.Errorf("Mask(kurz) = %q", got)
    }
}

func write(t *testing.T, root, name, content string) {
    t.Helper()
    p := filepath.Join(root, name)
    if err := os.MkdirAll(filepath.Dir(p), 0o755); err != nil {
        t.Fatal(err)
    }
    if err := os.WriteFile(p, []byte(content), 0o644); err != nil {
        t.Fatal(err)
    }
}

func TestDir(t *testing.T) {
    root := t.TempDir()
    write(t, root, "app/config.yaml", "user: lab\ntoken: "+ghTok+"\n")
    write(t, root, "deploy/.env", "A=1\nAWS_KEY="+awsKey+"\nB=2\n")
    write(t, root, "keys/id_rsa", pemKey+"\nMIIE...\n")
    write(t, root, ".git/config", "token: "+ghTok+"\n") // übersprungen
    write(t, root, "bin/tool", "\x00\x01"+awsKey)       // binär
    write(t, root, "ok.txt", "nichts\n"+awsKey+" secretscan:ignore\n")
    for _, workers := range []int{1, 8} {
        got, err := Dir(context.Background(), root, workers)
        if err != nil {
            t.Fatal(err)
        }
        want := []Finding{
            {File: "app/config.yaml", Line: 2, Rule: "github-token",
                Match: "ghp_…(40)"},
            {File: "deploy/.env", Line: 2, Rule: "aws-access-key",
                Match: "AKIA…(20)"},
            {File: "keys/id_rsa", Line: 1, Rule: "private-key",
                Match: "----…(31)"},
        }
        if !reflect.DeepEqual(got, want) {
            t.Errorf("workers=%d:\n got %+v\nwant %+v", workers, got, want)
        }
    }
}

func TestDirFehler(t *testing.T) {
    _, err := Dir(context.Background(), "/gibt/es/nicht", 2)
    if !errors.Is(err, os.ErrNotExist) {
        t.Errorf("err = %v", err)
    }
    ctx, cancel := context.WithCancel(context.Background())
    cancel()
    if _, err := Dir(ctx, t.TempDir(), 2); !errors.Is(err, context.Canceled) {
        t.Errorf("err = %v, will context.Canceled", err)
    }
}
EOF
cat > cmd/secretscan/main_test.go <<'EOF'
package main

import (
    "bytes"
    "context"
    "encoding/json"
    "os"
    "path/filepath"
    "strings"
    "testing"
)

func TestRun(t *testing.T) {
    clean, dirty := t.TempDir(), t.TempDir()
    key := "AKIA" + "LABEXAMPLE000000" // Lab-Wert
    err := os.WriteFile(filepath.Join(dirty, "x.env"), []byte("K="+key+"\n"), 0o600)
    if err != nil {
        t.Fatal(err)
    }
    tests := []struct {
        name string
        args []string
        code int
        out  string
    }{
        {"sauber", []string{clean}, 0, "0 Treffer\n"},
        {"Treffer", []string{dirty}, 1,
            "x.env:1: aws-access-key AKIA…(20)\n1 Treffer\n"},
        {"ohne Ordner", nil, 2, ""},
        {"fehlt", []string{"/gibt/es/nicht"}, 2, ""},
        {"falsches Flag", []string{"-x", clean}, 2, ""},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            var out, errOut bytes.Buffer
            code := run(context.Background(), tt.args, &out, &errOut)
            if code != tt.code || out.String() != tt.out {
                t.Errorf("Exit %d, Ausgabe %q; will %d, %q (stderr %q)",
                    code, out.String(), tt.code, tt.out, errOut.String())
            }
        })
    }
}

func TestRunJSON(t *testing.T) {
    dir := t.TempDir()
    pem := "-----BEGIN " + "EC PRIVATE KEY-----\n"
    err := os.WriteFile(filepath.Join(dir, "k.pem"), []byte(pem), 0o600)
    if err != nil {
        t.Fatal(err)
    }
    var out bytes.Buffer
    code := run(context.Background(), []string{"-json", dir}, &out, &out)
    if code != 1 {
        t.Fatalf("Exit %d", code)
    }
    var got []map[string]any
    if err := json.Unmarshal(out.Bytes(), &got); err != nil {
        t.Fatalf("kein JSON: %v\n%s", err, out.String())
    }
    if len(got) != 1 || got[0]["rule"] != "private-key" || got[0]["line"] != 1.0 ||
        strings.Contains(out.String(), "PRIVATE KEY") {
        t.Errorf("JSON = %s", out.String())
    }
}
EOF
date +%s > .start

Die Secrets in den Tests sind Lab-Werte und werden zur Laufzeit zusammengesetzt – so meldet weder dein eigener Scanner noch ein Scanner deines Git-Hosters die Testdatei.

Prüfskript

cat > pruefe.sh <<'EOF'
#!/usr/bin/env bash
# pruefe.sh – bewertet die Abschlussprüfung (Lab-Secrets, nur zum Testen)
cd "$(dirname "$0")" || exit 2
pts=0
check() { # check PUNKTE NAME BEFEHL
  if eval "$3" >/dev/null 2>&1; then echo "✔ $1 P  $2"; pts=$((pts + $1))
  else echo "✘ 0 P  $2"; fi
}
fx=$(mktemp -d)
mkdir -p "$fx/app" "$fx/.git" "$fx/bin"
printf 'token: ghp_%s\n' "$(printf 'b%.0s' {1..36})" > "$fx/app/config.yaml"
printf 'A=1\nAWS_KEY=AKIA%s\n' LABEXAMPLE000000 > "$fx/app/.env"
printf 'K=AKIA%s # secretscan:ignore\n' LABEXAMPLE000000 > "$fx/ok.env"
printf 'token: ghp_%s\n' "$(printf 'c%.0s' {1..36})" > "$fx/.git/config"
printf '\0\1AKIA%s' LABEXAMPLE000000 > "$fx/bin/tool"
rm -f bin/secretscan; go build -o bin/secretscan ./cmd/secretscan 2>/dev/null
out=$(./bin/secretscan "$fx" 2>/dev/null); code=$?

check 10 "gofmt sauber" 'test -z "$(gofmt -l .)"'
check 10 "go vet + golangci-lint" "go vet ./... && ~/go-lab/bin/lint run ./..."
check 20 "Tests grün mit -race" "go test -race -count=1 ./..."
check 10 "Exit 1 bei Treffern" "test $code -eq 1"
check 10 "genau 2 Treffer" "tail -1 <<<\"\$out\" | grep -qx '2 Treffer'"
check 10 "Secrets maskiert" "test $code -eq 1 && ! grep -q LABEXAMPLE <<<\"\$out\""
check 10 ".git, Binär, ignore übersprungen" \
  "test $code -eq 1 && ! grep -qE '^(\.git|bin/|ok\.env)' <<<\"\$out\""
check 10 "JSON gültig" "./bin/secretscan -json '$fx' | jq -e 'length == 2'"
check 5 "Exit 0 ohne Treffer" "./bin/secretscan cmd"
check 5 "Exit 2 ohne Ordner" "./bin/secretscan; test \$? -eq 2"
rm -rf "$fx"
echo "Punkte: $pts von 100"
EOF
chmod +x pruefe.sh

Starte es, sooft du willst; es baut das Tool, legt einen Ordner mit Lab-Secrets an, prüft und räumt auf. Nach 120 Minuten zählt der letzte Lauf:

./pruefe.sh; echo "Zeit: $(( ($(date +%s) - $(cat .start)) / 60 )) min"

Erwartet vor der ersten Codezeile (gekürzt):

✔ 10 P  gofmt sauber
✘ 0 P  go vet + golangci-lint
✘ 0 P  Tests grün mit -race
…
✘ 0 P  Exit 2 ohne Ordner
Punkte: 10 von 100

Punkte

Prüfung Punkte erreicht
gofmt sauber 10
go vet + golangci-lint 10
Tests grün mit -race 20
Exit 1 bei Treffern 10
genau 2 Treffer im Prüfordner 10
Secrets maskiert 10
.git, Binärdatei, secretscan:ignore übersprungen 10
JSON gültig 10
Exit 0 ohne Treffer 5
Exit 2 ohne Ordner 5
Summe 100

Teil 2: Kurzfragen

Je 1 Punkt, Bestehensgrenze 18 von 25. Antworte in ein bis zwei Sätzen, ohne nachzuschlagen.

  1. Was ist der Unterschied zwischen len("Grüße") und utf8.RuneCountInString("Grüße"), und was liefert range über einen String?
  2. Warum musst du das Ergebnis von append immer wieder zuweisen?
  3. Was passiert beim Lesen aus und beim Schreiben in eine nil-Map?
  4. Wann nimmst du einen Pointer-Receiver statt eines Wert-Receivers?
  5. Wie erfüllt ein Typ in Go ein Interface, und wozu dient var _ Parser = JSON{}?
  6. Was ist der Unterschied zwischen %w und %v in fmt.Errorf?
  7. Wann nimmst du errors.Is, wann errors.As bzw. errors.AsType?
  8. Warum gehört die Logik eines CLIs in run(...) und nicht in main?
  9. Was bedeuten die Exit-Codes 0, 1 und 2 in diesem Buch?
  10. Was prüft go test -race, und warum lohnt es sich auch bei Tests ohne sichtbare Fehler?
  11. Was ist ein Table-Driven Test, und was bringt t.Run?
  12. Wozu dienen t.Helper() und t.Cleanup()?
  13. Was macht ein Fuzz-Test, und wo landen gefundene Fehler?
  14. Warum ist for b.Loop() besser als for i := 0; i < b.N; i++?
  15. Was ist der Unterschied zwischen http.Client.Timeout und einem Context mit Timeout?
  16. Warum muss resp.Body immer geschlossen werden?
  17. Bei welchen HTTP-Antworten ist ein Retry sinnvoll, bei welchen nicht?
  18. Wie beendet sich ein http.Server sauber, wenn Kubernetes den Pod stoppt?
  19. Warum darf ein Worker-Pool ohne Lock in results[i] schreiben, aber nicht per append in ein gemeinsames Slice?
  20. Was bewirken errgroup.WithContext und g.SetLimit(4)?
  21. Was passiert in einem select mit einem nil-Channel?
  22. Was ist der Unterschied zwischen go.mod und go.sum, und was macht go mod tidy -diff?
  23. Wie baust du auf dem Mac ein statisches Linux-Binary für arm64 mit eingebauter Version?
  24. Wie testest du Code, der mit der Kubernetes-API oder einem LLM spricht, ohne Cluster und ohne Modell?
  25. Warum prüft llm-commit die Antwort des Modells mit Code, statt dem Prompt zu vertrauen?

Lösungsschlüssel

  1. len zählt Bytes (7), RuneCountInString Zeichen (5); range liefert Byte-Index und Rune.
  2. Reicht die Kapazität nicht, legt append ein neues Array an und gibt einen neuen Slice-Header zurück; der alte zeigt weiter auf das alte Array.
  3. Lesen liefert den Nullwert (und ok == false), Schreiben löst eine Panic aus.
  4. Wenn die Methode den Wert ändert, der Typ groß ist oder einen Mutex enthält; innerhalb eines Typs einheitlich bleiben.
  5. Implizit, sobald alle Methoden vorhanden sind; die Zuweisung lässt den Compiler das prüfen, ohne Laufzeitkosten.
  6. %w hängt den Fehler in die Kette ein (prüfbar mit errors.Is/As), %v übernimmt nur den Text.
  7. errors.Is vergleicht mit einem bestimmten Wert (Sentinel), errors.As/AsType sucht einen Typ in der Kette und gibt ihn mit seinen Feldern heraus.
  8. run bekommt Argumente, Ein- und Ausgaben als Parameter und gibt einen Exit-Code zurück – damit ist das ganze Tool ohne Prozessstart testbar; main ruft nur os.Exit(run(...)).
  9. 0 = alles in Ordnung, 1 = Fehler oder Funde bei der Arbeit, 2 = falscher Aufruf oder unbrauchbare Konfiguration.
  10. Gleichzeitige Zugriffe auf denselben Speicher ohne Synchronisation; Data Races fallen oft erst unter Last auf und liefern dann still falsche Werte.
  11. Ein Slice von Testfällen mit einer Schleife; t.Run macht daraus benannte Subtests, die einzeln laufen (-run Test/fall) und einzeln fehlschlagen.
  12. t.Helper() lässt Fehlermeldungen auf die Zeile des Aufrufers zeigen, t.Cleanup() registriert Aufräumarbeit, die nach dem Test sicher läuft.
  13. Er erzeugt aus Seeds neue Eingaben und prüft Eigenschaften; ein Fund wird nach testdata/fuzz/<Name>/ geschrieben und läuft danach bei jedem go test mit.
  14. Setup vor der Schleife zählt nicht mit, und der Compiler darf den gemessenen Aufruf nicht wegoptimieren (seit Go 1.24).
  15. Client.Timeout begrenzt einen einzelnen Request, der Context das Gesamtbudget inklusive Retries und Wartezeiten – und lässt sich von außen abbrechen.
  16. Sonst bleibt die Verbindung belegt und kann nicht wiederverwendet werden; auf Dauer gehen Dateideskriptoren oder Verbindungen aus.
  17. Sinnvoll bei 429, 5xx und Netzfehlern (mit Backoff, Retry-After beachten); nicht bei anderen 4xx und nicht bei abgelaufenem Context; nur für idempotente Anfragen.
  18. Auf SIGTERM per signal.NotifyContext reagieren und srv.Shutdown(ctx) mit Frist aufrufen: keine neuen Verbindungen, laufende Requests dürfen fertig werden.
  19. Jeder Index wird von genau einer Goroutine geschrieben und wg.Wait() sorgt für Sichtbarkeit; append ändert den gemeinsamen Slice-Header und ist damit ein Data Race.
  20. Der erste Fehler bricht den abgeleiteten Context für alle anderen ab, Wait liefert diesen Fehler; SetLimit lässt g.Go blockieren, solange schon 4 Goroutines laufen.
  21. Ein nil-Channel ist nie bereit – der Fall wird im select praktisch abgeschaltet.
  22. go.mod nennt Modul, Go-Version und benötigte Versionen, go.sum die Prüfsummen; tidy -diff zeigt nur, ob tidy etwas ändern würde (CI-Gate).
  23. GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -trimpath -ldflags "-s -w -X main.version=1.2.3" -o tool ./cmd/tool.
  24. Gegen Fakes: fake.NewClientset für client-go, httptest.Server für HTTP-APIs wie die LLM-Schnittstelle; die Logik bekommt Interfaces oder Funktionen injiziert.
  25. Modelle halten Formatregeln nicht zuverlässig ein; Code prüft deterministisch, und der Fehler geht als Rückmeldung für einen neuen Versuch zurück ans Modell.

Teil 3: Selbsteinschätzung

Thema kann ich im Lab gemacht
Toolchain, Modul, -ldflags, Linter (Tag 0) [ ] [ ]
Slices, Maps, Runen, bufio (Tag 1) [ ] [ ]
Structs, Methoden, Interfaces, Pakete (Tag 2) [ ] [ ]
Fehler, Wrapping, Module (Tag 3) [ ] [ ]
Table-Tests, Golden Files, Fuzzing, Benchmarks (Tag 4) [ ] [ ]
flag, cobra, Config, os/exec (Tag 5) [ ] [ ]
Dateien, JSON, YAML (Tag 6) [ ] [ ]
HTTP-Client, context, Retries (Tag 7) [ ] [ ]
Goroutines, Channels, Worker-Pool, errgroup (Tag 8) [ ] [ ]
HTTP-Server, Middleware, slog, Shutdown (Tag 9) [ ] [ ]
database/sql mit SQLite (Tag 10) [ ] [ ]
client-go, Informer, Fake-Clientset (Tag 11) [ ] [ ]
LLM per HTTP, Streaming, Tools, MCP (Tag 12) [ ] [ ]
Generics, Iteratoren, pprof (Tag 13) [ ] [ ]
Cross-Compile, GoReleaser, CI (Tag 14) [ ] [ ]
Tools nach Spezifikation unter Zeitdruck (Tag 15) [ ] [ ]

Jede Zeile ohne zwei Kreuze: das Kapitel noch einmal durcharbeiten – das Tool des Tages neu schreiben, ohne ins Buch zu schauen.

Musterlösung zu Teil 1

Erst lesen, wenn die 120 Minuten um sind.

cd ~/go-lab/pruefung-secretscan
cat > internal/scan/scan.go <<'EOF'
// Package scan sucht Secrets in Textdateien.
package scan

import (
    "bufio"
    "bytes"
    "cmp"
    "context"
    "errors"
    "fmt"
    "io/fs"
    "os"
    "path/filepath"
    "regexp"
    "slices"
    "strings"
    "sync"
    "unicode/utf8"
)

// Finding ist ein Treffer. Match ist maskiert – nie das ganze Secret.
type Finding struct {
    File  string `json:"file"`
    Line  int    `json:"line"`
    Rule  string `json:"rule"`
    Match string `json:"match"`
}

type rule struct {
    name string
    re   *regexp.Regexp
}

var rules = []rule{
    {"aws-access-key", regexp.MustCompile(`\bAKIA[0-9A-Z]{16}\b`)},
    {"github-token", regexp.MustCompile(`\bgh[pousr]_[A-Za-z0-9]{36}\b`)},
    {"private-key", regexp.MustCompile(`-----BEGIN [A-Z ]*PRIVATE KEY-----`)},
    {"api-key", regexp.MustCompile(`\bsk-[A-Za-z0-9_-]{20,}`)},
}

const (
    ignoreMarker = "secretscan:ignore"
    maxSize      = 1 << 20 // größere Dateien sind selten Konfiguration
)

var skipDirs = []string{".git", "node_modules", "vendor"}

// Mask zeigt die ersten vier Zeichen und die Länge.
func Mask(s string) string {
    n := utf8.RuneCountInString(s)
    if n <= 4 {
        return fmt.Sprintf("…(%d)", n)
    }
    return fmt.Sprintf("%s…(%d)", string([]rune(s)[:4]), n)
}

// Line prüft eine Zeile gegen alle Regeln, Treffer nach Position sortiert.
func Line(line string) []Finding {
    if strings.Contains(line, ignoreMarker) {
        return nil
    }
    type hit struct {
        pos int
        f   Finding
    }
    var hits []hit
    for _, r := range rules {
        for _, loc := range r.re.FindAllStringIndex(line, -1) {
            m := line[loc[0]:loc[1]]
            hits = append(hits, hit{loc[0], Finding{Rule: r.name, Match: Mask(m)}})
        }
    }
    slices.SortFunc(hits, func(a, b hit) int { return cmp.Compare(a.pos, b.pos) })
    var out []Finding
    for _, h := range hits {
        out = append(out, h.f)
    }
    return out
}

// File prüft eine Datei. Binärdateien (NUL-Byte vorn) liefern nichts.
func File(path string) ([]Finding, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return nil, err
    }
    if bytes.IndexByte(data[:min(len(data), 512)], 0) >= 0 {
        return nil, nil
    }
    var out []Finding
    sc := bufio.NewScanner(bytes.NewReader(data))
    sc.Buffer(nil, maxSize)
    for n := 1; sc.Scan(); n++ {
        for _, f := range Line(sc.Text()) {
            f.Line = n
            out = append(out, f)
        }
    }
    return out, sc.Err()
}

// Dir durchsucht root mit workers Goroutines; Dateinamen relativ zu root.
func Dir(ctx context.Context, root string, workers int) ([]Finding, error) {
    var files []string
    err := filepath.WalkDir(root, func(p string, d fs.DirEntry, err error) error {
        if err != nil {
            return err
        }
        if err := ctx.Err(); err != nil {
            return err
        }
        if d.IsDir() && slices.Contains(skipDirs, d.Name()) {
            return filepath.SkipDir
        }
        if !d.Type().IsRegular() {
            return nil
        }
        // zu groß: überspringen (err ist dann nil)
        if info, err := d.Info(); err != nil || info.Size() > maxSize {
            return err
        }
        files = append(files, p)
        return nil
    })
    if err != nil {
        return nil, err
    }

    results := make([][]Finding, len(files))
    errs := make([]error, len(files))
    jobs := make(chan int)
    var wg sync.WaitGroup
    for range max(workers, 1) {
        wg.Go(func() {
            for i := range jobs {
                results[i], errs[i] = File(files[i])
            }
        })
    }
    for i := range files {
        jobs <- i
    }
    close(jobs)
    wg.Wait()
    if err := errors.Join(errs...); err != nil {
        return nil, err
    }

    var out []Finding
    for i, found := range results {
        rel, err := filepath.Rel(root, files[i])
        if err != nil {
            return nil, err
        }
        for _, f := range found {
            f.File = filepath.ToSlash(rel)
            out = append(out, f)
        }
    }
    slices.SortStableFunc(out, func(a, b Finding) int {
        return cmp.Or(cmp.Compare(a.File, b.File), cmp.Compare(a.Line, b.Line))
    })
    return out, nil
}
EOF
cat > cmd/secretscan/main.go <<'EOF'
// secretscan sucht Secrets in einem Ordner: secretscan [-w 8] [-json] ORDNER
// Exit 0 = nichts gefunden, 1 = Treffer, 2 = Aufruf- oder Lesefehler.
// Abschlussprüfung aus "Go zum Anfassen".
package main

import (
    "context"
    "encoding/json"
    "flag"
    "fmt"
    "io"
    "os"
    "os/signal"
    "runtime"

    "example.com/secretscan/internal/scan"
)

func main() {
    ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt)
    defer stop()
    os.Exit(run(ctx, os.Args[1:], os.Stdout, os.Stderr))
}

func run(ctx context.Context, args []string, stdout, stderr io.Writer) int {
    fl := flag.NewFlagSet("secretscan", flag.ContinueOnError)
    fl.SetOutput(stderr)
    workers := fl.Int("w", runtime.NumCPU(), "parallele Leser")
    asJSON := fl.Bool("json", false, "JSON-Ausgabe")
    if err := fl.Parse(args); err != nil {
        return 2
    }
    if fl.NArg() != 1 {
        fmt.Fprintln(stderr, "Aufruf: secretscan [-w N] [-json] ORDNER")
        return 2
    }
    found, err := scan.Dir(ctx, fl.Arg(0), *workers)
    if err != nil {
        fmt.Fprintln(stderr, "secretscan:", err)
        return 2
    }
    if *asJSON {
        if found == nil {
            found = []scan.Finding{} // [] statt null
        }
        enc := json.NewEncoder(stdout)
        enc.SetEscapeHTML(false)
        _ = enc.Encode(found)
    } else {
        for _, f := range found {
            fmt.Fprintf(stdout, "%s:%d: %s %s\n", f.File, f.Line, f.Rule, f.Match)
        }
        fmt.Fprintf(stdout, "%d Treffer\n", len(found))
    }
    if len(found) > 0 {
        return 1
    }
    return 0
}
EOF
./pruefe.sh

Erwartet:

✔ 10 P  gofmt sauber
✔ 10 P  go vet + golangci-lint
✔ 20 P  Tests grün mit -race
✔ 10 P  Exit 1 bei Treffern
✔ 10 P  genau 2 Treffer
✔ 10 P  Secrets maskiert
✔ 10 P  .git, Binär, ignore übersprungen
✔ 10 P  JSON gültig
✔ 5 P  Exit 0 ohne Treffer
✔ 5 P  Exit 2 ohne Ordner
Punkte: 100 von 100

Was die Lösung zusammenbringt: Regex-Regeln als Tabelle (Tag 2, 6), filepath.SkipDir für ganze Ordner, den Worker-Pool mit eigenem Index (Tag 8, 15), errors.Join für Lesefehler (Tag 3), run(...) mit Exit-Codes (Tag 6) und Tests mit t.TempDir (Tag 4).

Ein letzter Lauf über deine eigenen Labs. Lab-Werte wie lab-token-1234 (Tag 5) trifft keine Regel; ein echter Treffer wäre ein Grund, das Secret sofort zu rotieren:

./bin/secretscan ~/go-lab; echo "exit=$?"

Erwartet (je nach deinen Labs):

0 Treffer
exit=0

Glückwunsch – du hast das Trainingslager abgeschlossen. Ab jetzt gilt dieselbe Regel wie in jedem Kapitel: jedes neue Problem als kleines Tool mit Tests, run(...) und sauberen Exit-Codes.