„LockBox“ CLI dokumentacija

Greitas pradėjimas

Įdėkite LockBox.Cli.exe į aplanką, įtrauktą į PATH, arba kvieskite jį pilnu keliu. --cli žymeklis priimamas suderinamumui, bet jis nėra būtinas tik CLI versijoje.

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

Minimalus kūrimo ir atidarymo darbo procesas:

$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 naudoja tas pačias komandas su pasviraisiais keliais ir dvejetainiu failu be .exe priesagos:

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 diegimas ir patikra

Išskleiskite sistemai ir procesoriui tinkamą ZIP. .NET įtrauktas. Palyginkite maišą su SHA256SUMS.txt. Įkelkite CLI į nurodytą absoliutų kelią ir patikrinkite pagalbą bei licenciją atsarginių kopijų paskyra.

Linux taip pat reikia platinimo sisteminių bibliotekų, įskaitant ICU ir OpenSSL; pridėtas .NET jų nepateikia. Windows galiojanti vykdymo politika turi leisti PowerShell scenarijus.

.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

Aplankai, keliai ir vieta

Pritaikykite kelius. Šaltinio aplankas negali būti tuščias, o konteineris turi būti už jo ribų. Tas pats išvesties vardas pakeičia ankstesnį konteinerį ir dalis. Palikite laikinos vietos prie konteinerio ir šaltinio kopiją suplanuotoms užduotims. Vienetų pagrindas yra 1024; užpildas prideda baitų.

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

Paslapčių failų paruošimas

Paslaptis sugeneruokite vieną kartą, išsaugokite apsaugotą kopiją ir ribokite prieigą prie failų. Pavyzdžiai nekeičia esamų raktų. UTF-8 failuose tarpai išlieka, bet galutiniai eilučių lūžiai pašalinami. Senoms kopijoms išsaugokite pradinius raktus.

$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

Aktyvacija ir licencijos statusas

Licencijos raktas yra pririštas prie įrenginio ID, atspausdinto tuo pačiu CLI kūrimu. Jei licencija nukopijuojama į kitą kompiuterį, LockBox ją atmeta ir pereina prie Free versijos.

Windows tikrina esamas LockBox programos duomenų vietas. Linux aktyvaciją saugo $XDG_CONFIG_HOME/lockbox/.lockbox.license, tada ~/.config/lockbox/.lockbox.license, o ~/.lockbox/.lockbox.license veikia kaip atsarginė parinktis.

.\LockBox.Cli.exe device-id

.\LockBox.Cli.exe license

Aktyvuoti iš licencijos failo

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

Aktyvuoti iš aplinkos kintamojo

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

Aktyvuoti tiesiogiai

Tiesioginė aktyvacija veikia, tačiau gali nutekėti per shell istoriją ar proceso žurnalus.

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

Linux aktyvacija

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

Slaptų duomenų tvarkymas

Pirmenybę teikite aplinkos kintamiesiems arba failams. Įterpti slaptus duomenis naudinga tik testavimui. Pagrindiniai slaptažodžiai ir sluoksnių raktai turi būti išsaugoti: be jų konteinerio negalima atidaryti.

Failais pagrįsti slaptieji duomenys

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

Algoritmai ir raktų generavimas

Naudokite algorithms, kad pamatytumėte visus palaikomus profilius ir minimalią versiją. Naudokite keygen, sluoksnių raktams.

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

Palaikomos komandų santrumpos:

algorithms
list-algorithms
profiles

keygen
generate-key
generate-keys

Sukurti konteinerius

create supakuoja šaltinio aplanką, pritaiko pasirenkamą suspaudimą ir užpildymą, užšifruoja duomenis per vieną ar kelias sluoksnius ir įrašo .lbx konteinerį.

Privalomi parametrai

• --source arba -s: šaltinio aplankas.
• --output arba -o: išvesties .lbx kelias.
• --master, --master-env arba --master-file.
• Bent vienas sluoksnis: --layer, --layer-env arba --layer-file.

Minimalus AES konteineris

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

Suspaustas konteineris

.\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 užpildas

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

Suskirstyti konteinerį į dalis

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

Pirmoji dalis išlaiko .lbx. Papildomos dalys naudoja .lbx1, .lbx2 ir t. t. Laikykite visas dalis tame pačiame aplanke.

Devynių sluoksnių Max pavyzdys

