LockBox CLI-Dokumentation

Schnellstart

Legen Sie LockBox.Cli.exe in einen Ordner, der in PATH enthalten ist, oder rufen Sie ihn mit dem vollständigen Pfad auf. Der --cli Marker wird aus Kompatibilitätsgründen akzeptiert, ist aber im reinen CLI-Build nicht erforderlich.

.\LockBox.Cli.exe --help
.\LockBox.Cli.exe device-id
.\LockBox.Cli.exe algorithms
.\LockBox.Cli.exe keygen --count 3

Minimaler Workflow zum Erstellen und Öffnen:

$env:LBX_MASTER = "use-a-long-master-password"
$env:LBX_L1 = "layer-1-key"

.\LockBox.Cli.exe create `
  --source "D:\Data" `
  --output "E:\Backups\data.lbx" `
  --master-env LBX_MASTER `
  --layer-env AES-128-GCM=LBX_L1

.\LockBox.Cli.exe open `
  --container "E:\Backups\data.lbx" `
  --output "D:\Restore" `
  --master-env LBX_MASTER `
  --key-env LBX_L1

Linux verwendet dieselben Befehle mit Schrägstrich-Pfaden und einer Binärdatei ohne das .exe Suffix:

chmod +x ./LockBox.Cli
./LockBox.Cli --help
./LockBox.Cli device-id
./LockBox.Cli create \
  --source "/srv/data" \
  --output "/backup/data.lbx" \
  --master-env LBX_MASTER \
  --layer-env AES-128-GCM=LBX_L1

CLI installieren und prüfen

Entpacken Sie das ZIP für Betriebssystem und CPU. .NET ist enthalten. Vergleichen Sie die Prüfsumme mit SHA256SUMS.txt. Legen Sie die CLI am unten angegebenen absoluten Pfad ab und prüfen Sie Hilfe und Lizenz unter dem Sicherungskonto.

Linux benötigt zusätzlich native Bibliotheken der Distribution, darunter ICU und OpenSSL; das enthaltene .NET liefert diese nicht mit. Unter Windows muss die wirksame Ausführungsrichtlinie PowerShell-Skripte zulassen.

.NET / Linux · PowerShell / ExecutionPolicy

Expand-Archive -LiteralPath '.\LockBox-Cli-win-x64.zip' -DestinationPath 'C:\Tools\LockBox'
& 'C:\Tools\LockBox\LockBox.Cli.exe' --help
& 'C:\Tools\LockBox\LockBox.Cli.exe' license
Get-FileHash -LiteralPath '.\LockBox-Cli-win-x64.zip' -Algorithm SHA256

uname -m
unzip LockBox-Cli-linux-x64.zip -d ./lockbox-cli
chmod +x ./lockbox-cli/LockBox.Cli
./lockbox-cli/LockBox.Cli --help
./lockbox-cli/LockBox.Cli license
sha256sum LockBox-Cli-linux-x64.zip

SHA256SUMS.txt

Windows x64   -> LockBox-Cli-win-x64.zip
Windows x86   -> LockBox-Cli-win-x86.zip
Windows ARM64 -> LockBox-Cli-win-arm64.zip
Linux x86_64  -> LockBox-Cli-linux-x64.zip
Linux aarch64 -> LockBox-Cli-linux-arm64.zip
Linux armv7l  -> LockBox-Cli-linux-arm.zip

Ordner, Pfade und Speicherplatz

Passen Sie die Pfade an. Der Quellordner darf nicht leer sein; das Ziel muss außerhalb liegen. Derselbe Zielname ersetzt den bisherigen Container samt Teilen. Planen Sie temporären Platz neben dem Container und eine Quellkopie für geplante Aufgaben ein. Größen basieren auf 1024; Padding fügt Bytes hinzu.

C:\Tools\LockBox\LockBox.Cli.exe     /opt/lockbox/LockBox.Cli
C:\LockBox\secrets\master.txt       /srv/lockbox/secrets/master.txt
C:\LockBox\secrets\layer1.txt       /srv/lockbox/secrets/layer1.txt
C:\LockBox\backup.ps1               /srv/lockbox/backup.sh
D:\Data\report.csv                 /srv/data/report.csv
E:\Backups\20260910-020000\data.lbx  /backup/20260910-020000/data.lbx
D:\Restore\Data\report.csv         /restore/data/report.csv

& 'C:\Tools\LockBox\LockBox.Cli.exe' create --source 'D:\Data' --output 'E:\Backups\data.lbx' --master-file 'C:\LockBox\secrets\master.txt' --layer-file 'AES-128-GCM=C:\LockBox\secrets\layer1.txt'

/opt/lockbox/LockBox.Cli create --source /srv/data --output /backup/data.lbx --master-file /srv/lockbox/secrets/master.txt --layer-file AES-128-GCM=/srv/lockbox/secrets/layer1.txt

