Dokumentasi LockBox CLI

Mulai cepat

Tempatkan LockBox.Cli.exe dalam folder yang termasuk dalam PATH, atau panggil dengan jalur lengkap. Penanda --cli diterima untuk kompatibilitas tetapi tidak diperlukan dalam build hanya CLI.

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

Alur kerja minimal buat dan buka:

$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 menggunakan perintah yang sama dengan jalur miring dan binari tanpa akhiran .exe:

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

Memasang dan memeriksa CLI

Ekstrak ZIP sesuai sistem dan prosesor. .NET sudah disertakan. Bandingkan hash dengan SHA256SUMS.txt. Tempatkan CLI di jalur absolut berikut, lalu periksa bantuan dan lisensi menggunakan akun pencadangan.

Linux juga memerlukan dependensi native distribusi, termasuk ICU dan OpenSSL; .NET bawaan tidak menyediakannya. Di Windows, kebijakan eksekusi yang berlaku harus mengizinkan skrip PowerShell.

.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

Folder, jalur, dan ruang

Sesuaikan jalur contoh. Folder sumber tidak boleh kosong dan kontainer harus berada di luarnya. Nama keluaran yang sama mengganti kontainer lama beserta bagiannya. Sediakan ruang sementara di samping kontainer dan salinan sumber untuk tugas terjadwal. Satuan ukuran berbasis 1024; padding menambahkan byte.

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

Menyiapkan berkas rahasia

Buat rahasia satu kali, simpan cadangan terlindungi, dan batasi akses berkas. Contoh menolak penggantian kunci yang sudah ada. Berkas UTF-8 mempertahankan spasi, tetapi menghapus baris baru di akhir. Simpan kunci asli untuk cadangan lama.

$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

Aktivasi dan status lisensi

Kunci lisensi terikat pada ID perangkat yang dicetak oleh build CLI yang sama. Jika lisensi disalin ke PC lain, LockBox menolaknya dan kembali ke versi Gratis.

Windows memeriksa lokasi data aplikasi LockBox yang ada. Linux menyimpan aktivasi di $XDG_CONFIG_HOME/lockbox/.lockbox.license, lalu ~/.config/lockbox/.lockbox.license, dengan ~/.lockbox/.lockbox.license sebagai cadangan.

.\LockBox.Cli.exe device-id

.\LockBox.Cli.exe license

Aktifkan dari file lisensi

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

Aktifkan dari variabel lingkungan

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

Aktifkan secara inline

Aktivasi inline bekerja, tetapi bisa bocor melalui riwayat shell atau log proses.

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

Aktivasi Linux

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

Penanganan rahasia

Lebih baik menggunakan variabel lingkungan atau file. Rahasia yang disisipkan hanya berguna untuk pengujian. Kata sandi utama dan kunci lapisan harus dipertahankan: tanpa mereka, kontainer tidak dapat dibuka.

Rahasia berbasis file

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

Algoritma dan pembuatan kunci

Gunakan algorithms untuk melihat semua profil yang didukung dan edisi minimum. Gunakan keygen untuk kunci lapisan.

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

Alias perintah yang didukung:

algorithms
list-algorithms
profiles

keygen
generate-key
generate-keys

Buat kontainer

create mengemas folder sumber, menerapkan kompresi dan padding opsional, mengenkripsi payload melalui satu atau lebih lapisan, dan menulis kontainer .lbx.

Opsi yang dibutuhkan

• --source atau -s: folder sumber.
• --output atau -o: jalur output .lbx.
• --master, --master-env, atau --master-file.
• Paling tidak satu lapisan: --layer, --layer-env, atau --layer-file.

Kontainer AES minimal

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

Kontainer terkompresi

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

Padding kripto

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

Memisahkan kontainer menjadi bagian-bagian

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

Bagian pertama tetap .lbx. Bagian tambahan menggunakan .lbx1, .lbx2, dan seterusnya. Simpan semua bagian di folder yang sama.

Contoh Max sembilan lapisan

$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

Algoritma/sintaks alternatif kunci

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

Hapus sumber setelah pembuatan manual berhasil

.\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 hanya menghapus folder sumber setelah kontainer berhasil dibuat. Penjadwal memiliki opsi berbeda: --delete-source-contents.

