Dokumentácia LockBox CLI

Rýchly štart

Umiestnite LockBox.Cli.exe do priečinka zahrnutého v PATH, alebo ho spustite pomocou úplnej cesty. Značka --cli je akceptovaná pre kompatibilitu, ale nie je vyžadovaná v zostave len s CLI.

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

Minimálny pracovný postup vytvorenia a otvorenia:

$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 používa rovnaké príkazy s lomkovými cestami a binárku bez prípony .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

Inštalácia a kontrola CLI

Rozbaľte ZIP pre svoj systém a procesor. .NET je súčasťou balíka. Porovnajte hash so SHA256SUMS.txt. Umiestnite CLI na uvedenú absolútnu cestu a skontrolujte pomoc aj licenciu pod účtom na zálohovanie.

Linux potrebuje aj natívne knižnice distribúcie vrátane ICU a OpenSSL; pribalený .NET ich nedodáva. Vo Windows musia platné zásady vykonávania povoľovať skripty 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

Priečinky, cesty a miesto

Upravte cesty. Zdrojový priečinok nesmie byť prázdny a kontajner musí byť mimo neho. Rovnaký výstupný názov nahradí pôvodný kontajner a časti. Vyhraďte dočasné miesto vedľa kontajnera a kópiu zdroja pre plánované úlohy. Jednotky používajú základ 1024; výplň pridáva 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

Príprava súborov s tajnými údajmi

Tajné údaje vygenerujte raz, bezpečne zálohujte a obmedzte prístup k súborom. Príklady odmietnu nahradiť existujúce kľúče. Súbory UTF-8 zachovávajú medzery, koncové zalomenia riadkov sa odstránia. Pre staršie zálohy uchovajte pôvodné kľúče.

$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

Aktivácia a stav licencie

Licenčný kľúč je viazaný na ID zariadenia, ktoré tlačí rovnaká zostava CLI. Ak je licencia skopírovaná na iný PC, LockBox ju odmietne a prejde do Free verzie.

Windows kontroluje existujúce umiestnenia dát aplikácie LockBox. Linux ukladá aktiváciu do $XDG_CONFIG_HOME/lockbox/.lockbox.license, potom ~/.config/lockbox/.lockbox.license, s ~/.lockbox/.lockbox.license ako záložnou možnosťou.

.\LockBox.Cli.exe device-id

.\LockBox.Cli.exe license

Aktivovať zo súboru licencie

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

Aktivovať z premennej prostredia

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

Aktivovať inline

Inline aktivácia funguje, ale môže uniknúť cez históriu shellu alebo logy procesov.

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

Linux aktivácia

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

Manipulácia s tajnými údajmi

Uprednostňujte premenné prostredia alebo súbory. Inline tajomstvá sú užitočné iba na testovanie. Hlavné heslá a kľúče vrstiev musia byť zachované: bez nich sa kontajner nedá otvoriť.

Tajomstvá založené na súboroch

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

Algoritmy a generovanie kľúčov

Použite algorithms pre zobrazenie všetkých podporovaných profilov a minimálnych edícií. Použite keygen pre kľúče vrstvy.

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

Podporované aliasy príkazov:

algorithms
list-algorithms
profiles

keygen
generate-key
generate-keys

Vytvorte kontajnery

create zabaluje zdrojový priečinok, aplikuje voliteľnú kompresiu a vyplnenie, zašifruje obsah cez jednu alebo viac vrstiev a zapíše .lbx kontajner.

Požadované možnosti

• --source alebo -s: zdrojový priečinok.
• --output alebo -o: výstupná cesta .lbx.
• --master, --master-env alebo --master-file.
• Aspoň jedna vrstva: --layer, --layer-env alebo --layer-file.

Minimálny AES kontajner

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

Kompresný kontajner

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

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

Rozdelenie kontajnera na časti

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