Wiederverwendbare Geheimnisdateien

Erzeugen Sie Schlüssel einmalig, sichern Sie sie geschützt und beschränken Sie den Dateizugriff. Die Beispiele ersetzen keine vorhandenen Schlüssel. UTF-8-Dateien behalten Leerzeichen; abschließende Zeilenumbrüche werden entfernt. Für alte Sicherungen benötigen Sie die ursprünglichen Schlüssel.

$ErrorActionPreference = 'Stop'
$cli = 'C:\Tools\LockBox\LockBox.Cli.exe'
$secretDir = 'C:\LockBox\secrets'
New-Item -ItemType Directory -Force -Path $secretDir | Out-Null
$files = @('master.txt', 'layer1.txt')
foreach ($name in $files) {
    if (Test-Path -LiteralPath (Join-Path $secretDir $name)) {
        throw "Secret already exists: $name"
    }
}
foreach ($name in $files) {
    $key = & $cli keygen --count 1
    if ($LASTEXITCODE -ne 0) { throw 'Key generation failed' }
    [IO.File]::WriteAllText((Join-Path $secretDir $name), [string]$key, [Text.UTF8Encoding]::new($false))
}

set -eu
umask 077
mkdir -p /srv/lockbox/secrets
test ! -e /srv/lockbox/secrets/master.txt
test ! -e /srv/lockbox/secrets/layer1.txt
set -C
/opt/lockbox/LockBox.Cli keygen --count 1 > /srv/lockbox/secrets/master.txt
/opt/lockbox/LockBox.Cli keygen --count 1 > /srv/lockbox/secrets/layer1.txt

Aktivierung und Lizenzstatus

Der Lizenzschlüssel ist an die Geräte-ID gebunden, die von demselben CLI-Build ausgegeben wird. Wenn eine Lizenz auf einen anderen PC kopiert wird, lehnt LockBox sie ab und wechselt zur Free-Version.

Windows überprüft die vorhandenen LockBox-Anwendungsdatenorte. Linux speichert die Aktivierung in $XDG_CONFIG_HOME/lockbox/.lockbox.license, dann ~/.config/lockbox/.lockbox.license, mit ~/.lockbox/.lockbox.license als Fallback.

.\LockBox.Cli.exe device-id

.\LockBox.Cli.exe license

Von einer Lizenzdatei aktivieren

.\LockBox.Cli.exe activate --license-file "C:\Licenses\lockbox-license.txt"

Von einer Umgebungsvariable aktivieren

$env:LBX_LICENSE = "LBX-LIC-..."
.\LockBox.Cli.exe activate --license-env LBX_LICENSE

Inline aktivieren

Die Inline-Aktivierung funktioniert, kann jedoch über die Shell-Historie oder Prozessprotokolle offengelegt werden.

.\LockBox.Cli.exe activate --license "LBX-LIC-..."

Linux-Aktivierung

export LBX_LICENSE="LBX-LIC-..."
./LockBox.Cli activate --license-env LBX_LICENSE
./LockBox.Cli license

Umgang mit Geheimnissen

Bevorzugen Sie Umgebungsvariablen oder Dateien. Inline-Geheimnisse sind nur für Tests nützlich. Hauptpasswörter und Layer-Schlüssel müssen aufbewahrt werden: Ohne sie kann der Container nicht geöffnet werden.

Dateibasierte Geheimnisse

Set-Content -Path ".\master.txt" -Value "master-password" -Encoding UTF8
Set-Content -Path ".\layer1.txt" -Value "layer-key-1" -Encoding UTF8

.\LockBox.Cli.exe create `
  -s "D:\Data" `
  -o "E:\Backups\data.lbx" `
  --master-file ".\master.txt" `
  --layer-file AES-128-GCM=.\layer1.txt

Algorithmen und Schlüsselerzeugung

Verwenden Sie algorithms, um alle unterstützten Profile und Mindestversionen zu sehen. Verwenden Sie keygen für Layer-Schlüssel.

.\LockBox.Cli.exe algorithms
.\LockBox.Cli.exe keygen
.\LockBox.Cli.exe keygen --count 9
.\LockBox.Cli.exe generate-keys -n 20

Unterstützte Befehlsalias:

algorithms
list-algorithms
profiles

keygen
generate-key
generate-keys

Container erstellen

create packt einen Quellordner, wendet optionale Kompression und Padding an, verschlüsselt die Nutzlast durch eine oder mehrere Schichten und schreibt einen .lbx Container.

Erforderliche Optionen

• --source oder -s: Quellordner.
• --output oder -o: Ausgabepfad des .lbx.
• --master, --master-env oder --master-file.
• Mindestens eine Schicht: --layer, --layer-env oder --layer-file.

