LockBox CLI dokumentatsioon

Kiire algus

Pane LockBox.Cli.exe PATH kausta, või nimeta seda täielikuks teeks. --cli marker aktsepteeritakse ühilduvuse tõttu kuid see ei ole nõutav ainult CLI-põhises versioonis.

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

Minimaalne loomise ja avatud töövoog:

$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 kasutab samu käske kaldkriipsuga ja binaariga ilma .exe järelliiteta:

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

CLI paigaldamine ja kontroll

Paki lahti süsteemile ja protsessorile sobiv ZIP. .NET on kaasas. Võrdle räsi failiga SHA256SUMS.txt. Paiguta CLI allpool näidatud absoluutsele teele ning kontrolli abi ja litsentsi varunduskontoga.

Linux vajab ka distributsiooni süsteemiteeke, sealhulgas ICU ja OpenSSL; kaasasolev .NET neid ei sisalda. Windowsis peab kehtiv käivituspoliitika lubama PowerShelli 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

Kaustad, teed ja kettaruum

Kohanda teed. Lähtekaust ei tohi olla tühi ning konteiner peab asuma väljaspool seda. Sama väljundnimi asendab eelmise konteineri ja osad. Varu ajutist ruumi konteineri kõrval ning lähtekoopia ajastatud töödele. Suurusühikute alus on 1024; täide lisab baite.

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

Saladusfailide ettevalmistamine

Loo saladused üks kord, hoia kaitstud varukoopiat ja piira failidele juurdepääsu. Näited keelduvad olemasolevaid võtmeid asendamast. UTF-8-failid säilitavad tühikud, kuid eemaldavad lõpu reavahetused. Vanade varukoopiate jaoks säilita algsed võtmed.

$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

Aktiveerimine ja litsentsi staatus

Litsentsivõti on seotud seadme ID-ga, mis on trükitud sama CLI versiooni poolt. Kui litsents kopeeritakse teisele arvutile, keelab LockBox selle ja lülitub üle tasuta versioonile.

Windows kontrollib olemasolevaid LockBoxi rakenduse andmete asukohti. Linux salvestab aktiveerimise $XDG_CONFIG_HOME/lockbox/.lockbox.license, siis ~/.config/lockbox/.lockbox.license, kasutades ~/.lockbox/.lockbox.license varuvõimalusena.

.\LockBox.Cli.exe device-id

.\LockBox.Cli.exe license

Aktiveerimine litsentsifailist

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

Aktiveerimine keskkonnamuutujast

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

Inline-aktiveerimine

Inline-aktiveerimine töötab, kuid see võib lekkida shelli ajaloo või protsessi logide kaudu.

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

Linuxi aktiveerimine

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

Salajaste käsitlemine

Soovitatakse kasutada keskkonnamuutujaid või faile. Inline-salajased andmed on kasulikud ainult testimiseks. Põhijuhised ja kihi-võtmed tuleb säilitada: ilma nendeta konteinerit ei saa avada.

Failipõhised salajased andmed

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

Algoritmid ja võtmete genereerimine

Kasutage algorithms, et näha kõiki toetatud profiile ja minimaalset versiooni. Kasutage keygen kihi-võtmete jaoks.

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

Toetatud käsualiasid:

algorithms
list-algorithms
profiles

keygen
generate-key
generate-keys

Loo konteinerid

create pakib lähtekausta, rakendab valikulist tihendamist ja padimist, krüpteerib sisu ühes või mitmes kihis ning kirjutab .lbx konteineri.

Nõutavad valikud

• --source või -s: lähtekaust.
• --output või -o: väljundi .lbx tee.
• --master, --master-env või --master-file.
• Vähemalt üks kiht: --layer, --layer-env või --layer-file.

Minimaalne AES-konteiner

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

Tihendatud konteiner

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

Krüpto padimine

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

Jaga konteiner osadeks

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

