LockBox CLI dokumentáció

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.

.\LockBox.Cli.exe device-id

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

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

Konténerek létrehozása

A create becsomagol egy forrásmappát, opcionális tömörítést és kitöltést alkalmaz, a hasznos terhet egy vagy több rétegen keresztül titkosítja, és létrehoz egy .lbx konténert.

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

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.

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

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

JSON szkriptek

Használja a --script-t, amikor egy munkafolyamatnak több lépése van. A szkript futtató támogatja a create, open, 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

A táblázat a create mezőket és open kulcstömböket a CLI kapcsolóihoz rendeli. A relatív útvonal alapja a folyamat munkakönyvtára; változók és dátumok nem helyettesítődnek. Mezőnként egy titokforrást használjon. Az open sorrendje keys, keyEnvs, keyFiles. Javasolt a stopOnError: true; false mellett későbbi siker elfedhet korábbi hibát. JSON-szkriptekben nincs ütemezőparancs.

{
  "stopOnError": true,
  "commands": [
    {
      "command": "create",
      "source": "/srv/data",
      "output": "/backup/data.lbx",
      "masterPasswordFile": "/srv/lockbox/secrets/master.txt",
      "layers": [
        { "algorithm": "AES-128-GCM", "keyFile": "/srv/lockbox/secrets/layer1.txt" }
      ]
    },
    {
      "command": "open",
      "container": "/backup/data.lbx",
      "output": "/restore/check",
      "masterPasswordFile": "/srv/lockbox/secrets/master.txt",
      "keyFiles": ["/srv/lockbox/secrets/layer1.txt"]
    }
  ]
}

/opt/lockbox/LockBox.Cli --quiet script /srv/lockbox/backup.lockbox.json

Automatizá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', '--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 \
        --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

Opciók létrehozása

Megnyitási opciók

Ütemező opciók

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 hibás feladat mellett is adhat nullát; a schedule status állapot nélkül is. Ellenőrizze a savedAt, lastSuccessAt és lastError mezőket; az [OK] csak Ready is lehet. A figyelő napi mentést, 30 másodperces lekérdezést és 26 órán belüli sikert vár. Módosítsa a küszöböket. A JSON-állapotok számok; a --quiet elrejti a sikeres create/open szokásos kimenetét.

$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