Minimaler AES-Container

.\LockBox.Cli.exe create `
  -s "D:\Data" `
  -o "E:\Backups\data.lbx" `
  --master-env LBX_MASTER `
  --layer-env AES-128-GCM=LBX_L1

Komprimierter Container

.\LockBox.Cli.exe create `
  --source "D:\Exports" `
  --output "E:\Backups\exports.lbx" `
  --master-env LBX_MASTER `
  --layer-env AES-256-GCM=LBX_L1 `
  --compress

Krypto-Padding

.\LockBox.Cli.exe create `
  -s "D:\Contracts" `
  -o "E:\Backups\contracts.lbx" `
  --master-env LBX_MASTER `
  --layer-env AES-256-GCM=LBX_L1 `
  --padding 2GB

Container in Teile aufteilen

.\LockBox.Cli.exe create `
  -s "D:\Media" `
  -o "E:\Backups\media.lbx" `
  --master-env LBX_MASTER `
  --layer-env AES-256-GCM=LBX_L1 `
  --split 700MB

Das erste Teil behält .lbx. Zusätzliche Teile verwenden .lbx1, .lbx2 und so weiter. Alle Teile im gleichen Ordner aufbewahren.

Beispiel für neun Schichten Max

$env:LBX_MASTER = "use-a-long-master-password"
$env:LBX_L1 = "layer-1-key"
$env:LBX_L2 = "layer-2-key"
$env:LBX_L3 = "layer-3-key"
$env:LBX_L4 = "layer-4-key"
$env:LBX_L5 = "layer-5-key"
$env:LBX_L6 = "layer-6-key"
$env:LBX_L7 = "layer-7-key"
$env:LBX_L8 = "layer-8-key"
$env:LBX_L9 = "layer-9-key"

.\LockBox.Cli.exe create `
  --source "D:\Data" `
  --output "E:\Backups\data-max.lbx" `
  --master-env LBX_MASTER `
  --compress `
  --padding 2GB `
  --split 700MB `
  --layer-env AES-256-GCM=LBX_L1 `
  --layer-env CHACHA20-POLY1305=LBX_L2 `
  --layer-env AES-256-CCM=LBX_L3 `
  --layer-env SERPENT-256-CTR-HMACSHA512=LBX_L4 `
  --layer-env TWOFISH-256-CTR-HMACSHA512=LBX_L5 `
  --layer-env CAMELLIA-256-CTR-HMACSHA512=LBX_L6 `
  --layer-env ARIA-256-CTR-HMACSHA512=LBX_L7 `
  --layer-env AES-256-CBC-HMACSHA512=LBX_L8 `
  --layer-env AES-192-OFB-HMACSHA384=LBX_L9

Alternative Algorithmus-/Schlüssel-Syntax

.\LockBox.Cli.exe create `
  -s "D:\Data" `
  -o "E:\Backups\data.lbx" `
  --master-env LBX_MASTER `
  --algorithm AES-128-GCM --key-env LBX_L1 `
  --algorithm AES-128-CTR-HMACSHA256 --key-env LBX_L2

Quellordner nach erfolgreicher manueller Erstellung löschen

.\LockBox.Cli.exe create `
  -s "D:\TempToEncrypt" `
  -o "E:\Backups\temp.lbx" `
  --master-env LBX_MASTER `
  --layer-env AES-256-GCM=LBX_L1 `
  --delete-source

--delete-source löscht den Quellordner nur, nachdem der Container erfolgreich erstellt wurde. Der Scheduler hat eine andere Option: --delete-source-contents.

Container-Zerstörungspasswort

Die Max-Edition kann einem Container ein separates Zerstörungspasswort hinzufügen. Wenn dieses Passwort später als Master-Passwort eingegeben wird, überschreibt LockBox den Container sofort ohne Bestätigung. Dies ist für Situationen mit Zwangsdruck gedacht. Halten Sie es vom echten Master-Passwort getrennt.

Der Befehl überprüft den freien Speicherplatz, verschlüsselt die ursprünglichen Containerdaten mit einem frischen zufälligen Geheimnis und AES-256-GCM in eine temporäre Datei, normalisiert das Ergebnis auf die exakt ursprüngliche Größe, ersetzt die Originaldatei und vergisst das zufällige Geheimnis. Für geteilte Container wird jeder .lbx, .lbx1, .lbx2 Teil im gleichen Ordner ersetzt, während die ursprünglichen Teildaten erhalten bleiben.

Mit einem Zerstörungspasswort erstellen

$env:LBX_MASTER = "real-master-password"
$env:LBX_L1 = "layer-key-1"
$env:LBX_DESTROY = "pressure-password"

