LockBox CLI dokumentacija

Brzi početak

Stavite LockBox.Cli.exe u mapu uključenu u PATH, ili je pozovite pomoću punog puta. Marker --cli se prihvaća radi kompatibilnosti , ali nije obavezan u verziji samo s CLI-jem.

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

Minimalni tijek stvaranja i otvaranja:

$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 koristi iste naredbe s kosim crtama u putanjama i binarnom datotekom bez sufiksa .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

Instalacija i provjera CLI-ja

Raspakirajte ZIP za svoj sustav i procesor. .NET je uključen. Usporedite hash sa SHA256SUMS.txt. Postavite CLI na navedenu apsolutnu putanju i provjerite pomoć i licencu računom za sigurnosne kopije.

Linux treba i izvorne biblioteke distribucije, uključujući ICU i OpenSSL; uključeni .NET ih ne isporučuje. U Windowsu važeća pravila izvršavanja moraju dopuštati PowerShell skripte.

.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

Mape, putanje i prostor

Prilagodite putanje. Izvorna mapa ne smije biti prazna, a spremnik mora biti izvan nje. Isti izlazni naziv zamjenjuje prethodni spremnik i dijelove. Osigurajte privremeni prostor uz spremnik te kopiju izvora za zakazane zadatke. Jedinice se temelje na 1024; popuna dodaje bajtove.

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

Priprema datoteka s tajnama

Tajne generirajte jednom, sačuvajte zaštićenu kopiju i ograničite pristup datotekama. Primjeri odbijaju zamijeniti postojeće ključeve. UTF-8 datoteke čuvaju razmake, ali uklanjaju završne prijelome redaka. Za stare kopije sačuvajte izvorne ključeve.

$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

Aktivacija i status licence

Licencni ključ je vezan uz ID uređaja koji ispisuje ista CLI verzija. Ako se licenca kopira na drugo računalo, LockBox je odbija i prelazi na Free.

Windows provjerava postojeće lokacije podataka aplikacije LockBox. Linux sprema aktivaciju u $XDG_CONFIG_HOME/lockbox/.lockbox.license, zatim ~/.config/lockbox/.lockbox.license, s ~/.lockbox/.lockbox.license kao rezervnom opcijom.

.\LockBox.Cli.exe device-id

.\LockBox.Cli.exe license

Aktiviraj iz licencne datoteke

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

Aktiviraj iz varijable okruženja

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

Inline aktivacija

Inline aktivacija radi, ali može procuriti kroz povijest ljuske ili logove procesa.

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

Linux aktivacija

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

Rukovanje tajnama

Preferirajte varijable okoline ili datoteke. Tajne unutar koda korisne su samo za testiranje. Glavne lozinke i ključni slojevi moraju se sačuvati: bez njih kontejner se ne može otvoriti.

Tajne temeljenje na datotekama

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

Algoritmi i generiranje ključeva

Koristite algorithms za pregled svih podržanih profila i minimalnih izdanja. Koristite keygen za ključeve sloja.

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

Podržani aliasi naredbi:

algorithms
list-algorithms
profiles

keygen
generate-key
generate-keys

Kreirajte spremnike

create pakira izvornu mapu, primjenjuje opcionalnu kompresiju i ispunu, šifrira sadržaj kroz jedan ili više slojeva i zapisuje .lbx spremnik.

Potrebne opcije

• --source ili -s: izvorna mapa.
• --output ili -o: izlazna .lbx putanja.
• --master, --master-env ili --master-file.
• Barem jedan sloj: --layer, --layer-env ili --layer-file.

Minimalni AES spremnik

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

Kompresirani spremnik

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

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

Podjela spremnika na dijelove

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

Prvi dio čuva .lbx. Dodatni dijelovi koriste .lbx1, .lbx2, i tako dalje. Držite sve dijelove u istoj mapi.

Primjer devet-slojnog 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

Alternativna sintaksa algoritma/ključ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

Izbrišite izvor nakon uspješnog ručnog kreiranja

.\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 briše izvornu mapu samo nakon što je spremnik uspješno kreiran. Scheduler ima drugačiju opciju: --delete-source-contents.

Lozinka za uništavanje kontejnera

Max izdanje može dodati posebnu lozinku za uništavanje kontejneru. Ako se ta lozinka unese kasnije kao glavna lozinka, LockBox odmah prepisuje kontejner bez potvrde. Ovo je namijenjeno za scenarije pod prisilom. Držite je odvojeno od stvarne glavne lozinke.

Naredba provjerava slobodan prostor na disku, šifrira izvorne podatke kontejnera s novo generiranim nasumičnim tajnim ključem i AES-256-GCM u privremenu datoteku, normalizira rezultat na točno izvornu veličinu, zamjenjuje izvornu datoteku i zaboravlja nasumični ključ. Za podijeljene kontejnere, svaki .lbx, .lbx1, .lbx2 dio u istoj mapi se zamjenjuje uz očuvanje izvornog broja dijelova.

Kreirajte s lozinkom za uništavanje

$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

Pokreni uništavanje bez slojeva ključeva

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

Linux pokretač

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

Nakon uspješnog uništavanja kontejner više nije valjana LockBox datoteka. CLI vraća izlazni kod 0 jer je tražena radnja uništavanja uspješno izvršena.

Otvorite kontejnere

open izdvaja kontejner u izlaznu mapu. Za normalno izdvajanje, slojevi ključeva moraju biti proslijeđeni istim redoslijedom korištenim tijekom stvaranja. Za radni tijek s lozinkom za uništavanje, potrebno je samo unijeti putanju kontejnera, putanju izlaza i lozinku za uništavanje kao glavnu lozinku.

Otvorite kontejner s jednim slojem

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

Otvorite podijeljeni kontejner

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