$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

Alternatyvi algoritmo/rakto sintaksė

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

Ištrinti šaltinį po sėkmingo rankinio kūrimo

.\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 ištrina šaltinio aplanką tik po to, kai konteineris sėkmingai sukurtas. Tvarkaraščio parinktis yra kitokia: --delete-source-contents.

Konteinerio sunaikinimo slaptažodis

Max versija gali pridėti atskirą sunaikinimo slaptažodį prie konteinerio. Jei vėliau įvedamas šis slaptažodis kaip pagrindinis slaptažodis, LockBox iš karto perrašo konteinerį be patvirtinimo. Tai skirta prievartos situacijoms. Laikykite jį atskirai nuo tikrojo pagrindinio slaptažodžio.

Komanda tikrina laisvą disko vietą, užšifruoja originalius konteinerio duomenis su nauju atsitiktiniu paslaptimi ir AES-256-GCM į laikino failo vietą, normalizuoja rezultatą iki tikslios originalios dydžio, pakeičia originalų failą ir pamiršta atsitiktinę paslaptį. Jei konteineriai yra padalyti į dalis, kiekviena .lbx, .lbx1, .lbx2 dalis tą pačią aplanką yra pakeista išlaikant originalų dalių dydžius.

Sukurti su sunaikinimo slaptažodžiu

$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

Suaktyvinti sunaikinimą be sluoksnių raktų

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

Linux suaktyvinimas

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

Po sėkmingo sunaikinimo konteineris nebe yra galiojantis LockBox failas. CLI grąžina išeigos kodą 0, nes prašyta sunaikinimo veiksmas buvo sėkmingai atliktas.

Atidaryti konteinerius

open išskleidžia konteinerį į išvesties aplanką. Gali būti atliekamas įprastas išskleidimas, sluoksnių raktai turi būti pateikti tokia pat tvarka, kaip naudojant kuriant. Sunaikinimo slaptažodžio darbo eiga reikalauja tik konteinerio kelio, išvesties kelio ir sunaikinimo slaptažodžio kaip pagrindinio slaptažodžio.

Atidaryti vieno sluoksnio konteinerį

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

Atidaryti padalintą konteinerį

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

Atidaryti daugiasluoksnį 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

Aliasingai

open
decrypt
extract

Kopijos patikra atkuriant

Sukurkite mažą bandomąjį report.csv. Išskleiskite į naują aplanką, kuriame lieka šaltinio aplanko vardas. Laikykite visas dalis kartu ir palyginkite su nepakeistu šaltiniu. Išskleidimui reikia rašomos laikinos vietos prie konteinerio. Apsaugokite ir atkurtus nešifruotus failus.

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

Tvarkaraštis

Tvarkaraščio komandos prieinamos Max leidime. Jos saugo visą užduoties metaduomenų informaciją šifruotame .lbxjobs faile, įskaitant šaltinio kelią, išvesties kelią, slaptažodžius, sunaikinimo slaptažodį, sluoksnių raktus, suspaudimą, užpildymą, dalijimą ir nustatymą ištrinti šaltinio turinį.

Planuojamos užduotys vykdomos tik kai LockBox.Cli.exe schedule run veikia. Naudokite Windows užduočių tvarkytuvę, Linux systemd, cron, paslaugų aplanką arba ilgai veikiančią konsolės sesiją, jei reikia, kad darbo vykdytojas automatiškai pradėtų veikti po paleidimo iš naujo.

Dažnumo reikšmės

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

Pridėti kasdienę šifruotą atsarginę užduotį

$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

Pridėti užduotį, kuri sėkmingai įvykdžius ištrina šaltinio aplanko turinį

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

Pridėti mėnesinį archyvą su užpildymu ir padalytais failais

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

Rodyti išsaugotas užduotis

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

Paleisti tvarkaraščio darbo vykdytoją

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

Vykdyti pritaikytas užduotis vieną kartą ir išeiti

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

Rodyti naujausią vykdymo būseną

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

Būsenos žymekliai yra [OK], [RUNNING] ir [FAILED]. Nepavykusi užduotis nurodo priežastį ir pataria vartotojui susisiekti su palaikymu, jei problema pasikartoja.

JSON scenarijai

Naudokite --script, kai darbotvarkėje yra kelios eilutės. Scenarijų vykdytojas palaiko create, open, keygen, algorithms, device-id, license ir activate.