.\LockBox.Cli.exe create `
  --source "D:\Data" `
  --output "E:\Backups\data.lbx" `
  --master-env LBX_MASTER `
  --layer-env AES-256-GCM=LBX_L1 `
  --destruction-password-env LBX_DESTROY

Zerstörung ohne Layer-Schlüssel auslösen

.\LockBox.Cli.exe open `
  --container "E:\Backups\data.lbx" `
  --output "D:\Restore" `
  --master-env LBX_DESTROY

Linux-Auslösung

export LBX_DESTROY="pressure-password"
./LockBox.Cli open \
  --container "/backup/data.lbx" \
  --output "/restore" \
  --master-env LBX_DESTROY

Nach erfolgreicher Zerstörung ist der Container keine gültige LockBox-Datei mehr. Die CLI gibt den Exit-Code 0 zurück, da die angeforderte Zerstörungsaktion erfolgreich abgeschlossen wurde.

Container öffnen

open extrahiert einen Container in den Ausgabeordner. Für eine normale Extraktion müssen die Layer-Schlüssel in der gleichen Reihenfolge übergeben werden, wie sie bei der Erstellung verwendet wurden. Für einen Zerstörungspasswort-Workflow sind nur der Containerpfad, der Ausgabepfad und das Zerstörungspasswort als Master-Passwort erforderlich.

Ein-Ebenen-Container öffnen

.\LockBox.Cli.exe open `
  --container "E:\Backups\data.lbx" `
  --output "D:\Restore" `
  --master-env LBX_MASTER `
  --key-env LBX_L1

Geteilten Container öffnen

.\LockBox.Cli.exe open `
  -c "E:\Backups\data.lbx" `
  -o "D:\Restore" `
  --master-env LBX_MASTER `
  --key-env LBX_L1

Mehr-Ebenen-Container öffnen

.\LockBox.Cli.exe open `
  -c "E:\Backups\data-max.lbx" `
  -o "D:\Restore" `
  --master-env LBX_MASTER `
  --key-env LBX_L1 `
  --key-env LBX_L2 `
  --key-env LBX_L3 `
  --key-env LBX_L4 `
  --key-env LBX_L5 `
  --key-env LBX_L6 `
  --key-env LBX_L7 `
  --key-env LBX_L8 `
  --key-env LBX_L9

Aliase

open
decrypt
extract

Sicherung durch Wiederherstellung prüfen

Erstellen Sie eine kleine report.csv als Test. Entpacken Sie in einen neuen Ordner; der Quellordnername bleibt darin erhalten. Halten Sie alle Containerteile zusammen und vergleichen Sie mit unveränderten Quelldaten. Temporäre Daten brauchen Schreibzugriff neben dem Container. Schützen Sie auch die wiederhergestellten Klartextdateien.

$ErrorActionPreference = 'Stop'
$cli = 'C:\Tools\LockBox\LockBox.Cli.exe'
$container = 'E:\Backups\data.lbx'
$restore = Join-Path 'D:\RestoreChecks' ([guid]::NewGuid().ToString('N'))
& $cli open --container $container --output $restore --master-file 'C:\LockBox\secrets\master.txt' --key-file 'C:\LockBox\secrets\layer1.txt'
if ($LASTEXITCODE -ne 0) { exit $LASTEXITCODE }
$original = (Get-FileHash -LiteralPath 'D:\Data\report.csv' -Algorithm SHA256).Hash
$restored = (Get-FileHash -LiteralPath (Join-Path $restore 'Data\report.csv') -Algorithm SHA256).Hash
if ($original -ne $restored) { throw 'SHA256 mismatch' }
Write-Output $restore

set -eu
umask 077
mkdir -p /restore
restore=$(mktemp -d /restore/check-XXXXXX)
/opt/lockbox/LockBox.Cli open --container /backup/data.lbx --output "$restore" --master-file /srv/lockbox/secrets/master.txt --key-file /srv/lockbox/secrets/layer1.txt
cmp /srv/data/report.csv "$restore/data/report.csv"
sha256sum /srv/data/report.csv "$restore/data/report.csv"

Planer

Planerbefehle sind in der Max-Edition verfügbar. Sie speichern vollständige Aufgaben-Metadaten in einer verschlüsselten .lbxjobs-Datei, einschließlich Quellpfad, Ausgabepfad, Passwörter, Löschpasswort, Ebenenschlüssel, Kompression, Padding, Aufteilung und Einstellung zum Löschen der Quellinhalte.

Geplante Aufgaben werden nur ausgeführt, während LockBox.Cli.exe schedule run läuft. Verwenden Sie den Windows-Taskplaner, Linux systemd, cron, einen Service-Wrapper oder eine lang laufende Konsolensitzung, wenn der Arbeiter nach einem Neustart automatisch starten soll.

