Atgal į LockBox

„LockBox“ CLI dokumentacija

CLI Windows ir Linux: konteinerių kūrimas, tikrinimas ir išskleidimas, automatinės kopijos ir JSON scenarijai. Tikrinimas veikia visuose leidimuose.

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.

Gauti įrenginio ID

.\LockBox.Cli.exe device-id

Tikrinti dabartinę redakciją

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

PaskirtisTiesiogiaiAplinkaFailas
Pagrindinis slaptažodis--master value--master-env ENV--master-file path
Sukurti sluoksnio raktą--layer ALG=KEY--layer-env ALG=ENV--layer-file ALG=FILE
Atidaryti sluoksnio raktą--key value--key-env ENV--key-file path
Tvarkaraščio failo slaptažodis--password value--password-env ENV--password-file path
Konteinerio naikinimo slaptažodis--destruction-password value--destruction-password-env ENV--destruction-password-file path
Licencijos raktas--license value--license-env ENV--license-file path

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

Konteineriams, sukurtiems naudojant sluoksnių slaptažodžius:

Sukurti konteinerius

Kūrimas supakuoja šaltinio aplanką, pasirinktinai suglaudina, šifruoja sluoksniais ir įrašo konteinerį. Pasirenkamas atsitiktinis užpildas pridedamas už šifruotų duomenų ribų.

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 `
  --verify-after-create --delete-source

--delete-source ištrina šaltinio aplanką tik po to, kai konteineris sėkmingai sukurtas. Tvarkaraščio parinktis yra kitokia: --delete-source-contents.

Šifruoti atsitiktiniais raktais

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.

Konteineriams, sukurtiems naudojant sluoksnių slaptažodžius:

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

Šifruoti atsitiktiniais raktais

Tikrinti konteinerį

Tikrinkite metaduomenis, konteinerio dalis, kiekvieną šifravimo sluoksnį ir failų kontrolines sumas. Pasiekiama Free, Pro ir Max leidimuose Windows, Android bei CLI.

Konteineriams, sukurtiems naudojant sluoksnių slaptažodžius: Interaktyvus terminalas prašo slaptažodžių ir raktų nerodydamas įvesties. Automatizavimui juos būtina aiškiai pateikti sluoksnių tvarka. Išvesties aplanko nereikia. Kodai: 0 tinkamas, 1 klaida ar atšaukimas, 2 neteisingi argumentai. Išvesties peradresavimas gali išsaugoti ataskaitą.

.\LockBox.Cli.exe verify "E:\Backups\data.lbx"
.\LockBox.Cli.exe verify --container "E:\Backups\data.lbx" --master-env LBX_MASTER --key-env LBX_L1
./LockBox.Cli verify /backup/data.lbx --master-env LBX_MASTER --key-env LBX_L1

Tikrinti konteinerį po sukūrimo

Įjunkite tikrinimą po kūrimo automatinei atsarginių kopijų patikrai. Šaltinis pašalinamas tik po sėkmės; klaida arba atšaukimas jį išsaugo. Integruotam planuokliui vis dar reikia Max.

./LockBox.Cli create --source /srv/data --output /backup/data.lbx --master-env LBX_MASTER --layer-env AES-128-GCM=LBX_L1 --verify-after-create
./LockBox.Cli schedule add --tasks /backup/daily.lbxjobs --password-env LBX_JOBS --name daily --frequency daily --start "$(date -d 'tomorrow 02:00' +%Y-%m-%dT%H:%M:%S)" --source /srv/data --output /backup/daily.lbx --master-env LBX_MASTER --layer-env AES-128-GCM=LBX_L1 --verify-after-create
{
  "stopOnError": true,
  "commands": [
    {
      "command": "create",
      "source": "/srv/data",
      "output": "/backup/data.lbx",
      "masterPasswordEnv": "LBX_MASTER",
      "layers": [{ "algorithm": "AES-128-GCM", "keyEnv": "LBX_L1" }],
      "verifyAfterCreate": true
    },
    {
      "command": "verify",
      "container": "/backup/data.lbx",
      "masterPasswordEnv": "LBX_MASTER",
      "keyEnvs": ["LBX_L1"]
    }
  ]
}

Tikrinimas vyksta atmintyje. Iššifruoti duomenys ir ataskaita diske neišsaugomi. Android gali talpykloje laikyti šifruotas dalis. Tikrinimo seansai ir ataskaitos neišsaugomi. Sistemos mainų atmintis ir atminties išklotinės nepatenka į šią garantiją.

Tinkamas rezultatas patvirtina archyvo vientisumą, ne atitiktį pradiniam aplankui. Formatas neautentifikuoja atsitiktinio užpildo ar sunaikinimo slaptažodžio tikrinimo reikšmės. Tikrinimas niekada nepaleidžia sunaikinimo.

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 `
  --verify-after-create --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.