Sukurti ir atidaryti viename scenarijuje

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

Tęsti po nepavykusio žingsnio

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

Aktyvuoti iš scenarijaus

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

JSON laukai ir vykdymo taisyklės

Lentelė sieja create laukus ir open raktų masyvus su CLI parinktimis. Santykiniai keliai prasideda proceso darbo kataloge; kintamieji ir datos nepakeičiami. Laukui naudokite vieną paslapties šaltinį. open skaito keys, tada keyEnvs ir keyFiles. Rinkitės stopOnError: true; su false vėlesnė sėkmė gali paslėpti klaidą. JSON scenarijai nepalaiko planuoklio komandų.

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

Automatizavimo receptai

Užšifruoto duomenų bazės atsarginės kopijos kūrimas

$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 artefaktų apsauga

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

Saugus partnerių perdavimas

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

Ilgalaikis archyvas

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

Partijų bylos pavyzdys

@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: kelių aplankų kopijos

Išsaugokite scenarijų nurodytu keliu. Kiekvienam šaltiniui jis sukuria unikaliai pavadintą konteinerį ir žurnalą, sustoja įvykus klaidai ir išsaugo CLI išėjimo kodą. AES-128-GCM veikia su Free; glaudinimui ir skaidymui reikia Pro arba 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: kopijos be priežiūros

Išsaugokite Bash scenarijų su LF eilučių pabaigomis. Paruoškite CLI ir paslaptis nurodytais keliais, šaltinio aplankus perduokite argumentais. Kiekvienas vykdymas gauna atskirą katalogą. Klaidos palieka žurnalą ir grąžina nenulinį kodą; šaltiniai išlieka.

/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

Operacinės sistemos tvarkaraštis

Užduotys paleidžia aukščiau pateiktus scenarijus; tokiam create naudojimui Max nereikia. Windows registracija veikia tik prisijungus vartotojui; prireikus Užduočių planuoklyje nustatykite darbą atsijungus. Pridėkite cron į kopijų paskyros crontab ir patikrinkite flock. Abu pavyzdžiai vykdomi 02:00 vietos laiku ir neleidžia suplanuotiems vykdymams persidengti. Patikrinkite teises ir išbandykite rankiniu būdu.

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: planuoklio priežiūra

Sukurkite tarnybos paskyrą lockbox su reikiamomis teisėmis, aktyvinkite jai Max ir paruoškite atskirą UTF-8 slaptažodžio failą jobs.txt. add prideda, o ne atnaujina: naudokite kartą užduočiai. Vienam užduočių failui paleiskite vieną procesą ir po pakeitimų paleiskite iš naujo. Būsenos JSON neatkuria istorijos: praleisti pasikartojimai praleidžiami, pavėluota once užduotis gali veikti vėl. Periodiniams sistemos paleidimams naudokite create, ne kartojamą run-once. Planuoklis pakartotinai naudoja išvesties vardą.

/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

Komandų nuoroda

Sukurti parinktis

Atidaryti parinktis

Tvarkaraščio parinktys

Naudokite --language arba --lang konsolės kalbai pasirinkti ir --quiet įprastai eigos informacijai paslėpti; klaidos vis tiek siunčiamos į standartinį klaidų srautą. Ctrl+C prašo atšaukti ir grąžina kodą 1. Kodas 2 reiškia netinkamą komandos sintaksę; kodas 3 reiškia, kad kūrimo funkcija dabartinėje versijoje nepasiekiama. Kodas 0 taip pat apima tyčia suaktyvintą sunaikinimo slaptažodį, todėl vien jis neįrodo, kad failai buvo išskleisti. Prieš kitus automatizavimo veiksmus patikrinkite laukiamą išvestį.

Išėjimo kodai ir stebėjimas

schedule run-once gali grąžinti nulį ir nepavykus užduočiai; schedule status taip pat be būsenos. Tikrinkite savedAt, lastSuccessAt ir lastError; [OK] gali reikšti tik Ready. Stebėjimas numato kasdienes kopijas, tikrinimą kas 30 sekundžių ir sėkmę per 26 valandas. Pritaikykite ribas. JSON būsenos yra skaičiai; --quiet slepia įprastą sėkmingų create/open išvestį.

$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

Trikčių šalinimas