Frequenzwerte

once
30m
hourly
2h
3h
6h
9h
12h
18h
daily
2d
3d
5d
weekly
2w
monthly
2mo
3mo
6mo
9mo
yearly

Tägliche verschlüsselte Sicherungsaufgabe hinzufügen

$env:LBX_JOBS_PASSWORD = "jobs-file-password"
$env:LBX_MASTER = "master-password"
$env:LBX_L1 = "layer-key-1"
$env:LBX_DESTROY = "pressure-password"

.\LockBox.Cli.exe schedule add `
  --tasks "E:\Backups\jobs.lbxjobs" `
  --password-env LBX_JOBS_PASSWORD `
  --name "Nightly data backup" `
  --frequency daily `
  --start ((Get-Date).AddDays(1).ToString("o")) `
  --source "D:\Data" `
  --output "E:\Backups\nightly-data.lbx" `
  --master-env LBX_MASTER `
  --layer-env AES-256-GCM=LBX_L1 `
  --destruction-password-env LBX_DESTROY `
  --compress

Aufgabe hinzufügen, die nach Erfolg den Quellordnerinhalt löscht

.\LockBox.Cli.exe schedule add `
  --tasks "E:\Backups\jobs.lbxjobs" `
  --password-env LBX_JOBS_PASSWORD `
  --name "Encrypt outgoing folder" `
  --frequency 30m `
  --start ((Get-Date).AddDays(1).ToString("o")) `
  --source "D:\Outgoing" `
  --output "E:\Backups\outgoing.lbx" `
  --master-env LBX_MASTER `
  --layer-env AES-256-GCM=LBX_L1 `
  --delete-source-contents

Monatliches Archiv mit Padding und geteilten Teilen hinzufügen

.\LockBox.Cli.exe schedule add `
  --tasks "E:\Backups\jobs.lbxjobs" `
  --password-env LBX_JOBS_PASSWORD `
  --name "Monthly legal archive" `
  --frequency monthly `
  --start ((Get-Date).AddDays(1).ToString("o")) `
  --source "D:\Legal" `
  --output "E:\Archives\legal-monthly.lbx" `
  --master-env LBX_MASTER `
  --layer-env AES-256-GCM=LBX_L1 `
  --compress `
  --padding 4GB `
  --split 2GB

Gespeicherte Aufgaben auflisten

.\LockBox.Cli.exe schedule list `
  --tasks "E:\Backups\jobs.lbxjobs" `
  --password-env LBX_JOBS_PASSWORD

Planer-Arbeiter ausführen

.\LockBox.Cli.exe schedule run `
  --tasks "E:\Backups\jobs.lbxjobs" `
  --password-env LBX_JOBS_PASSWORD `
  --state "E:\Backups\jobs.status.json" `
  --poll-seconds 30

Fällige Aufgaben einmal ausführen und beenden

.\LockBox.Cli.exe schedule run-once `
  --tasks "E:\Backups\jobs.lbxjobs" `
  --password-env LBX_JOBS_PASSWORD `
  --state "E:\Backups\jobs.status.json"

Neuesten Ausführungsstatus anzeigen

.\LockBox.Cli.exe schedule status --state "E:\Backups\jobs.status.json"

Statusmarker sind [OK], [RUNNING] und [FAILED]. Eine fehlgeschlagene Aufgabe enthält den Grund und fordert den Benutzer auf, den Support zu kontaktieren, falls das Problem erneut auftritt.

JSON-Skripte

Verwenden Sie --script, wenn ein Workflow mehrere Schritte hat. Der Skript-Runner unterstützt create, open, keygen, algorithms, device-id, license und activate.

Erstellen und in einem Skript öffnen

{
  "stopOnError": true,
  "commands": [
    {
      "command": "create",
      "source": "D:\\Data",
      "output": "E:\\Backups\\data.lbx",
      "masterPasswordEnv": "LBX_MASTER",
      "destructionPasswordEnv": "LBX_DESTROY",
      "compression": true,
      "padding": "512MB",
      "split": "700MB",
      "layers": [
        { "algorithm": "AES-256-GCM", "keyEnv": "LBX_L1" },
        { "algorithm": "CHACHA20-POLY1305", "keyEnv": "LBX_L2" }
      ]
    },
    {
      "command": "open",
      "container": "E:\\Backups\\data.lbx",
      "output": "D:\\Restore",
      "masterPasswordEnv": "LBX_MASTER",
      "keyEnvs": [ "LBX_L1", "LBX_L2" ]
    }
  ]
}

.\LockBox.Cli.exe --script ".\backup.lockbox.json"

Nach einem fehlgeschlagenen Schritt fortfahren

