Dokumentacja LockBox CLI

Szybki start

Umieść LockBox.Cli.exe w folderze uwzględnionym w PATH, lub uruchom go podając pełną ścieżkę. Marker --cli jest akceptowany dla zgodności , ale nie jest wymagany w wersji tylko z CLI.

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

Minimalny przebieg tworzenia i otwierania:

$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 używa tych samych poleceń ze ścieżkami z ukośnikami i pliku binarnego bez sufiksu .exe:

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

Instalacja i sprawdzenie CLI

Rozpakuj ZIP odpowiedni dla systemu i procesora. .NET jest dołączony. Porównaj skrót z SHA256SUMS.txt. Umieść CLI pod wskazaną niżej ścieżką bezwzględną i sprawdź pomoc oraz licencję na koncie wykonującym kopie.

Linux wymaga też bibliotek systemowych dystrybucji, w tym ICU i OpenSSL; dołączony .NET ich nie dostarcza. W Windows obowiązujące zasady wykonywania muszą zezwalać na skrypty PowerShell.

.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

Foldery, ścieżki i miejsce

Dostosuj ścieżki. Folder źródłowy nie może być pusty, a kontener musi znajdować się poza nim. Ponowne użycie nazwy zastępuje poprzedni kontener i części. Zapewnij miejsce tymczasowe obok kontenera oraz kopię źródła dla zadań zaplanowanych. Jednostki bazują na 1024; wypełnienie dodaje bajty.

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

Przygotowanie plików z sekretami

Wygeneruj sekrety raz, zachowaj chronioną kopię i ogranicz dostęp do plików. Przykłady nie zastępują istniejących kluczy. Pliki UTF-8 zachowują spacje, lecz usuwają końcowe znaki nowego wiersza. Starsze kopie wymagają oryginalnych kluczy.

$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

Aktywacja i status licencji

Klucz licencyjny jest powiązany z identyfikatorem urządzenia wydrukowanym przez tę samą wersję CLI. Jeśli licencja zostanie skopiowana na inny komputer, LockBox ją odrzuca i przechodzi do wersji Free.

Windows sprawdza istniejące lokalizacje danych aplikacji LockBox. Linux przechowuje aktywację w $XDG_CONFIG_HOME/lockbox/.lockbox.license, następnie ~/.config/lockbox/.lockbox.license, z ~/.lockbox/.lockbox.license jako odniesienie awaryjne.

.\LockBox.Cli.exe device-id

.\LockBox.Cli.exe license

Aktywacja z pliku licencji

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

Aktywacja z zmiennej środowiskowej

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

Aktywacja inline

Aktywacja inline działa, ale może wyciekać przez historię powłoki lub logi procesów.

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

Aktywacja w Linux

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

Obsługa sekretów

Preferuj zmienne środowiskowe lub pliki. Sekrety w linii są przydatne tylko do testowania. Hasła główne i klucze warstw muszą być zachowane: bez nich kontener nie może być otwarty.

Sekrety oparte na plikach

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

Algorytmy i generowanie kluczy

Użyj algorithms aby zobaczyć wszystkie obsługiwane profile i minimalne edycje. Użyj keygen dla kluczy warstw.

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

Obsługiwane aliasy poleceń:

algorithms
list-algorithms
profiles

keygen
generate-key
generate-keys

Tworzenie kontenerów

create pakuje folder źródłowy, stosuje opcjonalną kompresję i wypełnienie, szyfruje zawartość przez jedną lub więcej warstw i zapisuje kontener .lbx.

Wymagane opcje

• --source lub -s: folder źródłowy.
• --output lub -o: ścieżka wyjściowa .lbx.
• --master, --master-env lub --master-file.
• Przynajmniej jedna warstwa: --layer, --layer-env lub --layer-file.

Minimalny kontener AES

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

Skompresowany kontener

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

Wypełnienie kryptograficzne

.\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

Podział kontenera na części

.\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

Pierwsza część zachowuje .lbx. Dodatkowe części używają .lbx1, .lbx2 i tak dalej. Wszystkie części należy przechowywać w tym samym folderze.

