erste module drin.

zwischenstand: Architektur aktualisiert, TOFU implementiert,

pkg/crypto/pin.go

@@ -0,0 +1,142 @@
+package crypto
+
+import (
+	"bufio"
+	"bytes"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"os"
+	"strings"
+	"sync"
+)
+
+var (
+	// ErrUnknownServer: Kein Pin und kein erwarteter Fingerprint – ein
+	// ungeprüfter Erstkontakt wird verweigert.
+	ErrUnknownServer = errors.New("crypto: unbekannter Server – Fingerprint aus dem Enrollment-Token erforderlich")
+	// ErrFingerprintMismatch: Das Server-Zertifikat passt nicht zum Pin bzw.
+	// zum erwarteten Fingerprint (möglicher Man-in-the-Middle).
+	ErrFingerprintMismatch = errors.New("crypto: Server-Fingerprint stimmt nicht – möglicher Man-in-the-Middle")
+	// ErrCorruptKnownServers: Die known_servers-Datei ist nicht lesbar.
+	ErrCorruptKnownServers = errors.New("crypto: known_servers beschädigt")
+)
+
+// KnownServers ist die Pin-Datei des Agenten (analog zu SSH known_hosts).
+// Format: eine Zeile "<server> <fingerprint>", # für Kommentare. Einträge
+// werden nur angehängt, nie stillschweigend geändert.
+type KnownServers struct {
+	Path string
+	mu   sync.Mutex
+}
+
+// Lookup liefert den Pin für server. Eine fehlende Datei bedeutet: kein Pin.
+func (k *KnownServers) Lookup(server string) (Fingerprint, bool, error) {
+	k.mu.Lock()
+	defer k.mu.Unlock()
+	return k.lookup(server)
+}
+
+func (k *KnownServers) lookup(server string) (Fingerprint, bool, error) {
+	data, err := os.ReadFile(k.Path)
+	if errors.Is(err, os.ErrNotExist) {
+		return "", false, nil
+	}
+	if err != nil {
+		return "", false, err
+	}
+	sc := bufio.NewScanner(bytes.NewReader(data))
+	for line := 1; sc.Scan(); line++ {
+		text := strings.TrimSpace(sc.Text())
+		if text == "" || strings.HasPrefix(text, "#") {
+			continue
+		}
+		fields := strings.Fields(text)
+		if len(fields) != 2 {
+			return "", false, fmt.Errorf("%w: %s Zeile %d", ErrCorruptKnownServers, k.Path, line)
+		}
+		fp, err := ParseFingerprint(fields[1])
+		if err != nil {
+			return "", false, fmt.Errorf("%w: %s Zeile %d: %w", ErrCorruptKnownServers, k.Path, line, err)
+		}
+		if fields[0] == server {
+			return fp, true, nil
+		}
+	}
+	return "", false, sc.Err()
+}
+
+// Add pinnt fp für server. Ist bereits ein anderer Fingerprint gepinnt,
+// liefert Add ErrFingerprintMismatch und ändert nichts.
+func (k *KnownServers) Add(server string, fp Fingerprint) error {
+	if len(strings.Fields(server)) != 1 || strings.TrimSpace(server) != server {
+		return fmt.Errorf("crypto: ungültiger Servername %q", server)
+	}
+	if _, err := ParseFingerprint(string(fp)); err != nil {
+		return err
+	}
+	k.mu.Lock()
+	defer k.mu.Unlock()
+	pinned, ok, err := k.lookup(server)
+	if err != nil {
+		return err
+	}
+	if ok {
+		if pinned != fp {
+			return fmt.Errorf("%w: %s ist auf %s gepinnt, nicht %s", ErrFingerprintMismatch, server, pinned, fp)
+		}
+		return nil
+	}
+	f, err := os.OpenFile(k.Path, os.O_WRONLY|os.O_APPEND|os.O_CREATE, 0o600)
+	if err != nil {
+		return err
+	}
+	_, err = fmt.Fprintf(f, "%s %s\n", server, fp)
+	if cerr := f.Close(); err == nil {
+		err = cerr
+	}
+	return err
+}
+
+// ClientTLSConfig liefert die TLS-Konfiguration des Agenten für server
+// (host:port aus der --server-URL). Statt einer CA prüft sie den
+// Fingerprint:
+//
+//   - Pin vorhanden: Das Zertifikat muss dazu passen (expected wird ignoriert).
+//   - Kein Pin, expected gesetzt (Fingerprint aus dem Enrollment-Token):
+//     Das Zertifikat muss dazu passen und wird dann gepinnt.
+//   - Kein Pin, kein expected: Verbindung wird verweigert (ErrUnknownServer).
+//
+// Die Prüfung läuft im TLS-Handshake, also bevor irgendein Request-Byte
+// (Token, Signatur, Body) gesendet wird. Nur TLS 1.3.
+func ClientTLSConfig(server string, ks *KnownServers, expected Fingerprint) *tls.Config {
+	return &tls.Config{
+		MinVersion: tls.VersionTLS13,
+		// Die CA-Prüfung entfällt bewusst; VerifyConnection ersetzt sie
+		// durch die strengere Fingerprint-Prüfung.
+		InsecureSkipVerify: true,
+		VerifyConnection: func(cs tls.ConnectionState) error {
+			if len(cs.PeerCertificates) == 0 {
+				return fmt.Errorf("%w: kein Zertifikat", ErrFingerprintMismatch)
+			}
+			actual := FingerprintOf(cs.PeerCertificates[0])
+			pinned, ok, err := ks.Lookup(server)
+			if err != nil {
+				return err
+			}
+			if ok {
+				if actual != pinned {
+					return fmt.Errorf("%w: %s präsentiert %s, gepinnt ist %s", ErrFingerprintMismatch, server, actual, pinned)
+				}
+				return nil
+			}
+			if expected == "" {
+				return fmt.Errorf("%w (%s präsentiert %s)", ErrUnknownServer, server, actual)
+			}
+			if actual != expected {
+				return fmt.Errorf("%w: %s präsentiert %s, Token erwartet %s", ErrFingerprintMismatch, server, actual, expected)
+			}
+			return ks.Add(server, actual)
+		},
+	}
+}