{
  "stopOnError": false,
  "commands": [
    { "command": "license" },
    { "command": "algorithms" },
    {
      "command": "create",
      "source": "D:\\BuildOutput",
      "output": "E:\\Artifacts\\build.lbx",
      "masterPasswordEnv": "LBX_MASTER",
      "layers": [
        { "algorithm": "AES-128-GCM", "keyEnv": "LBX_L1" }
      ]
    }
  ]
}

Aus Skript aktivieren

{
  "commands": [
    {
      "command": "activate",
      "licenseKeyFile": "C:\\Licenses\\lockbox-license.txt"
    },
    { "command": "license" }
  ]
}

JSON-Felder und Ausführungsregeln

Die Tabelle ordnet create-Felder und open-Schlüsselarrays den CLI-Optionen zu. Relative Pfade beginnen im Arbeitsordner des Prozesses; Variablen und Zeitstempel werden nicht ersetzt. Verwenden Sie eine Geheimnisquelle je Feld. open liest keys, dann keyEnvs, dann keyFiles. Bevorzugen Sie stopOnError: true; bei false können spätere Erfolge frühere Fehler verdecken. Scheduler-Befehle sind in JSON-Skripten nicht verfügbar.

{
  "stopOnError": true,
  "commands": [
    {
      "command": "create",
      "source": "/srv/data",
      "output": "/backup/data.lbx",
      "masterPasswordFile": "/srv/lockbox/secrets/master.txt",
      "layers": [
        { "algorithm": "AES-128-GCM", "keyFile": "/srv/lockbox/secrets/layer1.txt" }
      ]
    },
    {
      "command": "open",
      "container": "/backup/data.lbx",
      "output": "/restore/check",
      "masterPasswordFile": "/srv/lockbox/secrets/master.txt",
      "keyFiles": ["/srv/lockbox/secrets/layer1.txt"]
    }
  ]
}

/opt/lockbox/LockBox.Cli --quiet script /srv/lockbox/backup.lockbox.json

Automatisierungsrezepte

Verschlüsseltes Datenbank-Dump-Backup

$stamp = Get-Date -Format "yyyyMMdd-HHmmss"
$dump = "D:\DbDumps\$stamp"
New-Item -ItemType Directory -Path $dump | Out-Null

Copy-Item "D:\DatabaseExports\*" $dump -Recurse

.\LockBox.Cli.exe create `
  -s $dump `
  -o "E:\Backups\db-$stamp.lbx" `
  --master-env LBX_MASTER `
  --layer-env AES-256-GCM=LBX_L1 `
  --compress `
  --padding 512MB

CI-Artefaktschutz

.\LockBox.Cli.exe create `
  --source "$env:BUILD_ARTIFACTSTAGINGDIRECTORY" `
  --output "$env:AGENT_TEMPDIRECTORY\protected-artifacts.lbx" `
  --master-env LBX_MASTER `
  --layer-env AES-128-GCM=LBX_L1

Sicherer Partnertransfer

