Atpakaļ uz LockBox

LockBox CLI dokumentācija

CLI Windows un Linux: konteineru izveide, pārbaude un izpakošana, automātiskas kopijas un JSON skripti. Pārbaude darbojas visos izdevumos.

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

Iegūt ierīces ID

.\LockBox.Cli.exe device-id

Pārbaudīt pašreizējo izdevumu

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

MērķisIekļautsVideFails
Galvenā parole--master value--master-env ENV--master-file path
Kārtas atslēgas izveide--layer ALG=KEY--layer-env ALG=ENV--layer-file ALG=FILE
Kārtas atslēgas atvēršana--key value--key-env ENV--key-file path
Plānotāja faila parole--password value--password-env ENV--password-file path
Konteinera iznīcināšanas parole--destruction-password value--destruction-password-env ENV--destruction-password-file path
Licences atslēga--license value--license-env ENV--license-file path

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

Konteineriem, kas izveidoti ar slāņu parolēm:

Izveidot konteinerus

Izveide sapako avota mapi, pēc izvēles saspiež, šifrē slāņos un ieraksta konteineru. Izvēles nejaušais aizpildījums tiek pievienots ārpus šifrētajiem datiem.

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

Šifrēt ar nejaušām atslēgām

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.

Konteineriem, kas izveidoti ar slāņu parolēm:

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

Šifrēt ar nejaušām atslēgām

Pārbaudīt konteineru

Pārbaudiet metadatus, konteinera daļas, katru šifrēšanas slāni un failu kontrolsummas. Pieejams Free, Pro un Max izdevumos Windows, Android un CLI.

Konteineriem, kas izveidoti ar slāņu parolēm: Interaktīvs terminālis prasa paroles un atslēgas, nerādot ievadi. Automatizācijā tās skaidri jānorāda slāņu secībā. Izvades mape nav vajadzīga. Kodi: 0 derīgs, 1 kļūda vai atcelšana, 2 nepareizi argumenti. Izvades novirzīšana var saglabāt pārskatu.

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

Pārbaudīt konteineru pēc izveides

Ieslēdziet pārbaudi pēc izveides automātiskai dublējumu pārbaudei. Avots tiek dzēsts tikai pēc veiksmīgas pārbaudes; kļūda vai atcelšana to saglabā. Iebūvētais plānotājs joprojām prasa 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"]
    }
  ]
}

Pārbaude notiek atmiņā. Atšifrētie dati un pārskats netiek saglabāti diskā. Android var kešot šifrētās daļas. Pārbaudes sesijas un pārskati netiek saglabāti. Sistēmas mijmaiņas atmiņa un atmiņas izmetes nav ietvertas šajā garantijā.

Derīgs rezultāts apstiprina arhīva integritāti, nevis atbilstību sākotnējai mapei. Formāts neautentificē nejaušo aizpildījumu vai iznīcināšanas paroles pārbaudītāju. Pārbaude nekad neiedarbina iznīcināšanu.

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

Šifrēt ar nejaušām atslēgām

Windows, Android un CLI: Free, Pro un Max atbilstoši izdevuma ierobežojumiem. Nav pieejams plānotājā vai ātrajā izveidē ar Explorer.

Nav jāizdomā vai jāatceras slāņu paroles. Saglabājiet atslēgu arhīvu un tā paroli; metadatiem joprojām vajadzīga galvenā parole.

  1. Vedņa pirmajā ekrānā ieslēdziet nejaušas atslēgas un izvēlieties algoritmus. Pēc izveides saglabājiet atslēgu arhīvu un nokopējiet tā paroli pirms lietotnes aizvēršanas. Galvenā parole joprojām ir obligāta.
  2. Saglabājiet arhīvu tieši USB atmiņā vai citā noņemamā datu nesējā, lai datorā nepaliktu kopija. Paroli glabājiet atsevišķi. LockBox nekad neraksta izpakotas atslēgas diskā.
  3. Ielādējiet atslēgu arhīvu un tā paroli visiem slāņiem vai izvēlieties atsevišķu atslēgas failu katrā atšifrēšanas solī.

AES-256 ZIP satur šifrētu keys.zip: atslēgu nosaukumi un skaits ir paslēpts. Citās arhivēšanas programmās jāizpako divreiz. key_1.lbxkey atbilst pirmajam atšifrēšanas solim, ārējam slānim. Arhīva importēšanai nemainiet failu nosaukumus.

Nejaušas atslēgas ir drošas, taču arhīva vai tā paroles zaudēšana nozīmē piekļuves zaudēšanu datiem. Glabājiet tos droši un pieejami. Iegaumētām parolēm ir priekšrocība salīdzinājumā ar pierakstītiem noslēpumiem. Nejaušas atslēgas nav savienojamas ar konteinera iznīcināšanu. Atslēgu režīmā šī funkcija ir atspējota.