Przykład dziewięciowarstwowego 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

Alternatywna składnia algorytmu/klucza

.\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

Usuń źródło po pomyślnym ręcznym utworzeniu

.\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 usuwa folder źródłowy tylko po pomyślnym utworzeniu kontenera. Harmonogram ma inną opcję: --delete-source-contents.

Hasło do niszczenia kontenera

Max edycja może dodać osobne hasło do zniszczenia do kontenera. Jeśli to hasło zostanie później wprowadzone jako główne hasło, LockBox natychmiast nadpisuje kontener bez potwierdzenia. Jest to przeznaczone do scenariuszy presji przymusu. Trzymaj je oddzielnie od prawdziwego głównego hasła.

Polecenie weryfikuje miejsce na dysku free, szyfruje oryginalne dane kontenera za pomocą nowego losowego sekretu i AES-256-GCM do pliku tymczasowego, normalizuje wynik do dokładnego oryginalnego rozmiaru, zastępuje oryginalny plik i zapomina losowy sekret. Dla kontenerów dzielonych, każdy .lbx, .lbx1, .lbx2 część w tym samym folderze jest zastępowana przy zachowaniu oryginalnych rozmiarów części.

Utwórz z hasłem niszczenia

$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

Wywołaj niszczenie bez kluczy warstw

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

wyzwalacz Linuksa

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

Po pomyślnym zniszczeniu kontener nie jest już prawidłowym plikiem LockBox. CLI zwraca kod zakończenia 0 ponieważ żądana akcja niszczenia zakończyła się pomyślnie.

Otwórz kontenery

open wyodrębnia kontener do folderu wyjściowego. Dla standardowego wyodrębniania, klucze warstw muszą być przekazane w tej samej kolejności, w jakiej były użyte podczas tworzenia. Dla przepływu pracy z hasłem niszczącym, wymagane są tylko ścieżka kontenera, ścieżka wyjściowa oraz hasło niszczące jako hasło główne.

Otwórz kontener jednopoziomowy

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

Otwórz kontener podzielony

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

Otwórz kontener wielowarstwowy

.\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

Aliasów

open
decrypt
extract

Sprawdzenie kopii przez odtworzenie

Utwórz mały plik testowy report.csv. Wypakuj do nowego folderu; wewnątrz zachowana zostanie nazwa folderu źródłowego. Trzymaj części razem i porównuj z niezmienionym źródłem. Wypakowanie wymaga zapisywalnego miejsca tymczasowego obok kontenera. Chroń również odtworzone niezaszyfrowane pliki.

$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"

Harmonogram

Polecenia harmonogramu są dostępne w edycji Max. Przechowują pełne metadane zadania w zaszyfrowanym pliku .lbxjobs, w tym ścieżkę źródłową, ścieżkę wyjściową, hasła, hasło niszczenia, klucze warstw, kompresję, wypełnienie, dzielenie oraz ustawienie usuwania zawartości źródła.

Zaplanowane zadania uruchamiają się tylko podczas działania LockBox.Cli.exe schedule run. Użyj Harmonogramu zadań Windows, systemd w Linuksie, crona, opakowania usługi lub długotrwałej sesji konsoli, jeśli potrzebujesz, aby pracownik uruchamiał się automatycznie po ponownym uruchomieniu.

Wartości częstotliwości

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

Dodaj codzienne zaszyfrowane zadanie kopii zapasowej

$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

Dodaj zadanie, które usuwa zawartość folderu źródłowego po sukcesie

.\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

Dodaj miesięczne archiwum z wypełnieniem i podziałem na części

.\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

Wyświetl zapisane zadania

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

Uruchom proces roboczy harmonogramu

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

Uruchom zaległe zadania jeden raz i zakończ

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

Pokaż najnowszy status wykonania

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

Markery statusu to [OK], [RUNNING] i [FAILED]. Niepowodzenie zadania zawiera powód i informuje użytkownika o konieczności skontaktowania się z pomocą, jeśli problem się powtórzy.

Skrypty JSON

Użyj --script, gdy przepływ pracy ma kilka kroków. Uruchamiacz skryptów obsługuje create, open, keygen, algorithms, device-id, license i activate.

