LockBox CLI dokumentācija

Ātrā sākšana

Novietojiet LockBox.Cli.exe mapē, kas iekļauta PATH, vai izsauciet to ar pilnu ceļu. --cli marķieris tiek pieņemts saderībai, bet tas nav obligāts tikai CLI versijā.

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

Minimāls izveides un atvēršanas darba plūsmas piemērs:

$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 izmanto tās pašas komandas ar slash ceļiem un bināro failu bez .exe sufiksa:

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 instalēšana un pārbaude

Izpakojiet savai sistēmai un procesoram atbilstošo ZIP. .NET ir iekļauts. Salīdziniet jaucējvērtību ar SHA256SUMS.txt. Novietojiet CLI norādītajā absolūtajā ceļā un pārbaudiet palīdzību un licenci ar rezerves kopiju kontu.

Linux vajag arī izplatījuma sistēmas bibliotēkas, tostarp ICU un OpenSSL; iekļautais .NET tās nenodrošina. Windows spēkā esošajai izpildes politikai jāatļauj PowerShell skripti.

.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

Mapes, ceļi un diska vieta

Pielāgojiet ceļus. Avota mape nedrīkst būt tukša, un konteineram jāatrodas ārpus tās. Tas pats izvades nosaukums aizstāj iepriekšējo konteineru un daļas. Atvēliet pagaidu vietu blakus konteineram un avota kopiju plānotajiem uzdevumiem. Vienību pamatā ir 1024; aizpildījums pievieno baitus.

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

Noslēpumu failu sagatavošana

Ģenerējiet noslēpumus vienreiz, glabājiet aizsargātu kopiju un ierobežojiet failu piekļuvi. Piemēri atsakās aizstāt esošās atslēgas. UTF-8 faili saglabā atstarpes, bet noņem beigu rindu pārtraukumus. Vecām kopijām saglabājiet sākotnējās atslēgas.

$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

Aktivizācija un licences statuss

Licences atslēga ir piesaistīta ierīces ID, ko izdrukā tā pati CLI versija. Ja licence tiek nokopēta uz citu datoru, LockBox to noraida un pārslēdzas uz Free.

Windows pārbauda esošās LockBox lietojumprogrammas datu atrašanās vietas. Linux glabā aktivizāciju $XDG_CONFIG_HOME/lockbox/.lockbox.license, pēc tam ~/.config/lockbox/.lockbox.license, ar ~/.lockbox/.lockbox.license kā rezerves variantu.

.\LockBox.Cli.exe device-id

.\LockBox.Cli.exe license

Aktivizēt no licences faila

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

Aktivizēt no vides mainīgā

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

Aktivizēt tieši

Tieša aktivizācija darbojas, bet tā var noplūst caur šella vēsturi vai procesa žurnāliem.

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

Linux aktivizācija

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

Noslēpumu pārvaldība

Dodiet priekšroku vides mainīgajiem vai failiem. Iekļautie noslēpumi ir noderīgi tikai testēšanai. Galvenās paroles un kārtu atslēgas jāsaglabā: bez tām konteineru nevar atvērt.

Failā balstīti noslēpumi

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 un atslēgu ģenerēšana

Lietojiet algorithms, lai redzētu visus atbalstītos profilus un minimālās izlaiduma versijas. Lietojiet keygen kārtu atslēgām.

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

Atbalstītie komandu aizstājvārdi:

algorithms
list-algorithms
profiles

keygen
generate-key
generate-keys

Izveidot konteinerus

create iepakot avota mapi, piemērot izvēles saspiešanu un polsterējumu, šifrēt ielādējamo saturu caur vienu vai vairākām kārtām un ierakstīt .lbx konteinerā.

Nepieciešamās opcijas

• --source vai -s: avota mape.
• --output vai -o: izvades .lbx ceļš.
• --master, --master-env vai --master-file.
• Vismaz viena kārta: --layer, --layer-env vai --layer-file.

Minimālais AES konteiners

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

Saspiests konteiners

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

Kripto polsterējums

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

Sadalīt konteineru daļās

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

Pirmā daļa saglabā .lbx. Papildu daļas izmanto .lbx1, .lbx2 un tā tālāk. Saglabājiet visas daļas tajā pašā mapē.

Deviņu kārtu Max piemērs

$env:LBX_MASTER = "use-a-long-master-password"
$env:LBX_L1 = "layer-1-key"
$env:LBX_L2 = "layer-2-key"
$env:LBX_L3 = "layer-3-key"
$env:LBX_L4 = "layer-4-key"
$env:LBX_L5 = "layer-5-key"
$env:LBX_L6 = "layer-6-key"
$env:LBX_L7 = "layer-7-key"
$env:LBX_L8 = "layer-8-key"
$env:LBX_L9 = "layer-9-key"