.\LockBox.Cli.exe create `
  -s "D:\PartnerPackage" `
  -o "E:\Transfer\partner-package.lbx" `
  --master-env LBX_MASTER `
  --layer-env AES-256-GCM=LBX_L1 `
  --layer-env CHACHA20-POLY1305=LBX_L2 `
  --compress `
  --split 1GB

Langzeitarchiv

.\LockBox.Cli.exe create `
  -s "D:\Records\2026" `
  -o "E:\ColdStorage\records-2026.lbx" `
  --master-file "C:\Secrets\records-master.txt" `
  --layer-file AES-256-GCM=C:\Secrets\records-layer1.txt `
  --layer-file SERPENT-256-CTR-HMACSHA512=C:\Secrets\records-layer2.txt `
  --compress `
  --padding 8GB `
  --split 4GB

Batch-Datei-Beispiel

@echo off
set LBX_MASTER=master-password
set LBX_L1=layer-key-1

LockBox.Cli.exe create ^
  --source "D:\Data" ^
  --output "E:\Backups\data.lbx" ^
  --master-env LBX_MASTER ^
  --layer-env AES-128-GCM=LBX_L1

if errorlevel 1 exit /b %errorlevel%
echo OK

Windows: mehrere Ordner sichern

Speichern Sie das Skript am angegebenen Pfad. Es erstellt pro Quelle einen eindeutig benannten Container und ein Protokoll, stoppt bei Fehlern und gibt den CLI-Exitcode zurück. AES-128-GCM funktioniert mit Free; Komprimierung und Aufteilung erfordern Pro oder Max.

C:\LockBox\backup.ps1

param(
    [string[]]$Source = @('D:\Data'),
    [string]$Destination = 'E:\Backups'
)
$ErrorActionPreference = 'Stop'
$cli = 'C:\Tools\LockBox\LockBox.Cli.exe'
$secretDir = 'C:\LockBox\secrets'
try {
    foreach ($folder in $Source) {
        $sourcePath = (Resolve-Path -LiteralPath $folder).Path
        $stamp = (Get-Date).ToUniversalTime().ToString('yyyyMMdd-HHmmss-fff')
        $runId = [guid]::NewGuid().ToString('N')
        $runDir = Join-Path $Destination "$stamp-$runId"
        New-Item -ItemType Directory -Path $runDir | Out-Null
        $container = Join-Path $runDir 'data.lbx'
        $log = Join-Path $runDir 'create.log'
        $cliArgs = @(
            '--quiet', 'create', '--source', $sourcePath, '--output', $container,
            '--master-file', (Join-Path $secretDir 'master.txt'),
            '--layer-file', ('AES-128-GCM=' + (Join-Path $secretDir 'layer1.txt'))
        )
        $ErrorActionPreference = 'Continue'
        & $cli @cliArgs > $log 2>&1
        $result = $LASTEXITCODE
        $ErrorActionPreference = 'Stop'
        if ($result -ne 0) {
            Get-Content -LiteralPath $log
            exit $result
        }
        if (-not (Test-Path -LiteralPath $container -PathType Leaf)) {
            throw "Container missing: $container"
        }
        Write-Output $container
    }
    exit 0
} catch {
    Write-Error $_ -ErrorAction Continue
    exit 1
}

& 'C:\LockBox\backup.ps1' -Source 'D:\Data', 'D:\Reports' -Destination 'E:\Backups'
# 0 = success; 1 = runtime error; 2 = usage error; 3 = edition restriction
$LASTEXITCODE

Linux: unbeaufsichtigte Sicherungen

Speichern Sie das Bash-Skript mit LF-Zeilenenden. Bereiten Sie CLI und Geheimnisdateien an den angegebenen Pfaden vor und übergeben Sie Quellordner als Argumente. Jeder Lauf erhält einen eigenen Ordner. Fehler werden protokolliert und liefern einen Fehlercode; Quelldaten bleiben erhalten.

/srv/lockbox/backup.sh

#!/bin/bash
set -eu
umask 077
cli=/opt/lockbox/LockBox.Cli
secret_dir=/srv/lockbox/secrets
backup_root=/backup
mkdir -p "$backup_root"
if [ "$#" -eq 0 ]; then
    set -- /srv/data
fi
for source in "$@"; do
    run_dir=$(mktemp -d "$backup_root/$(date -u +%Y%m%d-%H%M%S)-XXXXXX")
    container="$run_dir/data.lbx"
    log="$run_dir/create.log"
    "$cli" --quiet create \
        --source "$source" \
        --output "$container" \
        --master-file "$secret_dir/master.txt" \
        --layer-file "AES-128-GCM=$secret_dir/layer1.txt" > "$log" 2>&1 || {
        result=$?
        cat "$log" >&2
        exit "$result"
    }
    test -s "$container"
    printf '%s\n' "$container"
done

/bin/bash /srv/lockbox/backup.sh /srv/data /srv/reports

Sicherungen über das Betriebssystem planen

Die Aufgaben starten die obigen Skripte; create benötigt dafür kein Max. Die Windows-Registrierung läuft nur bei angemeldetem Benutzer; konfigurieren Sie bei Bedarf den abgemeldeten Betrieb im Aufgabenplaner. Tragen Sie cron beim Sicherungsbenutzer ein und prüfen Sie flock. Beide Beispiele laufen um 02:00 Ortszeit und verhindern überlappende geplante Läufe. Prüfen Sie Rechte und testen Sie manuell.

Windows

$action = New-ScheduledTaskAction -Execute 'powershell.exe' -Argument '-NoProfile -NonInteractive -File "C:\LockBox\backup.ps1"' -WorkingDirectory 'C:\LockBox'
$trigger = New-ScheduledTaskTrigger -Daily -At '02:00'
$settings = New-ScheduledTaskSettingsSet -StartWhenAvailable -MultipleInstances IgnoreNew -ExecutionTimeLimit ([TimeSpan]::Zero)
$principal = New-ScheduledTaskPrincipal -UserId ([Security.Principal.WindowsIdentity]::GetCurrent().Name) -LogonType Interactive
Register-ScheduledTask -TaskName 'LockBox backup' -Action $action -Trigger $trigger -Settings $settings -Principal $principal
Start-ScheduledTask -TaskName 'LockBox backup'
Get-ScheduledTaskInfo -TaskName 'LockBox backup'

New-ScheduledTaskSettingsSet · New-ScheduledTaskPrincipal

Linux: cron

crontab -e

0 2 * * * /usr/bin/flock -n /srv/lockbox/backup.lock /bin/bash /srv/lockbox/backup.sh >> /srv/lockbox/cron.log 2>&1

crontab(5)

Max: Scheduler betreiben

Erstellen Sie das Dienstkonto lockbox mit passenden Rechten, aktivieren Sie Max dafür und erstellen Sie die separate UTF-8-Passwortdatei jobs.txt. add hängt Aufgaben an; führen Sie es pro Aufgabe einmal aus. Betreiben Sie einen Worker pro Aufgabendatei und starten Sie ihn nach Änderungen neu. Status-JSON ist kein Wiederaufnahmepunkt: überfällige Wiederholungen werden übersprungen, überfällige once-Aufgaben können erneut laufen. Für periodische OS-Aufrufe verwenden Sie create statt wiederholtem run-once. Der Scheduler verwendet denselben Zielnamen erneut.

/opt/lockbox/LockBox.Cli schedule add \
  --tasks /srv/lockbox/jobs.lbxjobs \
  --password-file /srv/lockbox/secrets/jobs.txt \
  --name nightly-data --frequency daily \
  --start "$(date -d 'tomorrow 02:00' --iso-8601=seconds)" \
  --source /srv/data --output /backup/nightly-data.lbx \
  --master-file /srv/lockbox/secrets/master.txt \
  --layer-file AES-128-GCM=/srv/lockbox/secrets/layer1.txt

/opt/lockbox/LockBox.Cli schedule list --tasks /srv/lockbox/jobs.lbxjobs --password-file /srv/lockbox/secrets/jobs.txt

/etc/systemd/system/lockbox-scheduler.service

[Unit]
Description=LockBox scheduler
After=local-fs.target
RequiresMountsFor=/srv/data /srv/lockbox /backup

[Service]
Type=simple
User=lockbox
WorkingDirectory=/srv/lockbox
UMask=0077
ExecStart=/opt/lockbox/LockBox.Cli schedule run --tasks /srv/lockbox/jobs.lbxjobs --password-file /srv/lockbox/secrets/jobs.txt --state /srv/lockbox/jobs.status.json --poll-seconds 30
Restart=on-failure
RestartSec=10
KillSignal=SIGINT
TimeoutStopSec=300

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl enable --now lockbox-scheduler.service
systemctl status lockbox-scheduler.service
journalctl -u lockbox-scheduler.service -n 50 --no-pager
/opt/lockbox/LockBox.Cli schedule status --state /srv/lockbox/jobs.status.json

systemd.service

Befehlsreferenz

Optionen erstellen

Öffnungsoptionen

Scheduler-Optionen

Mit --language oder --lang wählen Sie die Konsolensprache; --quiet unterdrückt normale Fortschrittsmeldungen, Fehler erscheinen weiterhin im Standardfehlerstrom. Ctrl+C fordert den Abbruch an und liefert Code 1. Code 2 bedeutet ungültige Befehlssyntax, Code 3 eine in der aktuellen Edition nicht verfügbare Erstellungsfunktion. Code 0 wird auch bei absichtlich ausgelöstem Vernichtungspasswort zurückgegeben und beweist daher allein keine Dateiextraktion. Prüfen Sie die erwartete Ausgabe vor weiteren Automatisierungsschritten.

Exitcodes und Sicherungsüberwachung

schedule run-once kann trotz Aufgabenfehlern null zurückgeben; schedule status auch bei fehlendem Status. Prüfen Sie savedAt, lastSuccessAt und lastError; [OK] kann nur Ready bedeuten. Der Monitor erwartet tägliche Sicherungen, 30-Sekunden-Abfragen und einen Erfolg innerhalb von 26 Stunden. Passen Sie diese Schwellen an. JSON-Zustände sind numerisch; --quiet unterdrückt normale create/open-Erfolgsausgaben.

$ErrorActionPreference = 'Stop'
try {
    $status = Get-Content -LiteralPath 'E:\Backups\jobs.status.json' -Raw | ConvertFrom-Json
    if (@($status.tasks).Count -eq 0) { throw 'No tasks in status file' }
    if ([DateTimeOffset]$status.savedAt -lt [DateTimeOffset]::Now.AddMinutes(-2)) {
        throw 'Worker status is stale'
    }
    foreach ($task in $status.tasks) {
        if ($task.state -eq 3 -or $task.lastError) { throw "Task failed: $($task.name)" }
        if (-not $task.lastSuccessAt -or [DateTimeOffset]$task.lastSuccessAt -lt [DateTimeOffset]::Now.AddHours(-26)) {
            throw "No recent successful backup: $($task.name)"
        }
    }
    exit 0
} catch {
    Write-Error $_ -ErrorAction Continue
    exit 1
}

0 -> Ready
1 -> Running
2 -> Completed
3 -> Failed

Fehlerbehebung