LockBox CLI dokumentazioa

Azkar hasteko

Jarri LockBox.Cli.exe karpeta batean sartuta PATH, edo deitu zure bide osoa erabilita. --cli Markatzaile hau onartzen da bateragarritasunagatik baina ez da derrigorrezkoa CLI-bertsioan.

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

Sortu eta ireki lan-fluxu minimalista:

$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

Linuxek komando berberak erabiltzen ditu koskorrak dituzten bideekin eta .exe gehikaria ez duen binario batekin:

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 instalatu eta egiaztatu

Deskonprimitu sistemarako eta prozesadorerako ZIP egokia. .NET barne dago. Alderatu hasha SHA256SUMS.txt fitxategiarekin. Jarri CLI beheko bide absolutuan, eta egiaztatu laguntza eta lizentzia babeskopien kontuarekin.

Linuxek banaketaren jatorrizko mendekotasunak ere behar ditu, ICU eta OpenSSL barne; barneko .NETek ez ditu ematen. Windowsen, indarreko exekuzio-politikak PowerShell scriptak onartu behar ditu.

.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

Karpetak, bideak eta lekua

Egokitu bideak. Iturburu-karpeta ezin da hutsik egon, eta edukiontziak kanpoan egon behar du. Irteera-izen bera erabiltzeak aurreko edukiontzia eta zatiak ordezkatzen ditu. Utzi aldi baterako lekua edukiontziaren ondoan eta iturburuaren kopiarako tokia programatutako lanetan. Unitateek 1024 oinarria dute; betegarriak byteak gehitzen ditu.

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

Sekretuen fitxategiak prestatu

Sortu sekretuak behin, gorde kopia babestua eta mugatu fitxategietarako sarbidea. Adibideek ez dituzte lehendik dauden gakoak ordezkatzen. UTF-8 fitxategiek zuriuneak gordetzen dituzte, amaierako lerro-jauziak kenduta. Gorde jatorrizko gakoak kopia zaharretarako.

$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

Aktibazioa eta lizentziaren egoera

Lizentzia gakoa CLI eraikuntza berberak inprimatutako gailu IDari lotuta dago. Lizentzia beste ordenagailu batean kopiatzekotan, LockBox-ek baztertzen du eta Free-ra itzultzen da.

Windows-ek LockBox aplikazioaren datu kokapenak egiaztatzen ditu. Linux-ek aktibazioa $XDG_CONFIG_HOME/lockbox/.lockbox.license gordetzen du, ondoren ~/.config/lockbox/.lockbox.license, ~/.lockbox/.lockbox.license ordezko moduan.

.\LockBox.Cli.exe device-id

.\LockBox.Cli.exe license

Aktibatu lizentzia fitxategi batetik

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

Aktibatu ingurumen aldagaitik

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

Aktibazio bertikal

Aktibazio bertikalean funtzionatzen du, baina shell historian edo prozesu logetan isuri daiteke.

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

Linux aktibazioa

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

Sekretuen kudeaketa

Hobetsi ingurumeko aldagaiak edo fitxategiak. Sekretu bertikalak probetarako bakarrik dira erabilgarriak. Master pasahitzak eta geruzako gakoak kontserbatu behar dira: horiek gabe ontzia ezin da ireki.

Fitxategietan oinarritutako sekretuak

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

Algoritmoak eta gako sortzea

Erabili algorithms erabiltzaile profile guztiak eta edizio minimoak ikusteko. Erabili keygen geruzako gakoetarako.

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

Onartutako komando aliasak:

algorithms
list-algorithms
profiles

keygen
generate-key
generate-keys

Sortu ontziak

create jatorria duen karpeta bat paketatzen du, konpresio eta pad ondoriozko aukerak aplikatzen ditu, , betearazten du payload-a geruza batekin edo gehiagorekin sekretua bihurtuz, eta idazten du .lbx ontzi.

Beharrezko aukerak

• --source edo -s: iturburu karpeta.
• --output edo -o: irteera .lbx bidea.
• --master, --master-env, edo --master-file.
• Gutxienez geruza bat: --layer, --layer-env, edo --layer-file.

AES edukiontzi minimoa

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

Edukiontzi konprimatua

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

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

Edukiontzia zatitan banatu

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

Lehen zatia gordetzen du .lbx. Zati gehigarriak erabiltzen dituzte .lbx1, .lbx2, eta hala nola. Zati guztiak karpeta berean gorde.

Bederatzi-geruza Max adibidea

$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

Algoritmo/ giltza sintaxi alternatiboa

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