.\LockBox.Cli.exe create `
  --source "D:\Data" `
  --output "E:\Backups\data-max.lbx" `
  --master-env LBX_MASTER `
  --compress `
  --padding 2GB `
  --split 700MB `
  --layer-env AES-256-GCM=LBX_L1 `
  --layer-env CHACHA20-POLY1305=LBX_L2 `
  --layer-env AES-256-CCM=LBX_L3 `
  --layer-env SERPENT-256-CTR-HMACSHA512=LBX_L4 `
  --layer-env TWOFISH-256-CTR-HMACSHA512=LBX_L5 `
  --layer-env CAMELLIA-256-CTR-HMACSHA512=LBX_L6 `
  --layer-env ARIA-256-CTR-HMACSHA512=LBX_L7 `
  --layer-env AES-256-CBC-HMACSHA512=LBX_L8 `
  --layer-env AES-192-OFB-HMACSHA384=LBX_L9

Alternatīva algoritma/atsevišķas atslēgas sintakse

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

Dzēst avotu pēc veiksmīgas manuālas izveides

.\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 dzēš avota mapi tikai pēc tam, kad konteiners ir veiksmīgi izveidots. Plānotājam ir cita opcija: --delete-source-contents.

Konteinera dzēšanas parole

Max izdevums var pievienot konteinera atsevišķu dzēšanas paroli. Ja šī parole tiks ievadīta vēlāk kā galvenā parole, LockBox nekavējoties pārraksta konteinera saturu bez apstiprinājuma. Tas ir paredzēts piespiešanas scenārijiem. Turiet to atsevišķi no īstas galvenās paroles.

Komanda pārbauda brīvo diska vietu, šifrē oriģinālos konteinera datus ar jaunu nejaušu slepeno atslēgu un AES-256-GCM uz pagaidu failu, normalizē rezultātu līdz precīza oriģināla lielumam, aizvieto oriģinālo failu un aizmirst nejaušo slepeno atslēgu. Sadalītajos konteineros katra .lbx, .lbx1, .lbx2 daļa tajā pašā mapē tiek aizvietota, saglabājot oriģinālo daļu lielumus.

Izveidot ar dzēšanas paroli

$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

Aktivizēt dzēšanu bez slāņu atslēgām

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

Linux aktivizēšana

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

Pēc veiksmīgas dzēšanas konteiners vairs nav derīgs LockBox fails. CLI atgriež izejas kodu 0, jo pieprasītā dzēšanas darbība tika veikta veiksmīgi.

Atvērt konteinerus

open izvelk konteineru uz izvades mapi. Parastai izvilkšanai jāiesniedz slāņu atslēgas tajā pašā secībā, kāda tika izmantota izveides laikā. Dzēšanas paroles darbplūsmā ir nepieciešams tikai konteinera ceļš, izvades ceļš un dzēšanas parole kā galvenā parole.

Atvērt vienas slāņa konteineru

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

Atvērt sadalītu konteineru

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

Atvērt daudzslāņu konteineru

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

Aizstājvārdi

open
decrypt
extract

Kopijas pārbaude atjaunojot

Izveidojiet mazu testa report.csv. Izpakojiet jaunā mapē, kuras iekšienē saglabājas avota mapes nosaukums. Turiet visas daļas kopā un salīdziniet ar nemainītu avotu. Izpakošanai vajag rakstāmu pagaidu vietu blakus konteineram. Aizsargājiet arī atjaunotos nešifrētos 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"

Plānotājs

Plānotāja komandas ir pieejamas Max izdevumā. Tās saglabā pilnu uzdevuma metadatu šifrētā .lbxjobs failā, tostarp avota ceļu, izvades ceļu, paroles, dzēšanas paroli, slāņu atslēgas, saspiešanu, pievienošanu, sadalīšanu un iestatījumu dzēst avota saturu.

Ieplānotie darbi darbojas tikai tad, kad LockBox.Cli.exe schedule run ir aktīvs. Izmantojiet Windows uzdevumu plānotāju, Linux systemd, cron, servisa apvalku vai ilgi darbināmu konsoles sesiju, ja nepieciešams, lai darbaspēks tiktu automātiski palaists pēc restartēšanas.

Biežuma vērtības

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

Pievienot ikdienas šifrētu rezerves uzdevumu

$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

Pievienot uzdevumu, kas pēc veiksmīgas izpildes dzēš avota mapes saturu

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

Pievienot ikmēneša arhīvu ar pievienošanu un sadalītām daļām

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

Sarakstīt saglabātos uzdevumus

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

Palaist plānotāja darbaspēku

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

Palaist gaidāmos uzdevumus vienreiz un iziet

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

Rādīt jaunāko izpildes statusu

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

Statusa marķieri ir [OK], [RUNNING] un [FAILED]. Neizdevušos uzdevumā ietver iemeslu un informē lietotāju sazināties ar atbalstu, ja problēma atkārtojas.

JSON skripti

Izmantojiet --script, kad darba plūsmā ir vairāki soļi. Skriptu palaidējs atbalsta create, open, keygen, algorithms, device-id, license un activate.

Izveidot un atvērt vienā skriptā

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

Turpināt pēc neizdevušā soļa

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

Aktivizēt no skripta

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

JSON lauki un izpildes noteikumi

Tabula sasaista create laukus un open atslēgu masīvus ar CLI opcijām. Relatīvie ceļi sākas procesa darba direktorijā; mainīgie un datumi netiek aizvietoti. Katram laukam izmantojiet vienu noslēpuma avotu. open lasa keys, tad keyEnvs un keyFiles. Izvēlieties stopOnError: true; ar false vēlāks panākums var slēpt kļūdu. JSON skripti neatbalsta plānotāja komandas.

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

Automatizācijas receptes

Šifrētas datubāzes izgūšanas dublējums

$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 artefaktu aizsardzība

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

Droša partnera pārsūtīšana

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

Ilgtermiņa arhīvs

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

Partijas faila piemērs

@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: vairāku mapju kopēšana

Saglabājiet skriptu norādītajā ceļā. Katram avotam tas izveido unikāli nosauktu konteineru un žurnālu, apstājas kļūdas gadījumā un saglabā CLI izejas kodu. AES-128-GCM darbojas Free; saspiešanai un sadalīšanai vajag Pro vai 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: kopēšana bez uzraudzības

Saglabājiet Bash skriptu ar LF rindu beigām. Sagatavojiet CLI un noslēpumus norādītajos ceļos, avota mapes nododiet kā argumentus. Katra palaišana iegūst savu direktoriju. Kļūdas atstāj žurnālu un atgriež nenulles kodu; avoti saglabājas.

/srv/lockbox/backup.sh

#!/bin/bash
set -eu
umask 077
cli=/opt/lockbox/LockBox.Cli
secret_dir=/srv/lockbox/secrets
backup_root=/backup
mkdir -p "$backup_root"
if [ "$#" -eq 0 ]; then
    set -- /srv/data
fi
for source in "$@"; do
    run_dir=$(mktemp -d "$backup_root/$(date -u +%Y%m%d-%H%M%S)-XXXXXX")
    container="$run_dir/data.lbx"
    log="$run_dir/create.log"
    "$cli" --quiet create \
        --source "$source" \
        --output "$container" \
        --master-file "$secret_dir/master.txt" \
        --layer-file "AES-128-GCM=$secret_dir/layer1.txt" > "$log" 2>&1 || {
        result=$?
        cat "$log" >&2
        exit "$result"
    }
    test -s "$container"
    printf '%s\n' "$container"
done

/bin/bash /srv/lockbox/backup.sh /srv/data /srv/reports

Plānošana operētājsistēmā

Uzdevumi palaiž iepriekšējos skriptus; šādai create izmantošanai Max nav vajadzīgs. Windows reģistrācija darbojas tikai ar pieteiktu lietotāju; vajadzības gadījumā Uzdevumu plānotājā iestatiet darbu bez pieteikšanās. Pievienojiet cron rezerves kopiju lietotāja crontab pēc flock pārbaudes. Abi piemēri darbojas 02:00 pēc vietējā laika un novērš plānoto palaišanu pārklāšanos. Pārbaudiet tiesības un izmēģiniet manuāli.

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: plānotāja uzturēšana

Izveidojiet pakalpojuma kontu lockbox ar vajadzīgajām tiesībām, aktivizējiet tam Max un sagatavojiet atsevišķu UTF-8 paroles failu jobs.txt. add pievieno, nevis atjaunina: izmantojiet vienreiz katram uzdevumam. Darbiniet vienu procesu uzdevumu failam un pārstartējiet pēc izmaiņām. Statusa JSON neatjauno vēsturi: nokavēti atkārtojumi tiek izlaisti, nokavēts once uzdevums var palaisties vēlreiz. Periodiskām sistēmas palaišanām izmantojiet create, nevis atkārtotu run-once. Plānotājs atkārtoti izmanto izvades nosaukumu.

/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

Komandu atsauce

Izveides opcijas

Atvērt opcijas

Plānotāja opcijas

Izmantojiet --language vai --lang konsoles valodas izvēlei un --quiet ierastā progresa slēpšanai; kļūdas joprojām tiek izvadītas standarta kļūdu plūsmā. Ctrl+C pieprasa atcelšanu un atgriež kodu 1. Kods 2 nozīmē nederīgu komandas sintaksi; kods 3 nozīmē, ka izveides funkcija nav pieejama pašreizējā versijā. Kods 0 ietver arī apzināti aktivizētu iznīcināšanas paroli, tāpēc pats par sevi nepierāda, ka faili ir izvilkti. Pirms nākamajiem automatizācijas soļiem pārbaudiet gaidīto izvadi.

Izejas kodi un uzraudzība

schedule run-once var atgriezt nulli arī ar neveiksmīgiem uzdevumiem; schedule status arī bez statusa. Pārbaudiet savedAt, lastSuccessAt un lastError; [OK] var nozīmēt tikai Ready. Monitors paredz ikdienas kopijas, pārbaudes ik pēc 30 sekundēm un panākumu 26 stundu laikā. Pielāgojiet sliekšņus. JSON stāvokļi ir skaitļi; --quiet slēpj sekmīgu create/open parasto izvadi.

$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

Problēmu novēršana