Avota dzēšanai jāgaida atslēgu arhīva saglabāšana un pārbaude.

CLI saglabā uz --keys-archive un parāda paroli arī ar --quiet. Atkārtojiet --key-file atšifrēšanas secībā: key_1, key_2… Lietojiet --keys-archive-password-env, lai parole nepaliktu komandu vēsturē.

./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 skripti

Izmantojiet --script, kad darba plūsmā ir vairāki soļi. Skriptu palaidējs atbalsta create, open, verify, 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

Ceļi ir relatīvi procesa darba mapei. Mainīgie virknēs netiek izvērsti. Atslēgu secība: keys, keyEnvs, keyFiles. stopOnError pēc noklusējuma ir true; false turpina, bet atgriež pirmo kļūdas kodu. Atcelšana aptur izpildi. Plānotāja komandas JSON nav pieejamas.

{
  "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--sourceMape, ko saspiest un šifrēt.
output / outputContainerPath--outputIzvades .lbx ceļš.
masterPassword--masterIekļautais galvenais parole.
masterPasswordEnv--master-envNolasīt galveno paroli no vides mainīgā.
masterPasswordFile--master-fileNolasīt galveno paroli no UTF-8 teksta faila.
layers[].algorithm + layers[].key--layerPievienot ALGORITHM=KEY.
layers[].algorithm + layers[].keyEnv--layer-envPievienot ALGORITHM=ENV.
layers[].algorithm + layers[].keyFile--layer-filePievienot ALGORITHM=FILE.
compression / compress--compressIespējot saspiešanu.
verifyAfterCreate--verify-after-createPārbaudīt konteineru pēc izveides
padding--paddingNejaušs aizpildījums palielina konteineru, slēpjot datu apjomu. Šie papildu baiti nav šifrēti vai autentificēti. B / KB / MB / GB / TB
paddingBytes--padding-bytesPapildinājuma lielums nesaspiestos baitos.
split / splitSize--splitSadalīt izvadi .lbx, .lbx1, .lbx2.
splitPartSizeBytes--split-bytesDaļas lielums nesaspiestos baitos.
destructionPassword--destruction-passwordTikai Max iekļautās iznīcināšanas paroles. Ievadot to vēlāk kā galveno paroli, tūlītēji tiek pārrakstīts konteiners.
destructionPasswordEnv--destruction-password-envNolasīt tikai Max iznīcināšanas paroli no vides mainīgā.
destructionPasswordFile--destruction-password-fileNolasīt tikai Max iznīcināšanas paroli no UTF-8 teksta faila.
deleteSource / deleteSourceFolderAfterSuccess--delete-sourceDzēst sākotnējo mapi pēc veiksmīgas manuālas izveides.
container / containerPath--containerEsošs .lbx konteiners.
keys[]--keySaistītā slāņa atslēga oriģinālajā secībā.
keyEnvs[]--key-envSlāņa atslēga no vides mainīgā.
keyFiles[]--key-fileSlāņa atslēga no UTF-8 teksta faila.

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', '--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: 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 --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

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

KomandaMērķisAliasi
helpRādīt konsoles palīdzību.--help, -h, ?
device-idIzdrukāt datora ierīces ID licences izdošanai.deviceid, machine-id
licenseRādīt pašreizējo izdevumu un licences ceļu.license-status, status
activateInstalēt ierīcei piesaistītu licences atslēgu.activation
algorithmsSarakstīt algoritmus un minimālos izdevumus.profiles, list-algorithms
keygenĢenerēt nejaušas atslēgas.generate-key, generate-keys
createIzveidot šifrētu konteineru.encrypt
openIzvilkt šifrētu konteineru.decrypt, extract
verifyPārbaudīt konteineru—
schedulePārvaldīt un palaist plānotos uzdevumus.scheduler, scheduled-tasks
scriptPalaist JSON automatizācijas failu.--script

Izveides opcijas

--source, -sMape, ko saspiest un šifrēt.
--output, -oIzvades .lbx ceļš.
--masterIekļautais galvenais parole.
--master-envNolasīt galveno paroli no vides mainīgā.
--master-fileNolasīt galveno paroli no UTF-8 teksta faila.
--layerPievienot ALGORITHM=KEY.
--layer-envPievienot ALGORITHM=ENV.
--layer-filePievienot ALGORITHM=FILE.
--algorithm, -aAlternatīva algoritma forma, kas sasaistīta ar --key, --key-env vai --key-file.
--compressIespējot saspiešanu.
--no-compressIzslēgt saspiešanu, ja tā tika iestatīta iepriekš.
--paddingNejaušs aizpildījums palielina konteineru, slēpjot datu apjomu. Šie papildu baiti nav šifrēti vai autentificēti. B / KB / MB / GB / TB
--padding-bytesPapildinājuma lielums nesaspiestos baitos.
--splitSadalīt izvadi .lbx, .lbx1, .lbx2.
--split-bytesDaļas lielums nesaspiestos baitos.
--no-splitIzslēgt sadalīšanu, ja tā tika iestatīta iepriekš.
--destruction-passwordTikai Max iekļautās iznīcināšanas paroles. Ievadot to vēlāk kā galveno paroli, tūlītēji tiek pārrakstīts konteiners.
--destruction-password-envNolasīt tikai Max iznīcināšanas paroli no vides mainīgā.
--destruction-password-fileNolasīt tikai Max iznīcināšanas paroli no UTF-8 teksta faila.
--delete-sourceDzēst sākotnējo mapi pēc veiksmīgas manuālas izveides.
--verify-after-createIeslēdziet pārbaudi pēc izveides automātiskai dublējumu pārbaudei. Avots tiek dzēsts tikai pēc veiksmīgas pārbaudes; kļūda vai atcelšana to saglabā. Iebūvētais plānotājs joprojām prasa Max.

Atvērt opcijas

--container, -cEsošs .lbx konteiners.
--output, -oIzvilkšanas mape.
--master, --master-env, --master-fileGalvenā parole.
--key, -kSaistītā slāņa atslēga oriģinālajā secībā.
--key-envSlāņa atslēga no vides mainīgā.
--key-fileSlāņa atslēga no UTF-8 teksta faila.
—Atļauts workflows ar iznīcināšanas paroli. Parastā izvilkšana neizdodas pēc metadatu nolasīšanas, ja trūkst nepieciešamās atslēgas.

Plānotāja opcijas

schedule addPievienot uzdevumu šifrētajai .lbxjobs.
schedule listRādīt saglabātos uzdevumus.
schedule runPalaist ilgstošu darbinieku.
schedule run-oncePalaist pienākušos uzdevumus vienu reizi un iziet.
schedule statusLasīt jaunāko darbības statusa JSON.
--tasks, --fileŠifrētā uzdevuma faila ceļš.
--password, --password-env, --password-fileParole uzdevuma failam.
--state, --status-fileDarbības statusa JSON ceļš.
--nameUzdevuma nosaukums priekš schedule add.
--frequency, --everyUzdevuma biežums.
--start, --start-atVietējais sākuma datums/laiks.
--delete-source-contentsDzēst sākotnējās avota mapes saturu pēc veiksmīgas plānotās izpildes.
--poll-secondsDarbinieka aptaujas intervāls priekš schedule run.

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 atgriež 1, ja pienākuša uzdevuma izpilde neizdodas. schedule status var atgriezt 0 bez saglabāta stāvokļa. Pārbaudiet arī lastSuccessAt un lastError. Piemērs paredz ikdienas kopijas un aptauju ik pēc 30 sekundēm; pielāgojiet 26 stundu logu.

$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

Kāpēc man ir izejas kods 3?

Pašreizējā versija neļauj izmantot pieprasīto funkciju: pārāk daudz slāņu, kompresiju, kripto aizpildīšanu, sadalīšanu, plānotāju vai spēcīgāku algoritmu.

Kāpēc izvilkšana neizdodas ar autentifikācijas taga kļūdu?

Galvenā parole, slāņu atslēga, slāņu secība vai konteinera fails ir nepareizs. Attiecībā uz sadalītajiem konteineriem pārbaudiet arī, vai visas detaļas ir vienā mapē.

Kāpēc plānotājs nedarbojas pēc tam, kad aizveru konsoli?

schedule run ir darbinieka process. Turiet to atvērtu vai palaidiet no Windows uzdevumu plānotāja vai servisa apvalka.

Kāpēc grafika pievienošana neizdodas uzreiz?

Plānotājs pārbauda licenci, avota mapi, izvades ceļu, algoritmus, paroles un pieejamo diska vietu pirms uzdevuma saglabāšanas.

Vai es varu glabāt plānotāja paroles .lbxjobs failā?

Jā. .lbxjobs fails ir šifrēts ar plānotāja faila paroli un glabā pilnu uzdevuma metadatus, tostarp šifrēšanas paroles un slāņu atslēgas.

Kas notiek, ja plānotais skrējiens pārklājas ar iepriekšējo?

Jaunais notikums tiek izlaists, uzdevums ziņo par neveiksmīgu statusu ar paskaidrojumu, un nākamie mēģinājumi turpinās pēc aktīvā mēģinājuma beigām.

Kā izvairīties no noslēpumiem čaulu vēsturē?

Izmantojiet --master-env, --master-file, --layer-env, --layer-file, --destruction-password-env, --destruction-password-file, --password-env un --password-file.