LockBox CLI -dokumentaatio

Pika-aloitus

Laita LockBox.Cli.exe kansioon, joka sisältyy PATH-polkuun, tai kutsu sitä täydellä polulla. --cli-merkintä hyväksytään yhteensopivuuden vuoksi mutta ei ole pakollinen pelkkä CLI-rakennelma huomioiden.

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

Minimaalinen luonti- ja avaustyönkulku:

$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 käyttää samoja komentoja kauttaviivapoluilla ja binaaria ilman .exe-päätettä:

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:n asennus ja tarkistus

Pura järjestelmälle ja suorittimelle sopiva ZIP. .NET sisältyy pakettiin. Vertaa tiivistettä SHA256SUMS.txt-tiedostoon. Sijoita CLI alla olevaan absoluuttiseen polkuun ja tarkista ohje sekä lisenssi varmuuskopiointitilillä.

Linux tarvitsee myös jakelun natiivikirjastot, kuten ICU:n ja OpenSSL:n; mukana tuleva .NET ei sisällä niitä. Windowsissa voimassa olevan suorituskäytännön on sallittava PowerShell-komentosarjat.

.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

Kansiot, polut ja levytila

Muokkaa polut sopiviksi. Lähdekansio ei saa olla tyhjä ja säiliön on oltava sen ulkopuolella. Sama kohdenimi korvaa aiemman säiliön osineen. Varaa väliaikaistilaa säiliön viereen ja lähdekopio ajastetuille tehtäville. Kokoyksiköt perustuvat lukuun 1024; täyte lisää tavuja.

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

Salaisuustiedostojen valmistelu

Luo salaisuudet kerran, säilytä suojattu varmuuskopio ja rajoita tiedostojen käyttöoikeuksia. Esimerkit eivät korvaa olemassa olevia avaimia. UTF-8-tiedostojen välilyönnit säilyvät, lopun rivinvaihdot poistetaan. Vanhoihin kopioihin tarvitaan alkuperäiset avaimet.

$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

Aktivointi ja lisenssitila

Lisenssiavain on sidottu laite-ID:hen, joka tulostetaan samalla CLI-rakennelmalla. Jos lisenssi kopioidaan toiselle tietokoneelle, LockBox hylkää sen ja palaa Free-versioon.

Windows tarkistaa olemassa olevat LockBox-sovellustiedostojen sijainnit. Linux tallentaa aktivoinnin $XDG_CONFIG_HOME/lockbox/.lockbox.license, sitten ~/.config/lockbox/.lockbox.license, käyttäen ~/.lockbox/.lockbox.license varavaihtoehtona.

.\LockBox.Cli.exe device-id

.\LockBox.Cli.exe license

Aktivoi lisenssitiedostosta

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

Aktivoi ympäristömuuttujasta

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

Aktivoi suoraan

Suora aktivointi toimii, mutta se voi vuotaa kuoren historiaan tai prosessilokeihin.

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

Linux-aktivointi

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

Salaisuuksien käsittely

Suosi ympäristömuuttujia tai tiedostoja. Inline-salaisuudet ovat hyödyllisiä vain testauksessa. Pääsalasanat ja kerroksen avaimet on säilytettävä: ilman niitä konttia ei voi avata.

Tiedostopohjaiset salaisuudet

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

Algoritmit ja avaimen generointi

Käytä algorithms nähdäksesi kaikki tuetut profiilit ja vähimmäisversiot. Käytä keygen kerroksen avaimille.

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

Tuetut komentoaliaset:

algorithms
list-algorithms
profiles

keygen
generate-key
generate-keys

Luo kontteja

create pakkaa lähdekansion, käyttää valinnaista pakkausta ja täytettä, salaa hyötykuorman yhdellä tai useammalla kerroksella ja kirjoittaa .lbx-kontin.

Vaaditut valinnat

• --source tai -s: lähdekansio.
• --output tai -o: tulosteen .lbx-polku.
• --master, --master-env tai --master-file.
• Ainakin yksi kerros: --layer, --layer-env tai --layer-file.

Minimaalinen AES-kontti

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

Pakattu kontti

