LockBox CLI dokumentacija

Hitri začetek

Postavite LockBox.Cli.exe v mapo, vključeno v PATH, ali ga pokličite po polni poti. Označevalec --cli je sprejet za združljivost , vendar ni potreben v gradnji samo za CLI.

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

Minimalno ustvarjanje in odpiranje delovnega toka:

$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 uporablja iste ukaze s poševnimi potmi in binarno datoteko brez pripone .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

Namestitev in preverjanje CLI

Razširite ZIP za svoj sistem in procesor. .NET je vključen. Primerjajte zgoščeno vrednost s SHA256SUMS.txt. CLI postavite na navedeno absolutno pot ter preverite pomoč in licenco z računom za varnostne kopije.

Linux potrebuje tudi sistemske knjižnice distribucije, vključno z ICU in OpenSSL; priloženi .NET jih ne vsebuje. V Windows morajo veljavni pravilniki izvajanja dovoljevati skripte 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

Mape, poti in prostor

Prilagodite poti. Izvorna mapa ne sme biti prazna, vsebnik pa mora biti zunaj nje. Enako izhodno ime zamenja prejšnji vsebnik in dele. Zagotovite začasni prostor ob vsebniku in kopijo izvora za načrtovana opravila. Enote temeljijo na 1024; polnilo dodaja bajte.

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

Priprava datotek s skrivnostmi

Skrivnosti ustvarite enkrat, shranite zaščiteno kopijo in omejite dostop do datotek. Primeri zavrnejo zamenjavo obstoječih ključev. Datoteke UTF-8 ohranijo presledke, končne prelome vrstic pa odstranijo. Za stare kopije ohranite izvirne ključ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

Aktivacija in stanje licence

Licenčni ključ je vezan na ID naprave, ki ga izpiše ista gradnja CLI. Če je licenca kopirana na drug PC, jo LockBox zavrne in se vrne na Free.

Windows preverja obstoječe lokacije podatkov aplikacije LockBox. Linux shrani aktivacijo v $XDG_CONFIG_HOME/lockbox/.lockbox.license, nato ~/.config/lockbox/.lockbox.license, z ~/.lockbox/.lockbox.license kot rezervno možnostjo.

.\LockBox.Cli.exe device-id

.\LockBox.Cli.exe license

Aktiviraj iz licenčne datoteke

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

Aktiviraj iz okoljske spremenljivke

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

Aktiviraj v vrstici

Inline aktivacija deluje, vendar lahko uhaja skozi zgodovino lupine ali dnevnike procesov.

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

Linux aktivacija

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

Ravnanje s tajnostmi

Raje uporabljajte okoljske spremenljivke ali datoteke. Vstavljene skrivnosti so uporabne le za testiranje. Glavna gesla in ključi plasti morajo biti ohranjeni: brez njih kontejner ni mogoče odpreti.

Skrivnosti na podlagi datotek

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 in generiranje ključev

Uporabite algorithms, da vidite vse podprte profile in minimalne izdaje. Uporabite keygen za ključe plasti.

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

Podprti nadomestni ukazi:

algorithms
list-algorithms
profiles

keygen
generate-key
generate-keys

Ustvari vsebnike

create stisne izvorno mapo, uporabi po želji stiskanje in polnjenje, šifrira vsebino skozi eno ali več plasti ter zapiše .lbx vsebnik.

Obvezne možnosti

• --source ali -s: izvorna mapa.
• --output ali -o: izhodna .lbx pot.
• --master, --master-env ali --master-file.
• Vsaj ena plast: --layer, --layer-env ali --layer-file.

Minimalni AES vsebnik

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

Stisnjen vsebnik

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

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

Razdeli vsebnik na dele

.\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 del ohranja .lbx. Dodatni deli uporabljajo .lbx1, .lbx2 in tako naprej. Shranite vse dele v enaki mapi.

Primer Max z devetimi plastmi

$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ši izvor po uspešni ročni kreaciji

.\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 izbriše izvorno mapo šele po tem, ko je vsebnik uspešno ustvarjen. Načrtovalnik ima drugačno možnost: --delete-source-contents.

Geslo za uničenje vsebnika

Max različica lahko doda ločeno geslo za uničenje v vsebnik. Če je to geslo kasneje vneseno kot glavno geslo, LockBox takoj prepiše vsebnik brez potrditve. Namenjeno je scenarijem pod prisilo. Hranite ga ločeno od pravega glavnega gesla.

Ukaz preveri prost prostor na disku, šifrira izvorne podatke vsebnika z novim naključnim skrivnim ključem in AES-256-GCM v začasno datoteko, rezultat normalizira na točno prvotno velikost, zamenja izvorno datoteko in pozabi naključni skrivni ključ. Za razdeljene vsebnike se vsak .lbx, .lbx1, .lbx2 del v isti mapi zamenja ob ohranitvi prvotnih velikosti delov.

Ustvarjanje z geslom za uničenje

$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

Sprožitev uničenja brez ključev plasti

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

Sprožitev na Linuxu

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

Po uspešnem uničenju vsebnik ni več veljavna LockBox datoteka. CLI vrne izhodno kodo 0, ker je zahtevana akcija uničenja uspešno zaključena.

Odprtje vsebnikov

open razširi vsebnik v izhodno mapo. Za normalno razširjanje je potrebno posredovati ključe plasti v istem vrstnem redu, kot so bili uporabljeni pri ustvarjanju. Za delovni proces z geslom za uničenje je potrebno le pot do vsebnika, izhodna pot in geslo za uničenje kot glavno geslo.

Odpri enoplastni vsebnik

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

