Vissza a LockBoxhoz

LockBox CLI dokumentáció

CLI Windows és Linux rendszerhez: konténerek létrehozása, ellenőrzése és kibontása, automatikus mentés és JSON-szkriptek. Az ellenőrzés minden kiadásban működik.

Gyors kezdés

Helyezze a LockBox.Cli.exe fájlt egy mappába, amely szerepel a PATH-ben, vagy hívja meg teljes útvonallal. A --cli jelző kompatibilitási okokból elfogadott, de a kizárólag CLI-s verzióban nem kötelező.

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

Minimális létrehozás és megnyitás folyamat:

$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 ugyanazokat a parancsokat használja perjel útvonalakkal és .exe kiterjesztés nélküli binárissal:

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

A CLI telepítése és ellenőrzése

Csomagolja ki a rendszerhez és processzorhoz illő ZIP-et. A .NET része a csomagnak. Hasonlítsa össze a kivonatot a SHA256SUMS.txt fájllal. Helyezze a CLI-t az alábbi abszolút útvonalra, és a mentési fiókkal ellenőrizze a súgót és licencet.

Linuxon a disztribúció natív függőségei, például ICU és OpenSSL is szükségesek; a mellékelt .NET ezeket nem tartalmazza. Windows alatt az érvényes végrehajtási házirendnek engedélyeznie kell a PowerShell-szkripteket.

.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

Mappák, útvonalak és tárhely

Igazítsa az útvonalakat a környezetéhez. A forrásmappa nem lehet üres, a konténer legyen azon kívül. Azonos kimeneti név felülírja a korábbi konténert és részeit. Hagyjon ideiglenes helyet a konténer mellett, ütemezett feladatoknál forrásmásolatnak is. A méretegységek alapja 1024; a kitöltés bájtokat ad hozzá.

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

Titokfájlok előkészítése

Egyszer generálja a titkokat, őrizzen védett másolatot, és korlátozza a fájlhozzáférést. A példák nem cserélik le a meglévő kulcsokat. Az UTF-8-fájlok szóközei megmaradnak, a záró sortörések eltűnnek. Régi mentésekhez őrizze meg az eredeti kulcsokat.

$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

Aktiválás és licenc állapot

A licenckulcs a készülékazonosítóhoz van kötve, amelyet ugyanaz a CLI build jelenít meg. Ha egy licencet egy másik PC-re másolnak, a LockBox elutasítja, és visszatér a Free verzióra.

A Windows ellenőrzi a meglévő LockBox alkalmazásadatokat. A Linux az aktiválást a $XDG_CONFIG_HOME/lockbox/.lockbox.license-ban tárolja, majd ~/.config/lockbox/.lockbox.license-ben, ~/.lockbox/.lockbox.license mint tartalék.

Eszközazonosító lekérése

.\LockBox.Cli.exe device-id

Jelenlegi kiadás ellenőrzése

.\LockBox.Cli.exe license

Aktiválás licencfájlból

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

Aktiválás környezeti változóból

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

Inline aktiválás

Az inline aktiválás működik, de kiszivároghat a shell előzményekbe vagy a folyamat naplókba.

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

Linux aktiválás

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

Titkok kezelése

Előnyben részesítendők a környezeti változók vagy fájlok. Az inline titkok csak teszteléshez hasznosak. A mesterjelszavakat és a rétegkulcsokat meg kell őrizni: nélkülük a konténer nem nyitható meg.

CélBeágyazottKörnyezetFájl
Mesterjelszó--master value--master-env ENV--master-file path
Rétegkulcs létrehozása--layer ALG=KEY--layer-env ALG=ENV--layer-file ALG=FILE
Rétegkulcs megnyitása--key value--key-env ENV--key-file path
Ütemező fájl jelszó--password value--password-env ENV--password-file path
Konténer megsemmisítési jelszó--destruction-password value--destruction-password-env ENV--destruction-password-file path
Licenckulcs--license value--license-env ENV--license-file path

Fájl-alapú titkok

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

Algoritmusok és kulcsgenerálás

Használd a algorithms parancsot minden támogatott profil és minimális kiadás megtekintéséhez. Használd a keygen parancsot a rétegkulcsokhoz.

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