Utwórz i otwórz w jednym skrypcie

{
  "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"

Kontynuuj po niepowodzeniu kroku

{
  "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" }
      ]
    }
  ]
}

Aktywuj ze skryptu

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

Pola JSON i reguły wykonania

Tabela łączy pola create i tablice kluczy open z opcjami CLI. Ścieżki względne liczą się od katalogu roboczego procesu; zmienne i daty nie są podstawiane. Używaj jednego źródła sekretu na pole. open czyta keys, następnie keyEnvs i keyFiles. Wybierz stopOnError: true; przy false późniejszy sukces może ukryć wcześniejszy błąd. Skrypty JSON nie obsługują poleceń harmonogramu.

{
  "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

Przepisy automatyzacji

Backup zaszyfrowanej bazy danych

$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

Ochrona artefaktów CI

.\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

Bezpieczny transfer partnera

.\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

Archiwum długoterminowe

.\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

Przykład pliku wsadowego

@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: kopie wielu folderów

Zapisz skrypt pod wskazaną ścieżką. Tworzy kontener o unikalnej nazwie i dziennik dla każdego źródła, zatrzymuje się po błędzie i zachowuje kod wyjścia CLI. AES-128-GCM działa w Free; kompresja i dzielenie wymagają Pro lub 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: kopie bez nadzoru

Zapisz skrypt Bash z końcami wierszy LF. Przygotuj CLI i sekrety we wskazanych lokalizacjach, a foldery źródłowe przekaż jako argumenty. Każde uruchomienie otrzymuje osobny katalog. Błędy pozostawiają dziennik i niezerowy kod; pliki źródłowe pozostają.

/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

Harmonogram systemu operacyjnego

Zadania uruchamiają powyższe skrypty; takie użycie create nie wymaga Max. Rejestracja Windows działa tylko dla zalogowanego użytkownika; w razie potrzeby ustaw działanie po wylogowaniu w Harmonogramie zadań. Dodaj cron do crontab konta kopii po sprawdzeniu flock. Oba przykłady uruchamiają się o 02:00 czasu lokalnego i zapobiegają nakładaniu zaplanowanych uruchomień. Sprawdź uprawnienia i przetestuj ręcznie.

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: obsługa procesu harmonogramu

Utwórz konto usługi lockbox z wymaganymi uprawnieniami, aktywuj na nim Max i przygotuj osobny plik hasła UTF-8 jobs.txt. add dopisuje, nie aktualizuje: użyj raz na zadanie. Uruchamiaj jeden proces na plik zadań i restartuj po zmianach. JSON stanu nie odtwarza historii: zaległe powtórzenia są pomijane, zaległe zadanie once może wykonać się ponownie. Do cyklicznych uruchomień systemowych używaj create zamiast powtarzanego run-once. Harmonogram ponownie używa nazwy docelowej.

/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

Podręcznik poleceń

Opcje tworzenia

Opcje otwierania

Opcje harmonogramu

--language lub --lang wybiera język konsoli; --quiet ukrywa zwykłe komunikaty postępu, lecz błędy pozostają w standardowym strumieniu błędów. Ctrl+C żąda anulowania i zwraca 1. Kod 2 oznacza błędną składnię polecenia, a 3 funkcję tworzenia niedostępną w bieżącej edycji. Kod 0 jest też zwracany po celowym wyzwoleniu hasła zniszczenia, więc sam nie dowodzi wyodrębnienia plików. Sprawdź oczekiwany wynik przed kolejnymi krokami automatyzacji.

Kody wyjścia i monitorowanie

schedule run-once może zwrócić zero mimo błędów zadań; schedule status także bez stanu. Sprawdzaj savedAt, lastSuccessAt i lastError; [OK] może oznaczać tylko Ready. Monitor zakłada codzienne kopie, odpytywanie co 30 sekund i sukces w ciągu ostatnich 26 godzin. Dostosuj progi. Stany JSON są liczbami; --quiet wyłącza zwykły wynik udanych create/open.

$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

Rozwiązywanie problemów