Security & DevOps

Architektur & Praxis: S&B Forge — Autarkes CI/CD und Zero-Trust Secret Management ohne .env-Dateien

2026-09-08Skulls & Bones Lab

Das Ende der .env-Datei: Autarkes Secret Management & CI/CD mit S&B Forge

In fast jedem modernen Softwareprojekt wiederholt sich dasselbe sicherheitskritische Ritual: Ein Entwickler klont ein Repository, kopiert .env.example zu .env und trägt unverschlüsselte API-Tokens, Datenbank-Passwörter und Signing-Keys im Klartext auf seiner lokalen SSD ein.

Die Konsequenzen sind aus zahllosen Sicherheitsvorfällen bekannt:

Versehentliche Git-Leaks: Ein unbedachter git add . und ein unvollständiges .gitignore genügen, um Produktionsschlüssel dauerhaft in der Git-Historie zu verewigen.
Dateisystem-Exfiltration: Jedes NPM-Paket mit Post-Install-Skript, jede Browser-Erweiterung oder jede kompromittierte Entwickler-Software kann Klartext-.env-Dateien im Projektverzeichnis ohne Root-Rechte auslesen.
Fragile Deployment-Skripte: Um Builds auf Server zu übertragen, greifen Teams häufig auf unübersichtliche Shell- und PowerShell-Skripte (deploy.sh, deploy.ps1) zurück, in denen Server-Passwörter oder SSH-Parameter hartverdrahtet sind.
Cloud-SaaS-Lock-in: Große Enterprise-Vaults (HashiCorp Vault, AWS Secrets Manager) sind für Solo-Entwickler, kleine Teams und On-Premise-Umgebungen oft überdimensioniert, teuer, erfordern permanente Internetverbindungen und schaffen neue Angriffsflächen.

Mit S&B Forge (sb-forge) veröffentlichen wir heute ein freies, quelloffenes (MIT-Lizenz) und autarkes Werkzeug in 100% Rust, das dieses Problem an der Wurzel packt. Es vereint ein kryptographisch gehärtetes Zero-Plaintext-Secret-Management mit einer leistungsfähigen, lokalen CI/CD-Pipeline-Engine und nativer Server-Bereitstellung über S&B NetGate (sb-ssh).

Was ist S&B Forge?

S&B Forge ist eine autarke Single-Binary CLI. Es benötigt weder Docker, noch externe Datenbanken, Hintergrunddienste oder Cloud-Subscriptions.

+-------------------------------------------------------------------------+
|                              S&B FORGE                                  |
|                                                                         |
|  [ In-RAM Secret Vault ]       [ DAG Pipeline Engine ]   [ TUI Watch ]  |
|  - AES-256-GCM + Argon2id      - Asynchron (Tokio)       - Ratatui      |
|  - Zero Plaintext on Disk      - Parallele Stages        - Live-Status  |
|  - In-Memory Exec (sb-forge)   - Topologische Sortierung                |
|                                                                         |
|  [ Pre-Commit Scanner ]        [ S&B NetGate Transport ] [ BSI Audit ]  |
|  - 9 Heuristik-Prüfungen       - Ephemere SSH-Zertifikate- OPS.1.1.4    |
|  - Blockiert Leaks vor Commit  - Pure-Rust SFTP Push     - JSON-Lines   |
+-------------------------------------------------------------------------+

Das Tool löst das Spannungsfeld zwischen maximaler kryptographischer Härtung und reibungslosem Entwickler-Komfort:

Zero Plaintext on Disk: Entwickler speichern Secrets ausschließlich in lokal verschlüsselten Tresoren (~/.sb-forge/vault/<env>.vault).
In-Memory Secret Injektion (sb-forge exec): Anwendungen (Node.js, Next.js, Rust, Go, Python) erhalten Umgebungsvariablen direkt im flüchtigen RAM des Kindprozesses. Auf der Festplatte existiert zu keinem Zeitpunkt eine .env-Datei.
Parallele DAG-Pipelines (sb-forge run): Build-, Test- und Deployment-Schritte werden in einer deklarativen Forge.toml definiert und durch die asynchrone Tokio-Engine mit Zyklenerkennung parallel ausgeführt.
Cryptographic Server Sealing (sb-forge env seal): Secrets für Produktionsserver werden kryptographisch versiegelt und gebunden an den Server-Fingerprint übertragen.
Revisionssichere BSI IT-Grundschutz Audits: Alle Pipeline-Läufe und Secret-Zugriffe werden manipulationsgeschützt in JSON-Lines protokolliert (OPS.1.1.4).

Die 6 Kernsäulen der Forge-Architektur

1. Verschlüsselter Vault mit AES-256-GCM & Argon2id

Herkömmliche Tools speichern Secrets entweder im Klartext oder mit schwachen Schlüsseln. S&B Forge verwendet moderne kryptographische Standards:

KDF (Key Derivation Function): Aus dem Master-Passwort wird über Argon2id (Memory-Hardness gegen GPU/ASIC-Brute-Force) ein 256-Bit-Verschlüsselungsschlüssel abgeleitet.
Verschlüsselung: Alle Secrets werden mit AES-256-GCM (Galois/Counter Mode) verschlüsselt. Dies garantiert Vertraulichkeit und kryptographische Integrität (Authentizität).
Umgebungs-Isolation: Secrets sind strikt nach Environments getrennt (dev, staging, prod) und liegen als separate Binärtresore in ~/.sb-forge/vault/.

# Secret verschlüsselt für Entwicklung hinterlegen (mit maskierter Eingabe)
sb-forge secret set DATABASE_URL --env dev

# Secret für Produktion hinterlegen
sb-forge secret set STRIPE_SECRET_KEY --env prod

2. In-Memory Process Injection (`sb-forge exec`)

Das Kernmerkmal von S&B Forge: Kindprozesse erhalten Secrets ausschließlich über ihren flüchtigen Prozess-RAM.

# Node.js / Next.js Server ohne .env-Datei starten:
sb-forge exec --env dev -- npm run dev

# Cargo Test mit Test-Datenbank-Secrets ausführen:
sb-forge exec --env test -- cargo test

sb-forge exec entschlüsselt den Tresor temporär im Arbeitsspeicher, setzt die Umgebungsvariablen für den neuen Kindprozess und startet diesen. Sobald der Prozess beendet wird, existieren die Secrets nicht mehr im RAM. Andere Prozesse oder Dateisystem-Scanner haben zu keinem Zeitpunkt Zugriff auf die sensiblen Werte.

3. Pre-Commit Secret Scanner (`sb-forge scan`)

Trotz aller Sorgfalt passiert es schnell: Ein API-Token wird beim schnellen Debuggen in eine Quelldatei kopiert und mit committet. S&B Forge enthält einen integrierten Secret-Scanner mit 9 Erkennungsmustern:

Private SSH/RSA/EC-Keys (-----BEGIN ... PRIVATE KEY-----)
JWT Tokens (eyJ...)
Stripe API Keys (sk_live_...)
GitHub Personal Access Tokens (ghp_...)
AWS Access Keys & Secrets (AKIA...)
Slack & Discord Bot Tokens
Datenbank-Verbindungszeichenfolgen mit Passwörtern (postgres://, mysql://, mongodb://)
Generische Passwörter in Zuweisungen

# Staged Dateien vor dem Commit scannen
sb-forge scan --staged

# Gesamtes Repository inklusive vollständiger Git-Historie auditieren
sb-forge check --git-history

Mit sb-forge init installiert Forge einen nativen Git-Pre-Commit-Hook, der jeden Commit sofort abbricht, sollte ein Entwickler versehentlich ein Secret im Code hinterlassen haben.

4. Parallele Multi-Stage Pipelines in `Forge.toml`

Anstatt kryptische Bash-Skripte oder PowerShell-Einzeiler zu pflegen, definiert jedes Projekt seine CI/CD-Prozesse in einer standardisierten Forge.toml:

[project]
name = "my-web-platform"
version = "0.1.0"

# Parallele CI-Prüfung
[recipes.ci]
description = "Linting, Unit-Tests und Sicherheitsüberprüfung"
stages = [
    { name = "Lint", cmd = "npm run lint" },
    { name = "Typecheck", cmd = "npx tsc --noEmit" },
    { name = "Unit Tests", cmd = "npm test" },
]
parallel = true

# Sequentielles Deployment mit Remote-Übertragung
[recipes.deploy]
description = "Produktions-Build und Deployment auf Hostinger VPS"
stages = [
    { name = "Build", cmd = "npm run build" },
    { name = "Tarball erstellen", cmd = "tar -czf dist.tar.gz out/" },
    { name = "Upload", remote = "s&b-prod", cmd = "sftp-push dist.tar.gz /var/www/app/" },
    { name = "Remote Restart", remote = "s&b-prod", cmd = "pm2 restart app" },
    { name = "Aufräumen", cmd = "rm dist.tar.gz" }
]

Dank Tokio-Multithreading laufen Stages mit parallel = true mit maximaler Auslastung aller CPU-Kerne. Fehler in einer Stage führen zum kontrollierten Abbruch nachfolgender Schritte.

5. Cryptographic Server Sealing & systemd Generator

Wie gelangen Produktions-Secrets sicher auf den Zielserver, ohne dass sie im Klartext per SSH übertragen werden?

S&B Forge nutzt Cryptographic Server Sealing:

# 1. Produktions-Secrets an den Fingerprint des Zielservers binden & übertragen
sb-forge env seal prod --server hostinger-prod --deploy

Auf dem Server generiert Forge auf Wunsch sofort eine BSI-konforme, gehärtete systemd Service Unit:

sb-forge systemd-unit webapp --env prod --user www-data

Die generierte Unit nutzt moderne Linux-Härtungsfeatures wie ProtectSystem=strict, ProtectHome=true, NoNewPrivileges=true und PrivateTmp=true.

6. Vollbild TUI Dashboard (`sb-forge watch`)

Für interaktive Entwicklungs- und Monitoring-Aufgaben stellt Forge ein vollwertiges Terminal User Interface (TUI) auf Basis von Ratatui bereit:

sb-forge watch

Das Dashboard bietet:

Run Inspector: Chronologische Liste aller Pipeline-Ausführungen mit Dauer, Status und Einzelschritten.
Vault Status: Anzeige aktiver Vaults, Verschlüsselungsstatus und verbleibender Secret-Rotationsfristen.
Hot-Reload: Mit sb-forge run check --watch überwacht Forge das Projektverzeichnis und startet Tests bei Dateiänderungen automatisch neu (mit intelligentem Debouncing).

Schritt-für-Schritt Schnellstart

Schritt 1: S&B Forge installieren

Da Forge in 100% Rust ohne externe C-Abhängigkeiten geschrieben ist, genügt ein einziger Befehl:

cargo install --git https://github.com/Skulls-and-Bones/sb-forge.git

Die Binärdatei sb-forge steht nun global zur Verfügung. Prüfen Sie die Installation mit:

sb-forge --version

Schritt 2: Projekt initialisieren

Wechseln Sie in Ihr Projektverzeichnis und initialisieren Sie Forge:

cd ~/mein-projekt
sb-forge init

Dieser Befehl erstellt:

Eine vorstrukturierte Forge.toml mit Best-Practice CI/CD-Rezepten.
Einen Git Pre-Commit Hook in .git/hooks/pre-commit, der automatisch sb-forge scan --staged ausführt.
Den lokalen Vault-Speicher unter ~/.sb-forge/.

Schritt 3: Secrets im verschlüsselten Tresor hinterlegen

Legen Sie ein Master-Passwort fest und speichern Sie Ihre Secrets verschlüsselt ab:

# Interaktive, maskierte Eingabe (verhindert Klartext in der Shell-Historie):
sb-forge secret set DATABASE_URL --env dev
sb-forge secret set API_KEY --env dev

Die Secrets sind nun mit AES-256-GCM verschlüsselt. Sie können die hinterlegten Schlüssel (ohne Werte) einsehen:

sb-forge secret list --env dev

Schritt 4: Anwendung mit In-Memory Secret-Injektion ausführen

Starten Sie Ihre Entwicklungsumgebung. Ihre Anwendung liest wie gewohnt process.env.DATABASE_URL (Node.js) oder std::env::var("DATABASE_URL") (Rust) — ohne dass jemals eine .env-Datei auf Ihrer Festplatte lag:

sb-forge exec --env dev -- npm run dev

Schritt 5: CI/CD Pipelines ausführen

Führen Sie Ihre Qualitätsprüfungen aus:

# Lokale CI-Pipeline starten:
sb-forge run ci

# Vollständigen Release- & Deployment-Prozess ausführen:
sb-forge run deploy

Feature-Gegenüberstellung

Eigenschaft	Klassische `.env` + Bash	Cloud-SaaS Vaults (AWS / HashiCorp)	S&B Forge (`sb-forge`)
Speicherort Secrets	Klartext auf Festplatte	Externe Cloud-Server	Verschlüsselt im lokalen Vault (`AES-256-GCM`)
Dateisystem-Footprint	`.env` Dateien im Projekt	SDKs / Temp-Files	0 Byte Plaintext (Reine RAM-Injektion)
Leak-Prävention	Manuelles `.gitignore`	Cloud Policy Engine	Nativer 9-Pattern Pre-Commit Scanner
Pipeline-Ausführung	Fragile Shell-Skripte	Externe CI-Runner (GitHub Actions)	Parallele DAG-Pipelines mit Tokio Nebenläufigkeit
Server-Transport	Unsicheres Klartext-SCP	Agenten / IAM Rollen	S&B NetGate (`sb-ssh`) mit ephemeren Zertifikaten
Kosten & Lizenz	Kostenlos	Hohe monatliche SaaS-Kosten	100% Kostenlos (Open Source, MIT)
Cloud-Abhängigkeit	Keine	100% Internet- & Cloud-Zwang	100% Autark / Air-Gapped fähig
BSI-Compliance	Keine	Komplexe CloudTrail-Audits	Strukturierte JSONL-Logs (BSI OPS.1.1.4)
TUI Dashboard	Keine	Web-UI	Vollbild Ratatui Terminal-Monitor

Fazit: Entwickler-Komfort trifft Zero-Trust-Sicherheit

S&B Forge beweist, dass professionelle DevSecOps-Praktiken weder teure Cloud-Abonnements noch unübersichtliche Infrastruktur-Monster erfordern. Als kompakte, blitzschnelle Rust-Binary gibt Forge Entwicklern die vollständige Kontrolle über ihre Pipelines und Secrets zurück.

Probieren Sie S&B Forge noch heute aus — vollständig kostenlos und quelloffen:

GitHub Repository: https://github.com/Skulls-and-Bones/sb-forge
Offizielle Produktseite: https://www.skulls-and-bones.org/#forge
Installation: cargo install --git https://github.com/Skulls-and-Bones/sb-forge.git