Prvá časť uchováva .lbx. Ďalšie časti používajú .lbx1, .lbx2 a tak ďalej. Uchovajte všetky časti v rovnakom priečinku.

Príklad Max deväťvrstvový

$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

Alternatívny algoritmus/syntaktika kľúča

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

Odstrániť zdroj po úspešnom manuálnom vytvorení

.\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 odstráni zdrojový priečinok len po úspešnom vytvorení kontajnera. Plánovač má inú možnosť: --delete-source-contents.

Heslo na zničenie kontajnera

Max edícia môže do kontajnera pridať samostatné heslo na zničenie. Ak je toto heslo neskôr zadané ako hlavné heslo, LockBox okamžite prepíše kontajner bez potvrdenia. Je to určené pre situácie vyvíjania nátlaku. Uchovávajte ho oddelene od skutočného hlavného hesla.

Príkaz overí voľné miesto na disku, zašifruje pôvodné údaje kontajnera pomocou nového náhodného kľúča a AES-256-GCM do dočasného súboru, normalizuje výsledok na presnú pôvodnú veľkosť, nahradí pôvodný súbor a zabudne náhodný kľúč. Pre rozdelené kontajnery sa každý .lbx, .lbx1, .lbx2 diel v rovnakej zložke nahradí pri zachovaní pôvodných veľkostí dielov.

Vytvoriť s heslom na zničenie

$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

Spustiť zničenie bez kľúčov vrstiev

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

Spúšťač Linux

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

Po úspešnom zničení kontajner už nie je platný súbor LockBox. CLI vráti výstupný kód 0, pretože požadovaná akcia zničenia bola úspešne dokončená.

Otvoriť kontajnery

open extrahuje kontajner do výstupnej zložky. Pre bežnú extrakciu musia byť kľúče vrstiev odovzdané v rovnakom poradí, ako boli použité pri vytváraní. Pre workflow s heslom na zničenie sú potrebné len cesta ku kontajneru, výstupná cesta a heslo na zničenie ako hlavné heslo.

Otvoriť jednovrstvový kontajner

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

Otvoriť rozdelený kontajner

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

Otvoriť viacvrstvový kontajner

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

open
decrypt
extract

Overenie zálohy obnovením

Vytvorte malý testovací report.csv. Rozbaľujte do nového priečinka; vnútri zostane názov zdrojového priečinka. Uchovávajte všetky časti spolu a porovnajte s nezmeneným zdrojom. Rozbalenie potrebuje zapisovateľné dočasné miesto vedľa kontajnera. Chráňte aj obnovené nešifrované súbory.

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

Plánovač

Príkazy plánovača sú k dispozícii v edícii Max. Uchovávajú úplné metadáta úloh v šifrovanej forme .lbxjobs súbor, vrátane zdrojovej cesty, cesty výstupu, hesiel, hesla na zničenie, kľúčov vrstvy, kompresie, doplnenia, delenia a nastavenia odstránenia zdrojového obsahu.

Plánované úlohy bežia iba počas LockBox.Cli.exe schedule run beží. Použite Windows Task Scheduler, Linux systemd, cron, obal služby alebo dlho bežiacu konzolovú reláciu, ak potrebujete, aby sa pracovník spustil automaticky po reštarte.

Frekvenčné hodnoty

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

Pridať dennú šifrovanú zálohu úlohy

$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

Pridať úlohu, ktorá po úspechu vymaže obsah zdrojovej zložky

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

Pridať mesačný archív s vyrovnávaním a rozdelenými časťami

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

Zoznam uložených úloh

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

Spustite pracovníka plánovača

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

Spustite splatné úlohy raz a ukončite

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

Zobraziť najnovší stav spustenia

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

Stavové značky sú [OK] [RUNNING], a [FAILED]. Neúspešná úloha obsahuje dôvod a informuje používateľa, aby kontaktoval podporu, ak sa problém opakuje.

JSON skripty