Iturburua ezabatu sortze arrakastatsua eskuzko ondoren

.\LockBox.Cli.exe create `
  -s "D:\TempToEncrypt" `
  -o "E:\Backups\temp.lbx" `
  --master-env LBX_MASTER `
  --layer-env AES-256-GCM=LBX_L1 `
  --delete-source

--delete-source jatorrizko karpeta ezabatzen du kontainerra behar bezala sortu ondoren bakarrik. Agendatzaileak aukera desberdin bat du: --delete-source-contents.

Kontainerra suntsitzeko pasahitza

Max edizioak kontainer bati suntsitzeko pasahitz bereizi bat gehitu dezake. Pasahitz hori gero sartzen bada pasahitz nagusi gisa, LockBox-ek berehala gainidatziko du kontainera baimenik gabe. Hau presio-egoeretarako da. Mantendu benetako pasahitz nagusitik bereizita.

Agindua diskoaren espazio libre egiaztatzen du, jatorrizko edukiontziaren datuak sekretu aleatorio berri batekin eta AES-256-GCM bidez fitxategi behin-behineko batean zifratu, emaitza jatorrizko tamaina zehatzera normalizatu, jatorrizko fitxategia ordezkatu eta sekretu aleatorioa ahazten du. Edukiontzi zatituentzat, karpeta berean dauden .lbx, .lbx1, .lbx2 zatia guztia ordezkatzen da, zatien jatorrizko tamainak mantenduz.

Desagerpen pasahitzarekin sortu

$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

Geruzako gakoak gabe desagerpena abiarazi

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

Linux abiarazlea

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

Desagerpen arrakastatsua izan ondoren, edukiontzia ez da LockBox fitxategi balioduna. CLIak irteera kodea itzultzen du 0 eskatutako suntsipen ekintza arrakastaz burutu zelako.

Ireki ontziak

open ontzi bat irteera karpetara ateratzen du. Ateratze arrunt baterako, geruza gakoak sortzean erabili zen orden berean pasa behar dira. Suntsipen-pasahitz lan-fluxu baterako, ontziaren bidea, irteera bidea eta suntsipen-pasahitza pasahitz nagusi gisa bakarrik behar dira.

Ireki geruza bakarreko ontzi bat

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

Ireki ontzi zatitutako bat

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

Ireki geruza anitzeko ontzi bat

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

Izen bereziak

open
decrypt
extract

Kopia leheneratuz egiaztatu

Sortu report.csv proba-fitxategi txikia. Erauzi karpeta berri batera; barruan iturburu-karpetaren izena mantentzen da. Gorde zati guztiak batera eta alderatu aldatu gabeko iturburuarekin. Erauzketak idazteko aldi baterako lekua behar du edukiontziaren ondoan. Babestu leheneratutako zifratu gabeko fitxategiak ere.

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

Planifikatzailea

Planifikatzailearen komandoak Max edizioan daude eskuragarri. Lanaren metadatu osoa gordetzen dute zifratuta .lbxjobs fitxategia, iturburu-bidea, irteera-bidea, pasahitzak, suntsiketa-pasahitza, geruza-gakoak, konpresioa, betetzea, zatitzea eta iturburu-edukien ezabatzeko ezarpena barne.

Egutegian jarritako lanak bakarrik exekutatzen dira bitartean LockBox.Cli.exe schedule run exekutatzen ari da. Erabili Windows Task Scheduler, Linux systemd, cron, zerbitzu-enbaxadore bat edo kontsola-saio luze bat behar izanez gero langilea berabiaraztean automatikoki hasteko.

Maiztasun balioak

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

Eguneroko segurtasun-kopia enkriptatu bat gehitu

$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

Gehitu helburu bat, non iturburu karpetaren edukia ezabatuko den arrakasta lortu ondoren

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

Gehitu hilabeteko artxibo bat, betetzea eta zatika banatzea barne

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

Zerrendatu gorde diren zereginak

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

Exekutatu ordutegiaren langilea

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

Exekutatu epean dauden zereginak behin bakarrik eta irten

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

Erakutsi azken exekuzioaren egoera

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

Egoera-markak hauek dira [OK], [RUNNING], eta [FAILED]. Zeregina huts egiten badu, hutzeko arrazoia barne hartzen du eta erabiltzaileari aholkatzen dio arazoa errepikatzen bada laguntza jar dadin kontakti dezala.

JSON eskritura/scriptak

Erabili --script workflow batek hainbat pauso dituenean. Eskritura exekutatzaileak honakoak onartzen ditu create, open, keygen, algorithms, device-id, license, eta activate.

Sortu eta ireki script bakarrean

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

Huts egin duen pauso baten ondoren jarraitu

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

Aktibatu script-etik

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

JSON eremuak eta exekuzio-arauak

Taulak create eremuak eta open gako-zerrendak CLI aukerekin lotzen ditu. Bide erlatiboak prozesuaren lan-direktoriotik hasten dira; aldagaiak eta datak ez dira ordezkatzen. Erabili sekretu-iturburu bakarra eremu bakoitzeko. open komandoak keys, gero keyEnvs eta keyFiles irakurtzen ditu. Hobetsi stopOnError: true; false erabilita geroagoko arrakastak aurreko errorea ezkuta dezake. JSON scriptek ez dituzte antolatzailearen komandoak onartzen.

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

Automatizazio errezetak

Datu-base enkriptatuaren babeskopia

$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 artxiboaren babesa

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

Bideratu seguruak partnerra

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

Ebazpen luzeko artxiboa

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

Batch fitxategiaren adibidea

@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: hainbat karpetaren kopiak

Gorde scripta adierazitako bidean. Iturburu bakoitzeko izen bakarreko edukiontzia eta egunkaria sortzen ditu, errorean gelditzen da eta CLI irteera-kodea gordetzen du. AES-128-GCM Free bertsioan dabil; konpresioak eta zatitzeak Pro edo Max behar dute.

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: zaintzarik gabeko kopiak

Gorde Bash scripta LF lerro-amaierarekin. Prestatu CLI eta sekretuak adierazitako bideetan, eta pasa iturburu-karpetak argumentu gisa. Exekuzio bakoitzak direktorio propioa du. Erroreek egunkaria eta zero ez den kodea uzten dituzte; iturburuak mantentzen dira.

/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

Sistema eragilearen bidez programatu

Lanek goiko scriptak abiarazten dituzte; create horrela erabiltzeko ez da Max behar. Windows erregistroa erabiltzailea saioa hasita dagoenean soilik dabil; behar bada, konfiguratu saiorik gabeko exekuzioa ataza-antolatzailean. Gehitu cron babeskopien kontuko crontab fitxategian flock egiaztatu ondoren. Bi adibideak tokiko 02:00etan dabiltza eta programatutako exekuzioak gainjartzea eragozten dute. Egiaztatu baimenak eta probatu eskuz.

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: antolatzailea kudeatu

Sortu lockbox zerbitzu-kontua beharrezko baimenekin, aktibatu Max kontu horretan eta prestatu jobs.txt UTF-8 pasahitz-fitxategi bereizia. add gehitzeko da, ez eguneratzeko: erabili behin lan bakoitzeko. Exekutatu prozesu bakarra lan-fitxategi bakoitzeko eta berrabiarazi aldaketen ondoren. Egoeraren JSONak ez du historia berreskuratzen: atzeratutako errepikapenak saltatzen dira, atzeratutako once lana berriro exekuta daiteke. Sistemaren aldizkako abiarazteetarako erabili create, ez run-once errepikatua. Antolatzaileak irteera-izena berrerabiltzen du.

/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

Komandoen erreferentzia

Sortu aukerak

Ireki aukerak

Programadore aukerak

Erabili --language edo --lang kontsolaren hizkuntza hautatzeko, eta --quiet ohiko aurrerapena ezkutatzeko; erroreak erroreen irteera estandarrera bidaltzen dira oraindik. Ctrl+C sakatzeak ezeztatzea eskatzen du eta 1 kodea itzultzen du. 2 kodeak komandoaren sintaxi baliogabea adierazten du; 3 kodeak sortzeko eginbide bat uneko edizioan ez dagoela erabilgarri adierazten du. 0 kodeak nahita aktibatutako suntsipen-pasahitza ere barne hartzen du; beraz, berez ez du frogatzen fitxategiak erauzi direnik. Egiaztatu espero den irteera hurrengo automatizazio-urratsen aurretik.

Irteera-kodeak eta jarraipena

schedule run-once komandoak zero itzul dezake lanek huts egin arren; schedule status komandoak ere bai egoerarik gabe. Egiaztatu savedAt, lastSuccessAt eta lastError; [OK] Ready hutsa izan daiteke. Monitoreak eguneroko kopiak, 30 segundoko kontsultak eta 26 ordu barruko arrakasta espero ditu. Egokitu mugak. JSON egoerak zenbakiak dira; --quiet aukerak create/open arrakastatsuen ohiko irteera ezkutatzen du.

$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

Arazoen konponketa