Šifruoti atsitiktiniais raktais

Windows, Android ir CLI: Free, Pro ir Max pagal leidimo apribojimus. Neveikia planuoklyje ir greitai kuriant per Explorer.

Nereikia kurti ar įsiminti sluoksnių slaptažodžių. Išsaugokite raktų archyvą ir jo slaptažodį; metaduomenims vis tiek reikia pagrindinio slaptažodžio.

  1. Pirmame vedlio lange įjunkite atsitiktinius raktus ir pasirinkite algoritmus. Sukūrę išsaugokite raktų archyvą ir nukopijuokite jo slaptažodį prieš uždarydami programą. Pagrindinis slaptažodis tebėra privalomas.
  2. Išsaugokite archyvą tiesiai USB atmintinėje ar kitoje išimamoje laikmenoje, kad kompiuteryje neliktų kopijos. Slaptažodį laikykite atskirai. LockBox niekada neįrašo išpakuotų raktų į diską.
  3. Įkelkite raktų archyvą ir jo slaptažodį visiems sluoksniams arba pasirinkite atskirą rakto failą kiekviename iššifravimo žingsnyje.

AES-256 ZIP yra užšifruotas keys.zip: raktų pavadinimai ir skaičius paslėpti. Kitomis archyvavimo programomis reikia išskleisti du kartus. key_1.lbxkey skirtas pirmam iššifravimo veiksmui, išoriniam sluoksniui. Importuodami archyvą nekeiskite failų pavadinimų.

Atsitiktiniai raktai yra stiprūs, tačiau praradus archyvą ar jo slaptažodį prarandama prieiga prie duomenų. Laikykite juos saugiai ir prieinamus. Įsiminti slaptažodžiai turi pranašumą prieš užrašytas paslaptis. Atsitiktiniai raktai nesuderinami su konteinerio sunaikinimu. Raktų režimu ši funkcija išjungta.

Šaltinį galima trinti tik išsaugojus ir patikrinus raktų archyvą.

CLI išsaugo į --keys-archive ir pateikia slaptažodį net su --quiet. Kartokite --key-file iššifravimo tvarka: key_1, key_2… Naudokite --keys-archive-password-env, kad slaptažodis nepatektų į komandų istoriją.

./LockBox.Cli create --source /data/source --output /backup/data.lbx --master-env LBX_MASTER --random-keys --algorithm AES-128-GCM --keys-archive /media/usb/data-keys.zip --verify-after-create
./LockBox.Cli open --container /backup/data.lbx --output /data/restored --master-env LBX_MASTER --keys-archive /media/usb/data-keys.zip --keys-archive-password-env LBX_ARCHIVE_PASSWORD
./LockBox.Cli verify --container /backup/data.lbx --master-env LBX_MASTER --key-file /media/usb/key_1.lbxkey
.\LockBox.Cli.exe create --source "C:\Data" --output "D:\Backups\data.lbx" --master-env LBX_MASTER --random-keys --algorithm AES-128-GCM --keys-archive "E:\data-keys.zip"
.\LockBox.Cli.exe open --container "D:\Backups\data.lbx" --output "D:\Restored" --master-env LBX_MASTER --keys-archive "E:\data-keys.zip" --keys-archive-password-env LBX_ARCHIVE_PASSWORD
{
  "commands": [{
    "command": "create", "source": "/data/source", "output": "/backup/data.lbx",
    "masterPasswordEnv": "LBX_MASTER", "randomKeys": true,
    "algorithms": ["AES-128-GCM"], "keysArchive": "/media/usb/data-keys.zip",
    "verifyAfterCreate": true
  }]
}

JSON scenarijai

Naudokite --script, kai darbotvarkėje yra kelios eilutės. Scenarijų vykdytojas palaiko create, open, verify, 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

Keliai nurodomi proceso darbinio aplanko atžvilgiu. Kintamieji eilutėse neišplečiami. Raktų tvarka: keys, keyEnvs, keyFiles. stopOnError numatytoji reikšmė true; false tęsia, bet grąžina pirmą klaidos kodą. Atšaukimas sustabdo vykdymą. Planuoklio komandos JSON nepalaikomos.