Odpri razdeljen vsebnik

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

Odpri večplastni vsebnik

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

Vzdevki

open
decrypt
extract

Preverjanje kopije z obnovitvijo

Ustvarite majhen testni report.csv. Razširite v novo mapo; v njej ostane ime izvorne mape. Vse dele hranite skupaj in primerjajte z nespremenjenim izvorom. Razširjanje potrebuje začasni prostor za pisanje ob vsebniku. Zaščitite tudi obnovljene 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"

Razporejevalnik

Ukazi razporejevalnika so na voljo v Max izdaji. Shranjujejo celotne metapodatke naloge v šifrirani datoteki .lbxjobs, vključno z izvorno potjo, izhodno potjo, gesli, geslom za uničenje, ključih plasti, stiskanjem, izpolnjevanjem, delitvijo in nastavitvijo za brisanje vsebine izvora.

Načrtovane naloge tečejo le, ko je LockBox.Cli.exe schedule run v teku. Če želite, da se delavec samodejno zažene po ponovnem zagonu, uporabite Windows Task Scheduler, Linux systemd, cron, zavijalec storitev ali dolgo tekočo konzolno sejo.

Frequentne vrednosti

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

Dodaj dnevno šifrirano varnostno kopijo

$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 nalogo, ki po uspehu izbriše vsebino mape izvora

.\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 mesečni arhiv z izpolnjevanjem in deljenimi deli

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

Prikaži shranjene naloge

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

Zaženi delavca razporejevalnika

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

Zaženi zapadle naloge enkrat in izstopi

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

Prikaži zadnji status izvajanja

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

Oznake stanja so [OK], [RUNNING] in [FAILED]. Neuspešna naloga vključuje razlog in uporabnika obvesti, naj se obrne na podporo, če se težava ponovi.

JSON skripti

Uporabite --script, ko potek dela vključuje več korakov. Tekač skriptov podpira create, open, keygen, algorithms, device-id, license in activate.

Ustvari in odpri v enem skriptu

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

Nadaljuj po neuspelem koraku

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

Aktiviraj iz skripta

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

Polja JSON in pravila izvajanja

Tabela povezuje polja create in sezname ključev open z možnostmi CLI. Relativne poti izhajajo iz delovne mape procesa; spremenljivke in datumi se ne nadomestijo. Uporabite en vir skrivnosti na polje. open bere keys, nato keyEnvs in keyFiles. Izberite stopOnError: true; pri false lahko poznejši uspeh prikrije napako. Skripti JSON ne podpirajo ukazov razporejevalnika.

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

Varnostna kopija šifrirane baze podatkov

$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ščita CI artefaktov

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

Varna partnerska predaja

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

Dolgoletni arhiv

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

Primer datoteke paketa

@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 več map

Skript shranite na navedeno pot. Za vsak izvor ustvari vsebnik z enoličnim imenom in dnevnik, ob napaki se ustavi in ohrani izhodno kodo CLI. AES-128-GCM deluje v Free; stiskanje in delitev zahtevata Pro ali 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 brez nadzora

Skript Bash shranite s konci vrstic LF. Pripravite CLI in skrivnosti na navedenih poteh, izvorne mape pa podajte kot argumente. Vsak zagon dobi svojo mapo. Napake pustijo dnevnik in vrnejo neničelno kodo; izvori ostanejo.

/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

Urnik operacijskega sistema

Opravila zaženejo zgornje skripte; taka uporaba create ne zahteva Max. Registracija Windows deluje le ob prijavljenem uporabniku; po potrebi nastavite izvajanje brez prijave v Razporejevalniku opravil. Dodajte cron v crontab računa za kopiranje po preverjanju flock. Oba primera tečeta ob 02:00 po lokalnem času in preprečujeta prekrivanje načrtovanih zagonov. Preverite pravice in preizkusite roč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 razporejevalnika

Ustvarite storitveni račun lockbox z ustreznimi pravicami, aktivirajte Max zanj in pripravite ločeno datoteko gesla UTF-8 jobs.txt. add dodaja, ne posodablja: uporabite enkrat na opravilo. Za datoteko opravil zaženite en proces in ga po spremembah ponovno zaženite. Statusni JSON ne obnovi zgodovine: zamujene ponovitve preskoči, zamujeno opravilo once se lahko ponovi. Za periodične sistemske zagone uporabite create namesto ponavljanja run-once. Razporejevalnik ponovno uporabi izhodno ime.

/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 ukazov

Ustvarjalne možnosti

Možnosti odpiranja

Možnosti razporejevalnika

Z --language ali --lang izberete jezik konzole, z --quiet pa skrijete običajni prikaz napredka; napake se še vedno izpisujejo v standardni tok za napake. Ctrl+C zahteva preklic in vrne kodo 1. Koda 2 pomeni neveljavno skladnjo ukaza; koda 3 pomeni, da funkcija ustvarjanja v trenutni izdaji ni na voljo. Koda 0 zajema tudi namerno sproženo geslo za uničenje, zato sama po sebi ne dokazuje, da so bile datoteke razširjene. Pred naslednjimi koraki avtomatizacije preverite pričakovani izhod.

Izhodne kode in spremljanje

schedule run-once lahko vrne nič tudi ob neuspešnih opravilih; schedule status tudi brez stanja. Preverjajte savedAt, lastSuccessAt in lastError; [OK] lahko pomeni samo Ready. Monitor pričakuje dnevne kopije, preverjanje vsakih 30 sekund in uspeh v 26 urah. Prilagodite pragove. Stanja JSON so števila; --quiet odstrani običajen izpis uspeš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

Odpravljanje težav