Použite --script, keď má pracovný tok niekoľko krokov. Spúšťač skriptov podporuje create, open, keygen, algorithms, device-id, license a activate.

Vytvoriť a otvoriť v jednom skripte

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

Pokračovať po zlyhanom 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" }
      ]
    }
  ]
}

Aktivovať zo skriptu

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

Polia JSON a pravidlá vykonávania

Tabuľka spája polia create a zoznamy kľúčov open s voľbami CLI. Relatívne cesty vychádzajú z pracovného adresára procesu; premenné ani dátumy sa nedopĺňajú. Použite jeden zdroj tajného údaja na pole. open číta keys, potom keyEnvs a keyFiles. Uprednostnite stopOnError: true; pri false môže neskorší úspech zakryť chybu. Skripty JSON nepodporujú príkazy plánovača.

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

Automatizačné recepty

Zálohovanie šifrovaného výpisu databázy

$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

Ochrana artefaktov 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

Bezpečný prenos partnerovi

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

Dlhodobý archív

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

Príklad dávkového súboru

@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: záloha viacerých priečinkov

Uložte skript na uvedenú cestu. Pre každý zdroj vytvorí jedinečne pomenovaný kontajner a protokol, pri chybe skončí a zachová návratový kód CLI. AES-128-GCM funguje vo Free; kompresia a delenie vyžadujú Pro alebo 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: zálohy bez obsluhy

Uložte skript Bash s koncami riadkov LF. Pripravte CLI a tajné údaje na uvedených cestách, zdrojové priečinky odovzdajte ako argumenty. Každé spustenie má vlastný adresár. Chyby zanechajú protokol a nenulový kód; zdroje zostanú zachované.

/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

Plánovanie operačným systémom

Tieto úlohy spúšťajú uvedené skripty; takéto použitie create nevyžaduje Max. Registrácia Windows beží iba pri prihlásení používateľa; podľa potreby nastavte beh bez prihlásenia v Plánovači úloh. Pridajte cron do crontab zálohovacieho účtu a overte flock. Oba príklady bežia o 02:00 miestneho času a bránia súbehu plánovaných spustení. Overte oprávnenia a vyskúšajte ručne.

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: prevádzka plánovača

Vytvorte servisný účet lockbox s potrebnými právami, aktivujte preň Max a pripravte samostatný súbor hesla UTF-8 jobs.txt. add pridáva, neaktualizuje: použite raz na úlohu. Pre súbor úloh prevádzkujte jeden proces a po zmene ho reštartujte. Stavový JSON neobnovuje históriu: zmeškané opakovania preskočí, zmeškaná úloha once môže bežať znova. Na pravidelné systémové spúšťanie použite create namiesto opakovaného run-once. Plánovač opätovne používa výstupný názov.

/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

Referencia príkazov

Možnosti vytvorenia

Možnosti otvorenia

Možnosti plánovača

--language alebo --lang vyberá jazyk konzoly; --quiet potlačí bežný výpis priebehu, chyby však stále smerujú na štandardný chybový výstup. Ctrl+C požiada o zrušenie a vráti 1. Kód 2 označuje neplatnú syntax, kód 3 funkciu vytvárania nedostupnú v aktuálnej edícii. Kód 0 sa vracia aj pri úmyselnom spustení deštrukčného hesla, takže sám nepotvrdzuje extrakciu súborov. Pred ďalšími krokmi automatizácie overte očakávaný výstup.

Návratové kódy a sledovanie

schedule run-once môže vrátiť nulu aj pri chybe úlohy; schedule status tiež bez stavu. Kontrolujte savedAt, lastSuccessAt a lastError; [OK] môže znamenať iba Ready. Monitor predpokladá denné zálohy, dotazovanie po 30 sekundách a úspech počas 26 hodín. Upravte prahy. Stavy JSON sú číselné; --quiet potláča bežný výstup úspešných 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

Riešenie problémov