.\LockBox.Cli.exe create `
  --source "D:\Exports" `
  --output "E:\Backups\exports.lbx" `
  --master-env LBX_MASTER `
  --layer-env AES-256-GCM=LBX_L1 `
  --compress

Kryptotäyte

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

Jaa kontti osiin

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

Ensimmäinen osa säilyttää .lbx. Lisäosat käyttävät .lbx1, .lbx2 ja niin edelleen. Säilytä kaikki osat samassa kansiossa.

Yhdeksän kerroksen Max-esimerkki

$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

Vaihtoehtoinen algoritmi/avaimen syntaksi

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

Poista lähde onnistuneen manuaalisen luomisen jälkeen

.\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 poistaa lähdekansion vain sen jälkeen, kun kontti on onnistuneesti luotu. Ajastimella on eri vaihtoehto: --delete-source-contents.

Kontin tuhoamissalasana

Max-versio voi lisätä kontin erillisen tuhoamissalasanan. Jos tämä salasana syötetään myöhemmin pääsalasanana, LockBox ylikirjoittaa kontin välittömästi ilman vahvistusta. Tämä on tarkoitettu pakotustilanteita varten. Pidä se erillään varsinaisesta pääsalasanasta.

Komento tarkistaa vapaan levytilan, salaa alkuperäisen kontin datan uudella satunnaisella salaisella ja AES-256-GCM:llä tilapäiseen tiedostoon, normalisoi tuloksen tarkalle alkuperäiselle koolle, korvaa alkuperäisen tiedoston ja unohtaa satunnaisen salaisuuden. Pilkottujen konttien kohdalla jokainen .lbx, .lbx1, .lbx2 -osa samassa kansiossa korvataan samalla säilyttäen alkuperäiset osakoot.

Luo tuhoamissalasanalla

$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

Käynnistä tuhoaminen ilman kerrosavaimia

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

Linuxin laukaisu

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

Onnistuneen tuhoamisen jälkeen kontti ei enää ole voimassa oleva LockBox-tiedosto. CLI palauttaa poistumiskoodin 0, koska pyydetty tuhoamistoiminto suoritettiin onnistuneesti.

Avaa kontit

open purkaa kontin tuloskansioon. Tavallisessa purkamisessa kerrosavaimet on annettava samassa järjestyksessä kuin luomisen yhteydessä. Tuhoamissalasanan työnkulussa tarvitaan vain kontin polku, tuloskansio ja tuhoamissalasana pääsalasanaana.

Avaa yhden kerroksen kontti

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

Avaa pilkottu kontti

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

Avaa monikerroksinen kontti

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

Aliasnimitykset

open
decrypt
extract

Varmuuskopion tarkistus palauttamalla

Luo pieni report.csv-testitiedosto. Pura uuteen kansioon, jonka sisällä lähdekansion nimi säilyy. Pidä kaikki osat yhdessä ja vertaa muuttumattomaan lähteeseen. Purkaminen tarvitsee kirjoitettavaa väliaikaistilaa säiliön vierestä. Suojaa myös palautetut salaamattomat tiedostot.

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

Aikatauluttaja

Aikatauluttajakomentoja on saatavilla Max-versiossa. Ne tallentavat koko tehtävän metatiedot salattuun .lbxjobs-tiedostoon, mukaan lukien lähdepolku, tulospolku, salasanat, tuhoamissalasana, kerrosavaimet, pakkaus, täyte, jakaminen ja poista-lähdesisältö-asetus.

Aikataulutetut tehtävät suoritetaan vain, kun LockBox.Cli.exe schedule run on käynnissä. Käytä Windowsin Tehtävien ajastinta, Linuxin systemd:tä, cronia, palvelukäärettä tai pitkäkestoista konsolityökertaa, jos haluat työntekijän käynnistyvän automaattisesti uudelleenkäynnistyksen jälkeen.

Taajuusarvot

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

Lisää päivittäinen salattu varmuuskopiointitehtävä

$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

Lisää tehtävä, joka poistaa lähdekansion sisällön onnistumisen jälkeen

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

Lisää kuukausittainen arkisto täytteellä ja jaetuilla osilla

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

Listaa tallennetut tehtävät

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

Suorita aikatauluttajan työntekijä

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

Suorita erääntyneet tehtävät kerran ja lopeta

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

Näytä viimeisin suoritustila

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

Tilamerkit ovat [OK], [RUNNING] ja [FAILED]. Epäonnistunut tehtävä sisältää syyn ja ohjeistaa käyttäjää ottamaan yhteyttä tukeen, jos ongelma toistuu.

JSON-skriptit

Käytä --script, kun työnkulussa on useita vaiheita. Skriptien suorittaja tukee create, open, keygen, algorithms, device-id, license ja activate.

Luo ja avaa yhdessä skriptissä

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

Jatka epäonnistuneen vaiheen jälkeen

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

Aktivoi skriptistä

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

JSON-kentät ja suoritussäännöt

Taulukko yhdistää create-kentät ja open-avainlistat CLI-valintoihin. Suhteelliset polut alkavat prosessin työhakemistosta; muuttujia ja päivämääriä ei korvata. Käytä yhtä salaisuuslähdettä kenttää kohti. open lukee keys, sitten keyEnvs ja keyFiles. Suosi stopOnError: true; false-asetuksella myöhempi onnistuminen voi peittää aiemman virheen. JSON-komentosarjat eivät tue ajastinkomentoja.

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

Automaatioreseptit

Salattu tietokantadumppi varmuuskopiona

$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-artifaktien suojaus

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

Turvallinen yhteistyökumppanin siirto

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

Pitkäaikainen arkisto

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

Esimerkki erätiedostosta

@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: useiden kansioiden kopiointi

Tallenna komentosarja annettuun polkuun. Se luo jokaiselle lähteelle yksilöllisen säiliön ja lokin, pysähtyy virheeseen ja säilyttää CLI:n paluukoodin. AES-128-GCM toimii Free-versiossa; pakkaus ja osiin jako vaativat Pro- tai Max-version.

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: valvomaton varmuuskopiointi

Tallenna Bash-komentosarja LF-rivinvaihdoilla. Valmistele CLI ja salaisuudet annettuihin polkuihin ja välitä lähdekansiot argumentteina. Jokainen ajo saa oman hakemiston. Virheestä jää loki ja nollasta poikkeava paluukoodi; lähdetiedostot säilyvät.

/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

Ajastus käyttöjärjestelmällä

Tehtävät käynnistävät yllä olevat komentosarjat; tämä create-käyttö ei vaadi Max-versiota. Windows-rekisteröinti toimii vain käyttäjän ollessa kirjautuneena; määritä tarvittaessa ajo ilman kirjautumista Tehtävien ajoituksessa. Lisää cron varmuuskopiointitilin crontabiin ja tarkista flock. Molemmat esimerkit ajavat klo 02:00 paikallista aikaa ja estävät ajastettujen ajojen päällekkäisyyden. Tarkista oikeudet ja kokeile käsin.

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: ajastimen ylläpito

Luo palvelutili lockbox tarvittavin oikeuksin, aktivoi sille Max ja valmistele erillinen UTF-8-salasanatiedosto jobs.txt. add lisää eikä päivitä: käytä kerran tehtävää kohti. Aja yhtä prosessia tehtävätiedostoa kohti ja käynnistä uudelleen muutosten jälkeen. Tila-JSON ei palauta historiaa: myöhästyneet toistot ohitetaan, myöhästynyt once-tehtävä voi käynnistyä uudelleen. Käytä käyttöjärjestelmän toistuviin käynnistyksiin create-komentoa toistuvan run-once-komennon sijaan. Ajastin käyttää samaa kohdenimeä uudelleen.

/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

Komentoviite

Luo vaihtoehtoja

Avaa vaihtoehdot

Aikataulun vaihtoehdot

--language tai --lang valitsee konsolin kielen; --quiet piilottaa tavalliset etenemisviestit, mutta virheet tulostetaan edelleen vakiovirhevirtaan. Ctrl+C pyytää peruutusta ja palauttaa koodin 1. Koodi 2 tarkoittaa virheellistä komentorakennetta ja 3 luontitoimintoa, jota nykyinen versiotaso ei tue. Koodi 0 palautetaan myös tuhoamissalasanan tarkoituksellisesta käytöstä, joten se ei yksin todista tiedostojen purkamista. Tarkista odotettu tulos ennen automaation seuraavia vaiheita.

Paluukoodit ja valvonta

schedule run-once voi palauttaa nollan tehtävävirheistä huolimatta; schedule status myös ilman tilaa. Tarkista savedAt, lastSuccessAt ja lastError; [OK] voi tarkoittaa pelkkää Ready-tilaa. Valvonta olettaa päivittäiset kopiot, 30 sekunnin kyselyvälin ja onnistumisen 26 tunnin sisällä. Muokkaa rajoja. JSON-tilat ovat numeroita; --quiet vaimentaa onnistuneiden create/open-komentojen tavallisen tulosteen.

$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

Vianmääritys