LockBox CLI 文件

快速開始

將 LockBox.Cli.exe 放入包含於 PATH 的資料夾中， 或使用完整路徑呼叫它。為了兼容性，接受 --cli 標記， 但在僅 CLI 的版本中不是必須的。

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

最小的建立與開啟工作流程：

$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 使用相同的指令，只是路徑使用斜線，且二進位檔無 .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

安裝並驗證 CLI

解壓縮適合作業系統和處理器的 ZIP 套件。程式已包含 .NET。將雜湊值與 SHA256SUMS.txt 核對。把 CLI 放在下文所示的絕對路徑，並使用將執行備份的帳戶檢查說明和授權。

Linux 還需要發行版的原生相依程式庫，包括 ICU 和 OpenSSL；內建 .NET 並未提供這些程式庫。Windows 的有效執行原則必須允許執行 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

資料夾、路徑和磁碟空間

請替換範例路徑。來源資料夾不能為空，容器必須儲存在其外部。重複使用輸出名稱會取代原有容器及其分割檔。為容器旁的暫存檔預留空間，排程工作還需要來源資料副本的空間。容量單位以 1024 為基數；填補是增加位元組，而非設定最終總大小。

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

準備可重複使用的機密檔案

機密資訊僅產生一次，保留受保護的備份並限制檔案存取。範例會拒絕覆寫現有金鑰。UTF-8 檔案末尾的換行會移除，但空白會保留。開啟舊備份仍需原來的金鑰。

$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

啟動與授權狀態

授權金鑰綁定於相同 CLI 版本所顯示的裝置 ID。 如果授權被複製到另一台電腦，LockBox 將拒絕並回退到免費版本。

Windows 檢查現有的 LockBox 應用程式資料位置。Linux 將啟動資訊存放於 $XDG_CONFIG_HOME/lockbox/.lockbox.license，然後 ~/.config/lockbox/.lockbox.license，使用 ~/.lockbox/.lockbox.license 作為備援。

.\LockBox.Cli.exe device-id

.\LockBox.Cli.exe license

從授權檔啟動

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

從環境變數啟動

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

內嵌啟動

內嵌啟動可行，但可能透過 shell 歷史或程序日誌洩漏。

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

Linux 啟動

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

祕密處理

優先使用環境變數或檔案。內嵌祕密僅適用於測試。 必須保留主密碼和層金鑰：沒有它們，容器無法被開啟。

基於檔案的祕密

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

演算法與金鑰生成

使用 algorithms 查看所有支援的設定檔及最低版本要求。 使用 keygen 取得層金鑰。

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

支援的命令別名：

algorithms
list-algorithms
profiles

keygen
generate-key
generate-keys

建立容器

create 打包來源資料夾，套用可選的壓縮和填充， 透過一個或多個層加密有效載荷，並寫入 .lbx 容器。

必要選項

• --source 或 -s：來源資料夾。
• --output 或 -o：輸出 .lbx 路徑。
• --master、--master-env 或 --master-file。
• 至少一層：--layer、--layer-env 或 --layer-file。

最小 AES 容器

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

壓縮容器

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

加密填充

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

將容器拆分成多個部分

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

第一個部分保留 .lbx。附加部分使用 .lbx1、.lbx2，依此類推。請將所有部分保存在相同資料夾中。

九層最大範例

$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

替代演算法/金鑰語法

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

手動建立成功後刪除來源

.\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 僅在容器成功建立後刪除來源資料夾。排程器有不同選項：--delete-source-contents。

容器銷毀密碼

Max 版本可以為容器新增單獨的銷毀密碼。如果稍後以主密碼輸入該密碼，LockBox 將立即在未經確認的情況下覆寫容器。 此功能用於強迫壓力情境。請將其與真正的主密碼分開保管。

該命令會檢查可用磁碟空間，使用新的隨機密鑰和 AES-256-GCM 將原始容器資料加密到臨時檔案，將結果標準化為與原始大小完全相同的大小， 替換原始檔案，並忘記隨機密鑰。對於拆分容器，位於同一資料夾中的每個 .lbx、.lbx1、.lbx2 部分都會被替換，同時保留原始部分大小。

使用銷毀密碼創建

$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

在沒有層密鑰的情況下觸發銷毀

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

Linux 觸發

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

銷毀成功後，該容器將不再是有效的 LockBox 檔案。CLI 返回退出代碼 0，表示請求的銷毀操作已成功完成。

開啟容器

open 將容器解壓到輸出資料夾。對於一般解壓，需要按照創建時使用的順序提供層密鑰。對於銷毀密碼工作流程，只需提供容器路徑、輸出路徑以及作為主密碼的銷毀密碼即可。

開啟單層容器

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

開啟拆分容器

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