Esimene osa hoiab .lbx. Täiendavad osad kasutavad .lbx1, .lbx2 jne. Hoia kõik osad samas kaustas.

Üheksa kihi Max näide

$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

Alternatiivne algoritmi/võtme süntaks

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

Kustuta lähtekaust pärast manuaalse loomise edukust

.\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 kustutab lähtekausta alles pärast konteineri edukat loomist. Ajastajal on erinev valik: --delete-source-contents.

Konteineri kustutamise parool

Max edition võib konteinerile lisada eraldi kustutamise parooli. Kui see parool hiljem sisestatakse peaparoolina, kirjutab LockBox konteineri kohe üle ilma kinnitust küsimata. See on mõeldud sundolukordade jaoks. Hoidke see eraldi tegelikust peaparoolist.

Käsk kontrollib vaba kettaruumi, krüpteerib originaalse konteineri andmed uue juhusliku saladuse ja AES-256-GCM abil ajutisse faili, normaliseerib tulemuse täpselt originaalfile suuruseks, asendab originaalfaili ja unustab juhusliku saladuse. Jagatud konteinerite puhul asendatakse iga .lbx, .lbx1, .lbx2 osa samas kaustas, säilitades originaalosade suurused.

Loo kustutamise parooliga

$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

Käivita kustutamine ilma kihivõtmeta

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

Linuxi käivitamine

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

Pärast edukat kustutamist ei ole konteiner enam kehtiv LockBox fail. CLI tagastab väljundkoodi 0, kuna soovitud kustutamistoiming lõpetati edukalt.

Konteinerite avamine

open ekstraheerib konteineri väljundkausta. Normaalseks ekstraheerimiseks tuleb kihivõtmed edastada samas järjekorras, nagu neid loomiseks kasutati. Kustutamise paroolitöövoo puhul on vaja ainult konteineri rada, väljundrada ja kustutamise parool peaparoolina.

Ava ühekihiline konteiner

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

Ava jagatud konteiner

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

Ava mitmekihiline konteiner

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

Aliasid

open
decrypt
extract

Varukoopia kontroll taastamisega

Loo väike testfail report.csv. Paki lahti uude kausta, mille sees säilib lähtekausta nimi. Hoia kõik osad koos ja võrdle muutmata lähtega. Lahtipakkimine vajab kirjutatavat ajutist ruumi konteineri kõrval. Kaitse ka taastatud krüptimata faile.

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

Ajakava

Ajakava käske on saadaval Max versioonis. Need salvestavad kogu ülesande metaandmed krüpteeritud .lbxjobs faili, sealhulgas allika tee, väljundi tee, paroolid, hävitamise parool, kihi võtmed, pakkimine, täitmine, jagamine ja kustuta-allika-sisu seade.

Ajastatud tööd töötavad ainult siis, kui LockBox.Cli.exe schedule run töötab. Kasuta Windowsi Task Schedulerit, Linuxi systemd-d, cron-i, teenuseümbrist või pikaajalist konsooli seanssi, kui vajad, et töödejuhataja käivituks automaatselt pärast taaskäivitust.

Sageduse väärtused

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

Lisa igapäevane krüpteeritud varundustöö

$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

Lisa töö, mis kustutab allikakausta sisu peale edukust

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

Lisa igakuine arhiiv koos täitmise ja jagatud osadega

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

Loetle salvestatud tööd

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

Käivita ajakava töötaja

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

Käivita tähtaegsed tööd korraga ja välju

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

Kuva viimase jooksu olek

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

Olekumärgid on [OK], [RUNNING] ja [FAILED]. Ebaõnnestunud töö sisaldab põhjust ja teatab kasutajale, et võtaks ühendust tugiteenusega, kui probleem kordub.

JSON skriptid

Kasuta --script, kui töövoos on mitu sammu. Skriptide käitaja toetab create, open, keygen, algorithms, device-id, license ja activate.