Kata sandi penghancuran kontainer

Edisi maksimal dapat menambahkan kata sandi penghancuran terpisah ke suatu kontainer. Jika kata sandi tersebut dimasukkan nanti sebagai kata sandi utama, LockBox segera menimpa kontainer tanpa konfirmasi. Ini dimaksudkan untuk skenario tekanan pemaksaan. Simpan terpisah dari kata sandi utama yang sebenarnya.

Perintah memeriksa ruang disk bebas, mengenkripsi data kontainer asli dengan rahasia acak baru dan AES-256-GCM ke dalam file sementara, menormalkan hasilnya ke ukuran asli yang tepat, menggantikan file asli, dan melupakan rahasia acak tersebut. Untuk kontainer terpisah, setiap .lbx, .lbx1, .lbx2 bagian dalam folder yang sama diganti sambil mempertahankan ukuran bagian asli.

Buat dengan kata sandi penghancuran

$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

Memicu penghancuran tanpa kunci lapisan

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

Memicu di Linux

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

Setelah penghancuran berhasil, kontainer tidak lagi menjadi file LockBox yang valid. CLI mengembalikan kode keluar 0 karena aksi penghancuran yang diminta telah berhasil diselesaikan.

Buka kontainer

open mengekstrak kontainer ke folder output. Untuk ekstraksi normal, kunci lapisan harus diberikan dalam urutan yang sama seperti saat pembuatan. Untuk alur kerja kata sandi penghancuran, hanya jalur kontainer, jalur output, dan kata sandi penghancuran sebagai kata sandi utama yang diperlukan.

Buka kontainer satu lapisan

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

Buka kontainer terpisah

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

Buka kontainer multi-lapisan

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

Alias

open
decrypt
extract

Memverifikasi cadangan dengan pemulihan

Buat report.csv kecil untuk pengujian. Ekstrak ke folder baru; nama folder sumber tetap dipertahankan di dalamnya. Simpan semua bagian bersama dan bandingkan dengan sumber yang tidak berubah. Ekstraksi memerlukan ruang sementara yang dapat ditulis di samping kontainer. Lindungi juga berkas hasil pemulihan yang tidak terenkripsi.

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

Penjadwal

Perintah penjadwal tersedia di edisi Max. Mereka menyimpan metadata tugas lengkap dalam file .lbxjobs yang dienkripsi, termasuk jalur sumber, jalur output, kata sandi, kata sandi penghancuran, kunci lapisan, kompresi, padding, pemisahan, dan pengaturan hapus konten sumber.

Tugas yang dijadwalkan hanya berjalan saat LockBox.Cli.exe schedule run berjalan. Gunakan Windows Task Scheduler, systemd Linux, cron, pembungkus layanan, atau sesi konsol yang berjalan lama jika Anda ingin pekerja mulai otomatis setelah reboot.

Nilai frekuensi

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

Tambahkan tugas cadangan terenkripsi harian

$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

Tambahkan tugas yang menghapus konten folder sumber setelah berhasil

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

Tambahkan arsip bulanan dengan padding dan bagian terpisah

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

Daftar tugas yang disimpan

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

Jalankan pekerja penjadwal

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

Jalankan tugas yang jatuh tempo sekali dan keluar

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

Tampilkan status runtime terbaru

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

Penanda status adalah [OK], [RUNNING], dan [FAILED]. Tugas yang gagal menyertakan alasan dan memberitahu pengguna untuk menghubungi dukungan jika masalah berulang.

Script JSON

Gunakan --script ketika alur kerja memiliki beberapa langkah. Runner script mendukung create, open, keygen, algorithms, device-id, license, dan activate.

Buat dan buka dalam satu script

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

Lanjutkan setelah langkah gagal

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

Aktifkan dari script

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

Kolom JSON dan aturan eksekusi

Tabel memetakan kolom create dan larik kunci open ke opsi CLI. Jalur relatif dimulai dari direktori kerja proses; variabel dan tanggal tidak diganti. Gunakan satu sumber rahasia per kolom. open membaca keys, lalu keyEnvs dan keyFiles. Utamakan stopOnError: true; dengan false, keberhasilan berikutnya dapat menutupi kegagalan sebelumnya. Skrip JSON tidak mendukung perintah penjadwal.

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

