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/secretscanin~/go-lab/pruefung-secretscan, Paketinternal/scan, Kommandocmd/secretscan. - Regeln (Name: Muster):
aws-access-key:AKIAplus 16 Großbuchstaben/Ziffern, als ganzes Wortgithub-token:ghp_,gho_,ghu_,ghs_oderghr_plus 36 Buchstaben/Ziffern, als ganzes Wortprivate-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, nurRuleundMatchgesetzt), sortiert nach Position. Enthält die Zeilesecretscan: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)durchsuchtrootrekursiv mitworkersGoroutines, überspringt die Ordner.git,node_modulesundvendorsowie Dateien über 1 MiB und Nicht-Dateien (Symlinks …).Finding.Fileist relativ zurootmit/; Ergebnis sortiert nach Datei und Zeile, gleich für 1 und 8 Worker. Abgebrochenerctxliefertcontext.Canceled, fehlender Ordneros.ErrNotExist.scan.Findinghat die JSON-Namenfile,line,rule,match.- CLI:
secretscan [-w N] [-json] ORDNER. Text: eine Zeiledatei:zeile: regel maskepro Treffer, zuletztN Treffer. JSON: ein Array (leer:[], nienull). 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 > .startDie 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.shStarte 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.
- Was ist der Unterschied zwischen
len("Grüße")undutf8.RuneCountInString("Grüße"), und was liefertrangeüber einen String? - Warum musst du das Ergebnis von
appendimmer wieder zuweisen? - Was passiert beim Lesen aus und beim Schreiben in eine
nil-Map? - Wann nimmst du einen Pointer-Receiver statt eines Wert-Receivers?
- Wie erfüllt ein Typ in Go ein Interface, und wozu dient
var _ Parser = JSON{}? - Was ist der Unterschied zwischen
%wund%vinfmt.Errorf? - Wann nimmst du
errors.Is, wannerrors.Asbzw.errors.AsType? - Warum gehört die Logik eines CLIs in
run(...)und nicht inmain? - Was bedeuten die Exit-Codes 0, 1 und 2 in diesem Buch?
- Was prüft
go test -race, und warum lohnt es sich auch bei Tests ohne sichtbare Fehler? - Was ist ein Table-Driven Test, und was bringt
t.Run? - Wozu dienen
t.Helper()undt.Cleanup()? - Was macht ein Fuzz-Test, und wo landen gefundene Fehler?
- Warum ist
for b.Loop()besser alsfor i := 0; i < b.N; i++? - Was ist der Unterschied zwischen
http.Client.Timeoutund einem Context mit Timeout? - Warum muss
resp.Bodyimmer geschlossen werden? - Bei welchen HTTP-Antworten ist ein Retry sinnvoll, bei welchen nicht?
- Wie beendet sich ein
http.Serversauber, wenn Kubernetes den Pod stoppt? - Warum darf ein Worker-Pool ohne Lock in
results[i]schreiben, aber nicht perappendin ein gemeinsames Slice? - Was bewirken
errgroup.WithContextundg.SetLimit(4)? - Was passiert in einem
selectmit einemnil-Channel? - Was ist der Unterschied zwischen
go.modundgo.sum, und was machtgo mod tidy -diff? - Wie baust du auf dem Mac ein statisches Linux-Binary für arm64 mit eingebauter Version?
- Wie testest du Code, der mit der Kubernetes-API oder einem LLM spricht, ohne Cluster und ohne Modell?
- Warum prüft
llm-commitdie Antwort des Modells mit Code, statt dem Prompt zu vertrauen?
Lösungsschlüssel
lenzählt Bytes (7),RuneCountInStringZeichen (5);rangeliefert Byte-Index und Rune.- Reicht die Kapazität nicht, legt
appendein neues Array an und gibt einen neuen Slice-Header zurück; der alte zeigt weiter auf das alte Array. - Lesen liefert den Nullwert (und
ok == false), Schreiben löst eine Panic aus. - Wenn die Methode den Wert ändert, der Typ groß ist oder einen Mutex enthält; innerhalb eines Typs einheitlich bleiben.
- Implizit, sobald alle Methoden vorhanden sind; die Zuweisung lässt den Compiler das prüfen, ohne Laufzeitkosten.
%whängt den Fehler in die Kette ein (prüfbar miterrors.Is/As),%vübernimmt nur den Text.errors.Isvergleicht mit einem bestimmten Wert (Sentinel),errors.As/AsTypesucht einen Typ in der Kette und gibt ihn mit seinen Feldern heraus.runbekommt Argumente, Ein- und Ausgaben als Parameter und gibt einen Exit-Code zurück – damit ist das ganze Tool ohne Prozessstart testbar;mainruft nuros.Exit(run(...)).- 0 = alles in Ordnung, 1 = Fehler oder Funde bei der Arbeit, 2 = falscher Aufruf oder unbrauchbare Konfiguration.
- Gleichzeitige Zugriffe auf denselben Speicher ohne Synchronisation; Data Races fallen oft erst unter Last auf und liefern dann still falsche Werte.
- Ein Slice von Testfällen mit einer Schleife;
t.Runmacht daraus benannte Subtests, die einzeln laufen (-run Test/fall) und einzeln fehlschlagen. t.Helper()lässt Fehlermeldungen auf die Zeile des Aufrufers zeigen,t.Cleanup()registriert Aufräumarbeit, die nach dem Test sicher läuft.- Er erzeugt aus Seeds neue Eingaben und prüft Eigenschaften; ein Fund
wird nach
testdata/fuzz/<Name>/geschrieben und läuft danach bei jedemgo testmit. - Setup vor der Schleife zählt nicht mit, und der Compiler darf den gemessenen Aufruf nicht wegoptimieren (seit Go 1.24).
Client.Timeoutbegrenzt einen einzelnen Request, der Context das Gesamtbudget inklusive Retries und Wartezeiten – und lässt sich von außen abbrechen.- Sonst bleibt die Verbindung belegt und kann nicht wiederverwendet werden; auf Dauer gehen Dateideskriptoren oder Verbindungen aus.
- Sinnvoll bei 429, 5xx und Netzfehlern (mit Backoff,
Retry-Afterbeachten); nicht bei anderen 4xx und nicht bei abgelaufenem Context; nur für idempotente Anfragen. - Auf SIGTERM per
signal.NotifyContextreagieren undsrv.Shutdown(ctx)mit Frist aufrufen: keine neuen Verbindungen, laufende Requests dürfen fertig werden. - 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. - Der erste Fehler bricht den abgeleiteten Context für alle anderen
ab,
Waitliefert diesen Fehler;SetLimitlässtg.Goblockieren, solange schon 4 Goroutines laufen. - Ein
nil-Channel ist nie bereit – der Fall wird imselectpraktisch abgeschaltet. go.modnennt Modul, Go-Version und benötigte Versionen,go.sumdie Prüfsummen;tidy -diffzeigt nur, obtidyetwas ändern würde (CI-Gate).GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go build -trimpath -ldflags "-s -w -X main.version=1.2.3" -o tool ./cmd/tool.- Gegen Fakes:
fake.NewClientsetfür client-go,httptest.Serverfür HTTP-APIs wie die LLM-Schnittstelle; die Logik bekommt Interfaces oder Funktionen injiziert. - 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.shErwartet:
✔ 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.