Loo ja ava ühes skriptis

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

Jätka pärast ebaõnnestunud sammu

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

Aktiveeri skriptist

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

JSON-väljad ja täitmisreeglid

Tabel seob create-väljad ja open-võtmemassiivid CLI-valikutega. Suhtelised teed algavad protsessi töökataloogist; muutujaid ega kuupäevi ei asendata. Kasuta üht saladuse allikat välja kohta. open loeb keys, siis keyEnvs ja keyFiles. Eelista stopOnError: true; false korral võib hilisem edu peita varasema vea. JSON-skriptid ei toeta ajastaja käske.

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

Automatiseerimise retseptid

Krüpteeritud andmebaasi väljavõtte varukoopia

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

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

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

CI artefakti kaitse

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

Turvaline partneri ülekand

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

Pikaajaline arhiiv

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

Pakifaili näide

@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: mitme kausta varundamine

Salvesta skript näidatud teele. See loob igale allikale kordumatu nimega konteineri ja logi, peatub vea korral ning säilitab CLI väljumiskoodi. AES-128-GCM töötab Free väljaandes; tihendamine ja tükeldamine nõuavad Pro või Max väljaannet.

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: järelevalveta varundamine

Salvesta Bash-skript LF-reavahetustega. Valmista CLI ja saladused näidatud teedel ette ning anna lähtekaustad argumentidena. Iga käivitus saab oma kataloogi. Vead jätavad logi ja tagastavad nullist erineva koodi; lähtefailid säilivad.

/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

Ajastamine operatsioonisüsteemiga

Tööd käivitavad ülaltoodud skriptid; selline create kasutus ei vaja Maxi. Windowsi registreering töötab vaid sisselogitud kasutajaga; vajadusel seadista väljalogitud töö Task Scheduleris. Lisa cron varunduskonto crontabi ja kontrolli flocki olemasolu. Mõlemad näited käivituvad kohaliku aja järgi 02:00 ning väldivad ajastatud käivituste kattumist. Kontrolli õigusi ja testi käsitsi.

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: ajastaja haldamine

Loo vajalike õigustega teenusekonto lockbox, aktiveeri sellele Max ja valmista eraldi UTF-8-paroolifail jobs.txt. add lisab, mitte ei uuenda: kasuta üks kord töö kohta. Käivita üks protsess tööfaili kohta ja taaskäivita pärast muudatusi. Oleku-JSON ei taasta ajalugu: hilinenud kordused jäetakse vahele, hilinenud once-töö võib uuesti käivituda. Perioodiliste süsteemikäivituste jaoks kasuta create, mitte korduvat run-once. Ajastaja kasutab sama väljundnime uuesti.

/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

Käskude viide

Loo valikud

Ava valikud

Ajastaja valikud

Kasutage --language või --lang konsooli keele valimiseks ja --quiet tavapärase edenemisinfo peitmiseks; vead lähevad endiselt standardsesse veavoogu. Ctrl+C taotleb tühistamist ja tagastab koodi 1. Kood 2 tähendab vigast käsusüntaksit; kood 3 tähendab, et loomise funktsioon pole praeguses väljaandes saadaval. Kood 0 hõlmab ka tahtlikult käivitatud hävitamisparooli, seega ei tõenda see üksi failide ekstraktimist. Kontrollige oodatud väljundit enne automatiseerimise järgmisi samme.

Väljumiskoodid ja jälgimine

schedule run-once võib tagastada nulli ka töövea korral; schedule status ka puuduva oleku korral. Kontrolli savedAt, lastSuccessAt ja lastError; [OK] võib tähendada üksnes Ready. Monitor eeldab igapäevaseid koopiaid, päringuid iga 30 sekundi järel ja edu 26 tunni jooksul. Kohanda lävesid. JSON-olekud on arvud; --quiet peidab edukate create/open tavaväljundi.

$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

Tõrkeotsing