Resep otomasi

Backup dump database terenkripsi

$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

Perlindungan artefak CI

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

Transfer aman ke mitra

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

Arsip jangka panjang

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

Contoh berkas batch

@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: mencadangkan beberapa folder

Simpan skrip di jalur yang ditunjukkan. Skrip membuat kontainer bernama unik dan log untuk setiap sumber, berhenti saat gagal, dan mempertahankan kode keluar CLI. AES-128-GCM bekerja pada Free; kompresi dan pemisahan memerlukan Pro atau Max.

C:\LockBox\backup.ps1

param(
    [string[]]$Source = @('D:\Data'),
    [string]$Destination = 'E:\Backups'
)
$ErrorActionPreference = 'Stop'
$cli = 'C:\Tools\LockBox\LockBox.Cli.exe'
$secretDir = 'C:\LockBox\secrets'
try {
    foreach ($folder in $Source) {
        $sourcePath = (Resolve-Path -LiteralPath $folder).Path
        $stamp = (Get-Date).ToUniversalTime().ToString('yyyyMMdd-HHmmss-fff')
        $runId = [guid]::NewGuid().ToString('N')
        $runDir = Join-Path $Destination "$stamp-$runId"
        New-Item -ItemType Directory -Path $runDir | Out-Null
        $container = Join-Path $runDir 'data.lbx'
        $log = Join-Path $runDir 'create.log'
        $cliArgs = @(
            '--quiet', 'create', '--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: pencadangan tanpa pengawasan

Simpan skrip Bash dengan akhir baris LF. Siapkan CLI dan rahasia pada jalur yang ditunjukkan, lalu berikan folder sumber sebagai argumen. Setiap proses mendapat direktori tersendiri. Kegagalan meninggalkan log dan kode bukan nol; sumber tetap disimpan.

/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

Menjadwalkan melalui sistem operasi

Tugas ini menjalankan skrip di atas; penggunaan create ini tidak memerlukan Max. Pendaftaran Windows berjalan hanya ketika pengguna masuk; atur eksekusi tanpa masuk di Penjadwal Tugas bila perlu. Tambahkan cron ke crontab akun pencadangan setelah memastikan flock tersedia. Kedua contoh berjalan pukul 02:00 waktu setempat dan mencegah eksekusi terjadwal bertumpuk. Periksa izin dan uji secara manual.

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: mengoperasikan penjadwal

Buat akun layanan lockbox dengan izin yang diperlukan, aktifkan Max untuk akun itu, dan siapkan berkas sandi UTF-8 terpisah jobs.txt. add menambahkan, bukan memperbarui: gunakan sekali per tugas. Jalankan satu proses per berkas tugas dan mulai ulang setelah perubahan. JSON status tidak memulihkan riwayat: pengulangan yang terlambat dilewati, tugas once yang terlambat dapat berjalan lagi. Untuk peluncuran berkala oleh sistem gunakan create, bukan run-once berulang. Penjadwal memakai kembali nama keluaran.

/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

Referensi perintah

Buat opsi

Opsi buka

Opsi penjadwal

Gunakan --language atau --lang untuk memilih bahasa konsol dan --quiet untuk menyembunyikan kemajuan rutin; kesalahan tetap dikirim ke aliran kesalahan standar. Ctrl+C meminta pembatalan dan mengembalikan kode 1. Kode 2 berarti sintaks perintah tidak valid; kode 3 berarti fitur pembuatan tidak tersedia pada edisi saat ini. Kode 0 juga mencakup pemicu kata sandi pemusnahan yang disengaja, sehingga kode ini sendiri tidak membuktikan bahwa berkas telah diekstrak. Periksa keluaran yang diharapkan sebelum langkah otomatisasi berikutnya.

Kode keluar dan pemantauan

schedule run-once dapat mengembalikan nol meskipun tugas gagal; schedule status juga saat status tidak ada. Periksa savedAt, lastSuccessAt, dan lastError; [OK] bisa hanya berarti Ready. Monitor mengharapkan cadangan harian, pemeriksaan setiap 30 detik, dan keberhasilan dalam 26 jam. Sesuaikan ambang batas. Status JSON berupa angka; --quiet meniadakan keluaran rutin create/open yang berhasil.

$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

Pemecahan Masalah