Támogatott parancs aliasok:

algorithms
list-algorithms
profiles

keygen
generate-key
generate-keys

Rétegenkénti jelszavakkal létrehozott tárolók esetén:

Konténerek létrehozása

A létrehozás becsomagolja a forrásmappát, opcionálisan tömöríti, rétegenként titkosítja és kiírja a konténert. Az opcionális véletlen kitöltés a titkosított adatokon kívül kerül hozzá.

Szükséges opciók

  • --source vagy -s: forrásmappa.
  • --output vagy -o: kimeneti .lbx útvonal.
  • --master, --master-env vagy --master-file.
  • Legalább egy réteg: --layer, --layer-env vagy --layer-file.

Minimális AES konténer

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

Tömörített konténer

.\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 kitöltés

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

Konténer részekre bontása

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

Az első rész megőrzi a .lbx-t. A további részek a .lbx1, .lbx2 és így tovább metódust használják. Minden részt ugyanabban a mappában tarts.

Kilenc rétegű Max példa

$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ív algoritmus/egy kulcs szintaxis

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

Forrás törlése a sikeres kézi létrehozás után

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

A --delete-source csak akkor törli a forrásmappát, ha a konténer sikeresen létrejött. Az ütemezőnek más opciója van: --delete-source-contents.

Titkosítás véletlen kulcsokkal

Konténer megsemmisítési jelszó

Max kiadás külön megsemmisítési jelszót adhat a konténerhez. Ha ezt a jelszót később a fő jelszóként adják meg, a LockBox azonnal felülírja a konténert megerősítés nélkül. Ez kényszer-helyzetekre van szánva. Tartsa külön a valódi fő jelszótól.

A parancs ellenőrzi a szabad lemezterületet, titkosítja az eredeti konténeradatokat egy új, véletlenszerű titokkal és AES-256-GCM-mel egy ideiglenes fájlba, normalizálja az eredményt az eredeti méretre, kicseréli az eredeti fájlt, majd elfelejti a véletlenszerű titkot. Split konténerek esetén minden .lbx, .lbx1, .lbx2 rész ugyanabban a mappában lecserélődik, miközben megőrzi az eredeti részek méretét.

Létrehozás megsemmisítési jelszóval

$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

Megsemmisítés indítása rétegbillentyűk nélkül

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

Linux indítás

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

A sikeres megsemmisítés után a konténer már nem érvényes LockBox fájl. A CLI 0 kilépési kódot ad, mert a kért megsemmisítési művelet sikeresen befejeződött.

Rétegenkénti jelszavakkal létrehozott tárolók esetén:

Konténerek megnyitása

open kibont egy konténert a kimeneti mappába. Normál kibontás esetén a rétegbillentyűket ugyanabban a sorrendben kell átadni, mint a létrehozásnál. Megsemmisítési jelszavas munkafolyamat esetén csak a konténer elérési útja, a kimeneti út és a megsemmisítési jelszó fő jelszóként szükséges.

Egy rétegű konténer megnyitása

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

Split konténer megnyitása

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

Többrétegű konténer megnyitása

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

Áliaszok

open
decrypt
extract

Titkosítás véletlen kulcsokkal

Tároló ellenőrzése

Ellenőrizze a metaadatokat, konténerrészeket, minden titkosítási réteget és a fájlok ellenőrzőösszegét. Free, Pro és Max kiadásban is elérhető Windows, Android és CLI alatt.

Rétegenkénti jelszavakkal létrehozott tárolók esetén: Az interaktív terminál rejtve kéri a jelszavakat és kulcsokat. Automatizáláskor ezeket kifejezetten, rétegsorrendben kell megadni. Nem kell kimeneti mappa. Kódok: 0 érvényes, 1 hiba vagy megszakítás, 2 hibás argumentumok. A kimenet átirányítása jelentést menthet.

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

Tároló ellenőrzése létrehozás után

Kapcsolja be a létrehozás utáni ellenőrzést az automatikus mentésellenőrzéshez. A forrás csak siker után törlődik; hiba vagy megszakítás esetén megmarad. A beépített ütemező továbbra is Max kiadást igényel.