開啟多層容器

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

別名

open
decrypt
extract

透過還原驗證備份

為範例建立小型 report.csv 檔案。解壓縮到新的資料夾，內部會保留來源資料夾名稱。將全部分割檔放在一起，並與未修改的來源資料比較。解壓縮需要容器旁可寫入的暫存空間；也應保護還原後的明文檔案。

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

排程器

排程器命令在 Max 版本中可用。它們將完整的任務元資料存儲在加密的 .lbxjobs 檔案中，包括來源路徑、輸出路徑、密碼、銷毀密碼、圖層金鑰、壓縮、填充、分割以及刪除來源內容的設定。

排定的工作僅在 LockBox.Cli.exe schedule run 運行時執行。 如果您需要工作程序在重新啟動後自動啟動，請使用 Windows 工作排程器、Linux systemd、cron、服務封裝器或長時間運行的控制台會話。

頻率值

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

新增每日加密備份任務

$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

新增成功後刪除來源資料夾內容的任務

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

新增帶填充和分割部分的每月存檔

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

列出已保存的任務

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

執行排程器工作程序

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

執行到期任務一次後退出

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

顯示最新執行狀態

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

狀態標記為 [OK]、[RUNNING] 和 [FAILED]。 失敗的任務會包含原因，並告知使用者若問題重複發生應聯絡支援。

JSON 腳本

當工作流程有多個步驟時使用 --script。腳本執行器支援 create、open、keygen、algorithms、 device-id、license 和 activate。

在一個腳本中創建並打開

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

在步驟失敗後繼續

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

從腳本啟動

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

JSON 欄位和執行規則

表格將 create 欄位及 open 金鑰陣列對應至 CLI 選項。相對路徑以程序工作目錄為基準，而不是 JSON 檔案位置。字串中的變數和日期不會自動展開。每個欄位只使用一個機密來源；open 依序讀取 keys、keyEnvs、keyFiles。建議使用 stopOnError: true；false 時，後續成功可能掩蓋先前失敗。JSON 指令碼不支援排程工作命令。

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

自動化範例

加密資料庫匯出備份

$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 工件保護

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

安全合作夥伴傳輸

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

長期存檔

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

批次檔範例

@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：備份多個資料夾

將指令碼儲存到指定路徑。它為每個來源建立名稱唯一的容器和記錄，遇到錯誤即停止，並保留 CLI 結束代碼。AES-128-GCM 範例適用於 Free；壓縮和分割需要 Pro 或 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：無人值守備份

使用 LF 換行儲存 Bash 指令碼。在指定路徑準備 CLI 和機密檔案，並將來源資料夾作為引數傳入。每次執行都有獨立目錄。失敗時會留下記錄並傳回非零結束代碼；來源檔案保持不變。

/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

透過作業系統定時執行

這些工作啟動上方的備份指令碼，此種 create 用法不需要 Max。Windows 註冊範例僅在使用者登入時執行；若需登出後執行，請在工作排程器中設定。確認已安裝 flock 後，將 cron 項目加入備份使用者的 crontab。兩個範例皆於本地時間 02:00 執行，並防止排程工作重疊。先檢查帳戶權限並手動測試。

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：執行排程工作程序

先建立具備所需權限的 lockbox 服務帳戶，為該帳戶啟用 Max，並準備獨立的 UTF-8 密碼檔 jobs.txt。add 會新增而非更新，每個工作只需執行一次。每個工作檔執行一個程序，修改定義後重新啟動。狀態 JSON 不會還原執行歷程：過期的週期工作時點會被略過，過期的 once 工作可能再次執行。使用作業系統定期啟動時，應呼叫 create，而非反覆呼叫 run-once。內建排程器會重複使用設定的輸出名稱。

/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

指令參考

創建選項

開啟選項

排程器選項

使用 --language 或 --lang 選擇主控台語言，使用 --quiet 隱藏一般進度；錯誤仍會輸出到標準錯誤串流。Ctrl+C 要求取消並傳回代碼 1。代碼 2 表示命令語法無效；代碼 3 表示目前版本不提供某項建立功能。代碼 0 也包含刻意觸發銷毀密碼的情況，因此僅憑該代碼無法證明檔案已被擷取。執行後續自動化步驟前，請驗證預期輸出。

結束代碼和備份監控

schedule run-once 即使有工作失敗也可能傳回零，schedule status 在缺少狀態時也傳回零。請檢查 savedAt、lastSuccessAt、lastError；[OK] 可能僅表示 Ready。此監控範例假設每日備份、每 30 秒輪詢，且在 26 小時內成功過一次，請依實際排程調整門檻。JSON 狀態使用數字。--quiet 會抑制成功 create/open 的一般輸出。

$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

故障排除