Otvorite kontejner s više slojeva

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

Provjera kopije vraćanjem

Stvorite mali testni report.csv. Raspakirajte u novu mapu koja zadržava naziv izvorne mape. Čuvajte sve dijelove zajedno i usporedite s nepromijenjenim izvorom. Raspakiravanje zahtijeva privremeni prostor za pisanje uz spremnik. Zaštitite i vraćene nešifrirane datoteke.

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

Raspored

Naredbe rasporeda dostupne su u Max izdanju. One pohranjuju sve metapodatke zadatka u šifriranu .lbxjobs datoteku, uključujući izvorni put, put izlaza, lozinke, lozinku za uništenje, ključeve slojeva, kompresiju, popunjavanje, dijeljenje i postavku brisanja sadržaja izvora.

Raspoređeni zadaci pokreću se samo dok je LockBox.Cli.exe schedule run pokrenut. Koristite Windows Task Scheduler, Linux systemd, cron, servisni omotač ili dugotrajnu konzolnu sesiju ako želite da radnik automatski počne nakon ponovnog pokretanja.

Vrijednosti učestalosti

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

Dodajte dnevni šifrirani sigurnosni zadatak

$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

Dodajte zadatak koji briše sadržaj izvornog direktorija nakon uspjeha

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

Dodajte mjesečnu arhivu s popunjavanjem i dijeljenjem dijelova

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

Popis pohranjenih zadataka

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

Pokrenite radnika rasporeda

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

Pokrenite dospjele zadatke jednom i izađite

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

Prikaži najnoviji status izvršavanja

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

Oznake statusa su [OK], [RUNNING] i [FAILED]. Neuspjeli zadatak uključuje razlog i govori korisniku da se obrati podršci ako se problem ponovi.

JSON skripte

Koristite --script kada tijek rada ima nekoliko koraka. Pokretač skripti podržava create, open, keygen, algorithms, device-id, license i activate.

Kreirajte i otvorite u jednoj skripti

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

Nastavite nakon neuspjelog koraka

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

Aktivirajte iz skripte

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

JSON polja i pravila izvršavanja

Tablica povezuje create polja i open nizove ključeva s CLI opcijama. Relativne putanje počinju u radnoj mapi procesa; varijable i datumi ne zamjenjuju se. Koristite jedan izvor tajne po polju. open čita keys, zatim keyEnvs i keyFiles. Prednost dajte stopOnError: true; uz false kasniji uspjeh može sakriti pogrešku. JSON skripte ne podržavaju naredbe raspoređivač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

Recepti za automatizaciju

Sigurna sigurnosna kopija baze podataka

$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

Zaštita CI artefakata

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

Siguran prijenos partneru

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

Arhiva dugog roka

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

Primjer batch datoteke

@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: kopiranje više mapa

Spremite skriptu na navedenu putanju. Za svaki izvor stvara jedinstveno nazvan spremnik i zapisnik, staje pri pogrešci i čuva izlazni kod CLI-ja. AES-128-GCM radi u Free; sažimanje i dijeljenje zahtijevaju Pro ili 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: kopije bez nadzora

Spremite Bash skriptu s LF završecima redaka. Pripremite CLI i tajne na navedenim putanjama te proslijedite izvorne mape kao argumente. Svako pokretanje dobiva zasebnu mapu. Pogreške ostavljaju zapisnik i vraćaju kod različit od nule; izvori ostaju.

/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

Raspored operacijskog sustava

Zadaci pokreću prethodne skripte; takva uporaba create ne zahtijeva Max. Windows registracija radi samo dok je korisnik prijavljen; po potrebi podesite rad nakon odjave u Planeru zadataka. Dodajte cron u crontab računa za kopiranje nakon provjere flock. Oba primjera rade u 02:00 po lokalnom vremenu i sprječavaju preklapanje zakazanih pokretanja. Provjerite prava i testirajte ručno.

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: upravljanje raspoređivačem

Stvorite servisni račun lockbox s potrebnim pravima, aktivirajte Max za njega i pripremite zasebnu UTF-8 datoteku lozinke jobs.txt. add dodaje, ne ažurira: koristite jednom po zadatku. Pokrenite jedan proces po datoteci zadataka i ponovno ga pokrenite nakon promjena. Statusni JSON ne obnavlja povijest: propuštena ponavljanja se preskaču, propušteni zadatak once može se ponoviti. Za periodična sistemska pokretanja koristite create umjesto ponavljanog run-once. Raspoređivač ponovno koristi izlazni naziv.

/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

Referenca naredbi

Opcije stvaranja

Opcije otvaranja

Opcije raspoređivača

Koristite --language ili --lang za odabir jezika konzole i --quiet za skrivanje uobičajenog prikaza napretka; pogreške se i dalje ispisuju na standardni izlaz za pogreške. Ctrl+C zahtijeva otkazivanje i vraća kod 1. Kod 2 označava neispravnu sintaksu naredbe; kod 3 označava da funkcija stvaranja nije dostupna u trenutačnom izdanju. Kod 0 obuhvaća i namjerno aktiviranu lozinku za uništavanje, pa sam po sebi ne dokazuje da su datoteke izdvojene. Provjerite očekivani izlaz prije sljedećih koraka automatizacije.

Izlazni kodovi i nadzor

schedule run-once može vratiti nulu i kod neuspjelih zadataka; schedule status također bez statusa. Provjeravajte savedAt, lastSuccessAt i lastError; [OK] može značiti samo Ready. Monitor očekuje dnevne kopije, provjere svakih 30 sekundi i uspjeh unutar 26 sati. Prilagodite pragove. JSON stanja su brojevi; --quiet uklanja uobičajeni ispis uspješnih 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

Rješavanje problema