./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"]
    }
  ]
}

Az ellenőrzés a memóriában történik. A visszafejtett adatok és a jelentés nem kerülnek lemezre. Az Android gyorsítótárazhat titkosított részeket. Az ellenőrzési munkamenetek és jelentések nem mentődnek. A rendszer lapozása és memóriaképei kívül esnek ezen a garancián.

Az érvényes eredmény az archívum sértetlenségét igazolja, nem a forrásmappával való egyezést. A formátum nem hitelesíti a véletlen kitöltést vagy a megsemmisítési jelszó ellenőrzőértékét. Az ellenőrzés soha nem indít megsemmisítést.

Mentés ellenőrzése visszaállítással

Készítsen kis report.csv tesztfájlt. Új mappába bontson ki; azon belül megmarad a forrásmappa neve. Minden részt tartson együtt, és hasonlítsa össze a változatlan forrással. Kibontáshoz írható ideiglenes hely kell a konténer mellett. A visszaállított titkosítatlan fájlokat is védje.

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

Ütemező

Az ütemező parancsok a Max kiadásban érhetők el. Teljes feladatmetaadatot tárolnak egy titkosított .lbxjobs fájlban, beleértve a forrás útvonalát, a kimeneti útvonalat, jelszavakat, törlési jelszót, rétegkulcsokat, tömörítést, kitöltést, felosztást és a forrás-tartalom törlése beállítást.

Az ütemezett feladatok csak akkor futnak, amikor LockBox.Cli.exe schedule run fut. Használjon Windows Feladatütemezőt, Linux systemd-t, cront, egy szolgáltatás csomagolót vagy egy hosszú futású konzol munkamenetet, ha szüksége van arra, hogy a munkás automatikusan elinduljon újraindítás után.

Gyakorisági értékek

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

Napi titkosított mentési feladat hozzáadása

$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

Olyan feladat hozzáadása, amely a forrásmappa tartalmát törli siker után

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

Havi archívum hozzáadása kitöltéssel és részekre bontással

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

Mentett feladatok listázása

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

Az ütemező munkás futtatása

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

Határidős feladatok egyszeri futtatása és kilépés

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

Legutóbbi futási állapot megjelenítése

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

Az állapotjelzők [OK], [RUNNING] és [FAILED]. Egy sikertelen feladat tartalmazza az okot, és tájékoztatja a felhasználót, hogy ha a probléma ismétlődik, lépjen kapcsolatba a támogatással.

Titkosítás véletlen kulcsokkal

Windows, Android és CLI: Free, Pro és Max, az adott kiadás korlátaival. Az ütemezőben és az Intéző gyors létrehozásában nem érhető el.

Nem kell rétegenként jelszót kitalálni és megjegyezni. Őrizze meg a kulcsarchívumot és jelszavát; a metaadatokhoz továbbra is mesterjelszó szükséges.

  1. Kapcsolja be a véletlen kulcsokat a varázsló első képernyőjén, majd válassza ki az algoritmusokat. Létrehozás után mentse a kulcsarchívumot, és másolja ki a jelszavát az alkalmazás bezárása előtt. A mesterjelszó továbbra is kötelező.
  2. Mentse az archívumot közvetlenül USB-meghajtóra vagy más cserélhető adathordozóra, hogy ne maradjon másolat a számítógépen. A jelszót külön tárolja. A LockBox soha nem írja lemezre a kibontott kulcsokat.
  3. Töltse be a kulcsarchívumot és jelszavát az összes réteghez, vagy válasszon külön kulcsfájlt minden visszafejtési lépésnél.

Az AES-256 ZIP egy titkosított keys.zip fájlt tartalmaz: a kulcsok neve és száma rejtett. Más archiválók két kibontást igényelnek. A key_1.lbxkey az első visszafejtési lépéshez, a külső réteghez tartozik. Importáláshoz ne módosítsa a fájlneveket.

A véletlen kulcsok erősek, de az archívum vagy jelszava elvesztése az adatokhoz való hozzáférés elvesztését jelenti. Tárolja őket biztonságosan és elérhetően. A megjegyzett jelszavak előnyösebbek a leírt titkoknál. A véletlen kulcsok nem használhatók a tároló megsemmisítésével együtt. Kulcsmódban ez a funkció le van tiltva.