{
  "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
source / sourceFolder / sourceFolderPath--sourceAplankas, kurį reikia supakuoti ir užšifruoti.
output / outputContainerPath--outputIšvesties .lbx kelias.
masterPassword--masterĮterptas pagrindinis slaptažodis.
masterPasswordEnv--master-envNuskaityti pagrindinį slaptažodį iš aplinkos kintamojo.
masterPasswordFile--master-fileNuskaityti pagrindinį slaptažodį iš UTF-8 teksto failo.
layers[].algorithm + layers[].key--layerPridėti ALGORITHM=KEY.
layers[].algorithm + layers[].keyEnv--layer-envPridėti ALGORITHM=ENV.
layers[].algorithm + layers[].keyFile--layer-filePridėti ALGORITHM=FILE.
compression / compress--compressĮjungti suspaudimą.
verifyAfterCreate--verify-after-createTikrinti konteinerį po sukūrimo
padding--paddingAtsitiktinis užpildas padidina konteinerį, slėpdamas duomenų dydį. Šie papildomi baitai nešifruojami ir neautentifikuojami. B / KB / MB / GB / TB
paddingBytes--padding-bytesPapildymo dydis žaliuosiuose baituose.
split / splitSize--splitPadalinti išvestį į .lbx, .lbx1, .lbx2.
splitPartSizeBytes--split-bytesPadalijimo dalies dydis žaliuosiuose baituose.
destructionPassword--destruction-passwordTik Max inline sunaikinimo slaptažodis. Vėliau įvedus jį kaip pagrindinį slaptažodį, konteineris bus nedelsiant perrašytas.
destructionPasswordEnv--destruction-password-envNuskaityti tik Max sunaikinimo slaptažodį iš aplinkos kintamojo.
destructionPasswordFile--destruction-password-fileNuskaityti tik Max sunaikinimo slaptažodį iš UTF-8 teksto failo.
deleteSource / deleteSourceFolderAfterSuccess--delete-sourceIštrinti šaltinio aplanką po sėkmingo rankinio sukūrimo.
container / containerPath--containerEsamas .lbx konteineris.
keys[]--keyĮterptasis sluoksnio raktas originalia tvarka.
keyEnvs[]--key-envSluoksnio raktas iš aplinkos kintamojo.
keyFiles[]--key-fileSluoksnio raktas iš UTF-8 teksto failo.

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', '--verify-after-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 --verify-after-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

KomandaPaskirtisAlternatyvos
helpRodyti konsolės pagalbą.--help, -h, ?
device-idAtspausdinti PC įrenginio ID licencijos išdavimui.deviceid, machine-id
licenseRodyti dabartinę versiją ir licencijos kelią.license-status, status
activateĮdiegti į įrenginį pririštą licencijos raktą.activation
algorithmsRodyti algoritmus ir minimalias versijas.profiles, list-algorithms
keygenGeneruoti atsitiktinius raktus.generate-key, generate-keys
createSukurti užšifruotą konteinerį.encrypt
openIšskleisti užšifruotą konteinerį.decrypt, extract
verifyTikrinti konteinerį—
scheduleTvarkyti ir vykdyti suplanuotas užduotis.scheduler, scheduled-tasks
scriptVykdyti JSON automatizavimo bylą.--script

Sukurti parinktis

--source, -sAplankas, kurį reikia supakuoti ir užšifruoti.
--output, -oIšvesties .lbx kelias.
--masterĮterptas pagrindinis slaptažodis.
--master-envNuskaityti pagrindinį slaptažodį iš aplinkos kintamojo.
--master-fileNuskaityti pagrindinį slaptažodį iš UTF-8 teksto failo.
--layerPridėti ALGORITHM=KEY.
--layer-envPridėti ALGORITHM=ENV.
--layer-filePridėti ALGORITHM=FILE.
--algorithm, -aAlternatyvus algoritmas, derinamas su --key, --key-env arba --key-file.
--compressĮjungti suspaudimą.
--no-compressIšjungti suspaudimą, jei buvo nustatyta anksčiau.
--paddingAtsitiktinis užpildas padidina konteinerį, slėpdamas duomenų dydį. Šie papildomi baitai nešifruojami ir neautentifikuojami. B / KB / MB / GB / TB
--padding-bytesPapildymo dydis žaliuosiuose baituose.
--splitPadalinti išvestį į .lbx, .lbx1, .lbx2.
--split-bytesPadalijimo dalies dydis žaliuosiuose baituose.
--no-splitIšjungti dalijimą, jei buvo nustatyta anksčiau.
--destruction-passwordTik Max inline sunaikinimo slaptažodis. Vėliau įvedus jį kaip pagrindinį slaptažodį, konteineris bus nedelsiant perrašytas.
--destruction-password-envNuskaityti tik Max sunaikinimo slaptažodį iš aplinkos kintamojo.
--destruction-password-fileNuskaityti tik Max sunaikinimo slaptažodį iš UTF-8 teksto failo.
--delete-sourceIštrinti šaltinio aplanką po sėkmingo rankinio sukūrimo.
--verify-after-createĮjunkite tikrinimą po kūrimo automatinei atsarginių kopijų patikrai. Šaltinis pašalinamas tik po sėkmės; klaida arba atšaukimas jį išsaugo. Integruotam planuokliui vis dar reikia Max.

Atidaryti parinktis

--container, -cEsamas .lbx konteineris.
--output, -oIštraukimo aplankas.
--master, --master-env, --master-filePagrindinio slaptažodžio šaltinis.
--key, -kĮterptasis sluoksnio raktas originalia tvarka.
--key-envSluoksnio raktas iš aplinkos kintamojo.
--key-fileSluoksnio raktas iš UTF-8 teksto failo.
—Leidžiama sunaikinimo slaptažodžio procesams. Įprasta ištrauka nepavyksta po metaduomenų nuskaitymo, jei trūksta būtinų raktų.

Tvarkaraščio parinktys

schedule addPridėti užduotį į užšifruotą .lbxjobs.
schedule listRodyti išsaugotas užduotis.
schedule runPaleisti ilgai veikiančią darbų vykdytoją.
schedule run-onceVykdyti esmines užduotis vieną kartą ir išeiti.
schedule statusNuskaityti naujausią vykdymo laikų JSON.
--tasks, --fileUžšifruoto užduočių failo kelias.
--password, --password-env, --password-fileSlaptažodis užduočių failui.
--state, --status-fileVykdymo būsenos JSON kelias.
--nameUžduoties pavadinimas schedule add.
--frequency, --everyUžduoties dažnis.
--start, --start-atVietinis pradžios data/laikas.
--delete-source-contentsIštrinti originalaus šaltinio aplanko turinį po sėkmingo suplanuoto vykdymo.
--poll-secondsDarbų vykdytojo tikrinimo intervalas schedule run.

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 grąžina 1, jei nepavyksta užduotis, kurios laikas atėjo. schedule status gali grąžinti 0 be išsaugotos būsenos. Tikrinkite ir lastSuccessAt bei lastError. Pavyzdys numato kasdienes kopijas ir užklausas kas 30 sekundžių; pritaikykite 26 valandų langą.

$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

Kodėl gaunu išeities kodą 3?

Dabartinė versija neleidžia prašomos funkcijos: per daug sluoksnių, suspaudimas, šifravimo užpildas, dalijimas, planuoklis arba stipresnis algoritmas.

Kodėl išgavimo metu gaunu autentifikavimo žymos klaidą?

Pagrindinis slaptažodis, sluoksnio raktas, sluoksnių tvarka arba konteinerio failas yra neteisingi. Dalijamuose konteineriuose taip pat patikrinkite, ar kiekviena dalis yra toje pačioje aplanke.

Kodėl planuoklis neveikia uždarius konsolę?

schedule run yra darbinis procesas. Palikite jį atidarytą arba paleiskite per Windows Task Scheduler ar paslaugų apvyniojimą.

Kodėl schedule add iškart nepavyksta?

Planuoklis patikrina licenciją, šaltinio aplanką, išvesties kelią, algoritmus, slaptažodžius ir turimą disko vietą prieš išsaugant užduotį.

Ar galiu saugoti planuotuvo slaptažodžius .lbxjobs faile?

Taip. .lbxjobs failas yra užšifruotas su planuotuvo failo slaptažodžiu ir saugo visą užduoties metaduomenų informaciją, įskaitant šifravimo slaptažodžius ir sluoksnių raktus.

Kas nutinka, jei suplanuotas vykdymas sutampa su ankstesniu vykdymu?

Naujas įvykis praleidžiamas, užduotis praneša apie nepavykusią būseną su paaiškinimu, o ateities vykdymai tęsiasi baigus aktyvų vykdymą.

Kaip išvengti slaptų duomenų pateikimo shell istorijoje?

Naudokite --master-env, --master-file, --layer-env, --layer-file, --destruction-password-env, --destruction-password-file, --password-env ir --password-file.