A forrás törlésének meg kell várnia a kulcsarchívum mentését és ellenőrzését.

A CLI a --keys-archive helyre ment, és --quiet mellett is kiírja a jelszót. Ismételje a --key-file kapcsolót visszafejtési sorrendben: key_1, key_2… Használja a --keys-archive-password-env kapcsolót, hogy a jelszó ne kerüljön a parancselőzményekbe.

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

Használja a --script-t, amikor egy munkafolyamatnak több lépése van. A szkript futtató támogatja a create, open, verify, keygen, algorithms, device-id, license és activate elemeket.

Egyszerre létrehozás és megnyitás egy szkriptben

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

Folytatás egy sikertelen lépés után

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

Aktiválás szkriptből

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

JSON-mezők és futási szabályok

Az útvonalak a folyamat munkamappájához képest relatívak. A karakterláncok változói nem helyettesítődnek. Kulcssorrend: keys, keyEnvs, keyFiles. A stopOnError alapértéke true; false folytatja a futást, de az első hibakódot adja vissza. A megszakítás leállítja a futást. Ütemezőparancsok JSON-ban nem használhatók.

{
  "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--sourceA csomagolandó és titkosítandó mappa.
output / outputContainerPath--outputKimeneti .lbx útvonal.
masterPassword--masterBeágyazott mester jelszó.
masterPasswordEnv--master-envA mester jelszó környezeti változóból történő olvasása.
masterPasswordFile--master-fileA mester jelszó UTF-8 szöveges fájlból történő olvasása.
layers[].algorithm + layers[].key--layerALGORITHM=KEY hozzáadása.
layers[].algorithm + layers[].keyEnv--layer-envALGORITHM=ENV hozzáadása.
layers[].algorithm + layers[].keyFile--layer-fileALGORITHM=FILE hozzáadása.
compression / compress--compressTömörítés engedélyezése.
verifyAfterCreate--verify-after-createTároló ellenőrzése létrehozás után
padding--paddingA véletlen kitöltés növeli a konténert az adatméret elfedésére. Ezek a többletbájtok nem titkosítottak és nem hitelesítettek. B / KB / MB / GB / TB
paddingBytes--padding-bytesKitöltés mérete nyers bájtban.
split / splitSize--splitKimenet darabolása .lbx, .lbx1, .lbx2.
splitPartSizeBytes--split-bytesRész mérete nyers bájtban.
destructionPassword--destruction-passwordCsak maximális inline megsemmisítési jelszó. Későbbi mester jelszóként történő megadása azonnal felülírja a konténert.
destructionPasswordEnv--destruction-password-envA csak maximális megsemmisítési jelszó környezeti változóból történő olvasása.
destructionPasswordFile--destruction-password-fileA csak maximális megsemmisítési jelszó UTF-8 szöveges fájlból történő olvasása.
deleteSource / deleteSourceFolderAfterSuccess--delete-sourceA forrásmappa törlése a sikeres kézi létrehozás után.
container / containerPath--containerMeglévő .lbx tároló.
keys[]--keyBeágyazott rétegkulcs az eredeti sorrendben.
keyEnvs[]--key-envRétegkulcs környezeti változóból.
keyFiles[]--key-fileRétegkulcs UTF-8 szövegfájlból.

Automatizálási receptek

Titkosított adatbázis-mentés

$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 műtárgyvédelem

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

Biztonságos partnerátvitel

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

Hosszú távú archívum

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

Tömeges fájl példa

@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: több mappa mentése

Mentse a szkriptet a jelzett útvonalra. Forrásonként egyedi nevű konténert és naplót készít, hiba esetén leáll, és megőrzi a CLI kilépési kódját. Az AES-128-GCM működik Free kiadásban; tömörítéshez és daraboláshoz Pro vagy Max kell.

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: felügyelet nélküli mentés

A Bash-szkriptet LF sorvégekkel mentse. Készítse elő a CLI-t és titkokat a megadott helyeken, a forrásmappákat argumentumként adja át. Minden futás külön könyvtárat kap. Hibánál napló marad és nem nulla kód érkezik; a forrásfájlok megmaradnak.

/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

Ütemezés az operációs rendszerrel

A feladatok a fenti szkripteket indítják; a create ilyen használatához nem kell Max. A Windows-regisztráció csak bejelentkezett felhasználóval fut; szükség esetén állítsa be a kijelentkezett futást a Feladatütemezőben. A cron-sort a mentési fiók crontabjába tegye a flock ellenőrzése után. Mindkét példa helyi idő szerint 02:00-kor fut, és megakadályozza az ütemezett futások átfedését. Ellenőrizze a jogokat, és próbálja ki kézzel.

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: az ütemező működtetése

Hozza létre a lockbox szolgáltatásfiókot megfelelő jogokkal, aktiválja rá a Max kiadást, és készítsen külön UTF-8 jobs.txt jelszófájlt. Az add hozzáad, nem frissít: feladatonként egyszer használja. Feladatfájlonként egy folyamat fusson, módosítás után indítsa újra. Az állapot-JSON nem állít vissza előzményeket: a lejárt ismétléseket kihagyja, a lejárt once feladat újra futhat. Rendszeres rendszerindításhoz create legyen, ne ismételt run-once. Az ütemező újrahasználja a kimeneti nevet.

/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

Parancs referencia

ParancsCélAliasok
helpKonzol súgó megjelenítése.--help, -h, ?
device-idPC eszközazonosító kiírása licenc kiadásához.deviceid, machine-id
licenseAz aktuális kiadás és licencútvonal megjelenítése.license-status, status
activateEszközhöz kötött licenckulcs telepítése.activation
algorithmsAlgoritmusok és minimum kiadások listázása.profiles, list-algorithms
keygenVéletlenszerű kulcsok generálása.generate-key, generate-keys
createTitkosított tároló létrehozása.encrypt
openTitkosított tároló kibontása.decrypt, extract
verifyTároló ellenőrzése—
scheduleÜtemezett feladatok kezelése és futtatása.scheduler, scheduled-tasks
scriptJSON automatizálási fájl futtatása.--script

Opciók létrehozása

--source, -sA csomagolandó és titkosítandó mappa.
--output, -oKimeneti .lbx útvonal.
--masterBeágyazott mester jelszó.
--master-envA mester jelszó környezeti változóból történő olvasása.
--master-fileA mester jelszó UTF-8 szöveges fájlból történő olvasása.
--layerALGORITHM=KEY hozzáadása.
--layer-envALGORITHM=ENV hozzáadása.
--layer-fileALGORITHM=FILE hozzáadása.
--algorithm, -aAlternatív algoritmus a --key, --key-env vagy --key-file párosításával.
--compressTömörítés engedélyezése.
--no-compressTömörítés letiltása, ha korábban beállították.
--paddingA véletlen kitöltés növeli a konténert az adatméret elfedésére. Ezek a többletbájtok nem titkosítottak és nem hitelesítettek. B / KB / MB / GB / TB
--padding-bytesKitöltés mérete nyers bájtban.
--splitKimenet darabolása .lbx, .lbx1, .lbx2.
--split-bytesRész mérete nyers bájtban.
--no-splitDarabolás letiltása, ha korábban beállították.
--destruction-passwordCsak maximális inline megsemmisítési jelszó. Későbbi mester jelszóként történő megadása azonnal felülírja a konténert.
--destruction-password-envA csak maximális megsemmisítési jelszó környezeti változóból történő olvasása.
--destruction-password-fileA csak maximális megsemmisítési jelszó UTF-8 szöveges fájlból történő olvasása.
--delete-sourceA forrásmappa törlése a sikeres kézi létrehozás után.
--verify-after-createKapcsolja be a létrehozás utáni ellenőrzést az automatikus mentésellenőrzéshez. A forrás csak siker után törlődik; hiba vagy megszakítás esetén megmarad. A beépített ütemező továbbra is Max kiadást igényel.

Megnyitási opciók

--container, -cMeglévő .lbx tároló.
--output, -oKicsomagolási mappa.
--master, --master-env, --master-fileFő jelszó forrása.
--key, -kBeágyazott rétegkulcs az eredeti sorrendben.
--key-envRétegkulcs környezeti változóból.
--key-fileRétegkulcs UTF-8 szövegfájlból.
—Engedélyezett a pusztító jelszó folyamatokhoz. A normál kicsomagolás metadata olvasása után sikertelen lesz, ha a szükséges kulcsok hiányoznak.

Ütemező opciók

schedule addFeladat hozzáadása titkosított .lbxjobs-hoz.
schedule listMentett feladatok megjelenítése.
schedule runHosszú életű munkás futtatása.
schedule run-onceVégrehajtandó feladatok egyszeri futtatása, majd kilépés.
schedule statusLegfrissebb futásidejű állapot JSON olvasása.
--tasks, --fileTitkosított feladatfájl elérési útja.
--password, --password-env, --password-fileJelszó a feladatfájlhoz.
--state, --status-fileFutásidejű állapot JSON elérési útja.
--nameFeladat neve schedule add-hoz.
--frequency, --everyFeladat gyakorisága.
--start, --start-atHelyi indulási dátum/idő.
--delete-source-contentsEredeti forrásmappa tartalmának törlése a sikeres ütemezett futtatás után.
--poll-secondsMunkás lekérdezési intervallum schedule run-hoz.

A --language vagy --lang kapcsolóval válassza ki a konzol nyelvét, a --quiet kapcsolóval pedig rejtse el a szokásos folyamatjelzést; a hibák továbbra is a szabványos hibakimenetre kerülnek. A Ctrl+C megszakítást kér, és 1-es kódot ad vissza. A 2-es kód érvénytelen parancsszintaxist jelent; a 3-as kód azt jelenti, hogy egy létrehozási funkció nem érhető el a jelenlegi kiadásban. A 0-s kód a megsemmisítési jelszó szándékos aktiválását is lefedi, ezért önmagában nem bizonyítja a fájlok kibontását. A következő automatizálási lépések előtt ellenőrizze az elvárt kimenetet.

Kilépési kódok és felügyelet

A schedule run-once 1-et ad vissza, ha egy esedékes feladat sikertelen. A schedule status mentett állapot nélkül is adhat 0-t. Ellenőrizze a lastSuccessAt és lastError mezőket is. A példa napi mentést és 30 másodperces lekérdezést feltételez; igazítsa a 26 órás időablakot.

$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

Hibaelhárítás

Miért kapok 3-as exit kódot?

A jelenlegi kiadás nem engedélyezi a kívánt funkciót: túl sok réteget, tömörítést, kriptokitűzést, splittelést, ütemezőt vagy erősebb algoritmust.

Miért bukik el a kimentés hitelesítési címke hibájával?

A fő jelszó, rétegkulcs, rétegsorrend vagy konténer fájl hibás. A szétosztott konténereknél ellenőrizd, hogy minden alkatrész ugyanabban a mappában van-e.

Miért nem fut be az időzítő, miután bezárom a konzolt?

schedule run a munkavállalói folyamat. Tartsd nyitva, vagy indítsd el Windows Task Schedulerből vagy egy szolgáltatási csomagolóról.

Miért bukik el azonnal az ütemezés hozzáadása?

Az ütemező ellenőrizi a licencet, a forrásmappát, a kimeneti útvonalat, az algoritmusokat, jelszavakat és a rendelkezésre álló lemezhelyet, mielőtt elmenti a feladatot.

Tárolhatom az időzítő jelszavakat a .lbxjobs fájlban?

Igen. A .lbxjobs fájl az ütemező fájl jelszóval van titkosítva, és teljes feladat metaadatokat tárol, beleértve a titkosítási jelszavakat és a rétegkulcsokat.

Mi történik, ha egy ütemezett futás átfedi az előző futást?

Az új eseményt kihagyják, a feladat hibás státuszt jelent magyarázattal, és a további futtatások folytatódnak az aktív futás befejezése után.

Hogyan kerülhetem el a titkokat a shell történetében?

Használj --master-env, --master-file, --layer-env, --layer-file, --destruction-password-env, --destruction-password-file, --password-env és --password-file.