Tài liệu CLI của LockBox

Bắt đầu nhanh

Đặt LockBox.Cli.exe vào một thư mục được bao gồm trong PATH, hoặc gọi nó bằng đường dẫn đầy đủ. Đánh dấu --cli được chấp nhận để tương thích nhưng không bắt buộc trong bản build chỉ CLI.

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

Quy trình tạo và mở tối thiểu:

$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 sử dụng cùng lệnh với đường dẫn dấu gạch chéo và một nhị phân không có hậu tố .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

Cài đặt và kiểm tra CLI

Giải nén ZIP phù hợp với hệ điều hành và bộ xử lý. .NET đã được kèm theo. So sánh mã băm với SHA256SUMS.txt. Đặt CLI tại đường dẫn tuyệt đối bên dưới, rồi kiểm tra trợ giúp và giấy phép bằng tài khoản sao lưu.

Linux còn cần thư viện gốc của bản phân phối, gồm ICU và OpenSSL; .NET đi kèm không cung cấp chúng. Trên Windows, chính sách thực thi hiện hành phải cho phép tập lệnh 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

Thư mục, đường dẫn và dung lượng

Điều chỉnh các đường dẫn. Thư mục nguồn không được rỗng, còn vùng chứa phải nằm bên ngoài. Dùng lại tên đầu ra sẽ thay thế vùng chứa cũ và các phần. Dành chỗ tạm cạnh vùng chứa và chỗ cho bản sao nguồn khi chạy tác vụ định kỳ. Đơn vị kích thước dùng cơ số 1024; phần đệm cộng thêm 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

Chuẩn bị tệp bí mật

Tạo bí mật một lần, giữ bản sao được bảo vệ và giới hạn quyền truy cập tệp. Các ví dụ từ chối thay khóa đã có. Tệp UTF-8 giữ khoảng trắng nhưng bỏ xuống dòng ở cuối. Giữ khóa gốc để mở bản sao lưu cũ.

$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

Kích hoạt và trạng thái giấy phép

Khóa giấy phép được liên kết với ID thiết bị được in bởi cùng bản build CLI. Nếu một giấy phép được sao chép sang PC khác, LockBox sẽ từ chối và quay về chế độ Miễn phí.

Windows kiểm tra các vị trí dữ liệu ứng dụng LockBox hiện có. Linux lưu kích hoạt trong $XDG_CONFIG_HOME/lockbox/.lockbox.license, sau đó ~/.config/lockbox/.lockbox.license, với ~/.lockbox/.lockbox.license như một phương án dự phòng.

.\LockBox.Cli.exe device-id

.\LockBox.Cli.exe license

Kích hoạt từ tệp giấy phép

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

Kích hoạt từ biến môi trường

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

Kích hoạt trực tiếp

Kích hoạt trực tiếp hoạt động, nhưng có thể rò rỉ qua lịch sử shell hoặc nhật ký tiến trình.

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

Kích hoạt trên Linux

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

Xử lý bí mật

Ưu tiên sử dụng biến môi trường hoặc tệp. Bí mật nhúng chỉ hữu ích cho việc thử nghiệm. Mật khẩu chính và khóa lớp phải được bảo quản: nếu không có chúng, container không thể mở được.

Bí mật dựa trên tệp

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

Thuật toán và tạo khóa

Sử dụng algorithms để xem tất cả các hồ sơ hỗ trợ và các phiên bản tối thiểu. Sử dụng keygen cho khóa lớp.

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

Bí danh lệnh được hỗ trợ:

algorithms
list-algorithms
profiles

keygen
generate-key
generate-keys

Tạo container

create đóng gói một thư mục nguồn, áp dụng nén và đệm tùy chọn, mã hóa dữ liệu qua một hoặc nhiều lớp, và ghi ra một container .lbx.

Tùy chọn bắt buộc

• --source hoặc -s: thư mục nguồn.
• --output hoặc -o: đường dẫn .lbx đầu ra.
• --master, --master-env, hoặc --master-file.
• Ít nhất một lớp: --layer, --layer-env, hoặc --layer-file.

Container AES tối thiểu

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

Container đã nén

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

Đệm Crypto

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

Chia container thành các phần

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

Phần đầu giữ .lbx. Các phần bổ sung sử dụng .lbx1, .lbx2, v.v. Giữ tất cả các phần trong cùng một thư mục.

Ví dụ tối đa chín lớp

$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

Cú pháp thuật toán/chìa khóa thay thế

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

Xóa nguồn sau khi tạo thủ công thành công

.\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 chỉ xóa thư mục nguồn sau khi container được tạo thành công. Bộ lập lịch có một tùy chọn khác: --delete-source-contents.

Mật khẩu phá hủy container

Phiên bản Max có thể thêm một mật khẩu phá hủy riêng cho một container. Nếu mật khẩu đó được nhập sau này như là mật khẩu chính, LockBox sẽ ghi đè ngay lập tức container mà không cần xác nhận. Điều này dành cho các tình huống áp lực cưỡng chế. Hãy giữ nó tách biệt với mật khẩu chính thật.

Lệnh này kiểm tra dung lượng đĩa trống, mã hóa dữ liệu container gốc với một bí mật ngẫu nhiên mới và AES-256-GCM vào một tệp tạm thời, chuẩn hóa kết quả về đúng kích thước gốc, thay thế tệp gốc, và quên bí mật ngẫu nhiên đó. Đối với container phân mảnh, mỗi .lbx, .lbx1, .lbx2 phần trong cùng thư mục sẽ được thay thế trong khi vẫn giữ nguyên kích thước phần gốc.

Tạo với mật khẩu phá hủy

$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ích hoạt phá hủy mà không có khoá lớp

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

Kích hoạt trên Linux

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

Sau khi phá hủy thành công, container không còn là tệp LockBox hợp lệ. CLI trả về mã thoát 0 vì hành động phá hủy được yêu cầu đã hoàn tất thành công.

Mở container

open giải nén một container vào thư mục đầu ra. Đối với giải nén bình thường, các khoá lớp phải được truyền theo cùng thứ tự đã sử dụng trong quá trình tạo. Đối với quy trình mật khẩu phá hủy, chỉ cần đường dẫn container, đường dẫn đầu ra, và mật khẩu phá hủy như mật khẩu chính.

Mở container một lớp

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

Mở container phân mảnh

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

Mở container đa lớp

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

Bí danh

open
decrypt
extract

Kiểm chứng bằng cách khôi phục

Tạo tệp report.csv nhỏ để thử. Giải nén vào thư mục mới, bên trong vẫn giữ tên thư mục nguồn. Giữ mọi phần cùng nhau và so sánh với nguồn chưa thay đổi. Giải nén cần chỗ tạm có quyền ghi cạnh vùng chứa. Bảo vệ cả các tệp đã khôi phục không còn mã hóa.

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

Bộ lập lịch

Các lệnh của bộ lập lịch có sẵn trong phiên bản Max. Chúng lưu trữ tất cả siêu dữ liệu nhiệm vụ trong một tệp .lbxjobs được mã hóa, bao gồm đường dẫn nguồn, đường dẫn đầu ra, mật khẩu, mật khẩu hủy, khóa lớp, nén, đệm, chia tách và thiết lập xóa nội dung nguồn.

Các công việc được lập lịch chỉ chạy khi LockBox.Cli.exe schedule run đang chạy. Sử dụng Trình lập lịch tác vụ Windows, systemd trên Linux, cron, một trình bao dịch vụ, hoặc phiên console chạy lâu nếu bạn cần tác vụ tự động khởi động sau khi khởi động lại.

Giá trị tần suất

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

Thêm một tác vụ sao lưu được mã hóa hàng ngày

$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

Thêm một tác vụ xóa nội dung thư mục nguồn sau khi thành công

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

Thêm một lưu trữ hàng tháng với đệm và các phần chia

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

Liệt kê các tác vụ đã lưu

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

Chạy tác vụ của bộ lập lịch

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

Chạy các tác vụ đến hạn một lần và thoát

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

Hiển thị trạng thái chạy mới nhất

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

Các dấu hiệu trạng thái là [OK], [RUNNING] và [FAILED]. Một tác vụ thất bại bao gồm lý do và hướng dẫn người dùng liên hệ hỗ trợ nếu sự cố tái diễn.

Script JSON

Sử dụng --script khi một quy trình có nhiều bước. Trình chạy script hỗ trợ create, open, keygen, algorithms, device-id, license và activate.

Tạo và mở trong một 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"

Tiếp tục sau một bước thất bại

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

Kích hoạt từ script

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

Trường JSON và quy tắc thực thi

Bảng nối các trường create và mảng khóa open với tùy chọn CLI. Đường dẫn tương đối bắt đầu từ thư mục làm việc của tiến trình, không phải tệp JSON; biến và ngày tháng không được thay thế. Dùng một nguồn bí mật cho mỗi trường. open đọc keys, rồi keyEnvs và keyFiles. Ưu tiên stopOnError: true; với false, thành công sau có thể che lỗi trước. Tập lệnh JSON không hỗ trợ lệnh lập lịch.

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

Công thức tự động hóa

Sao lưu cơ sở dữ liệu mã hóa

$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

Bảo vệ artifact 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

Chuyển đối tác an toàn

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

Lưu trữ dài hạn

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

Ví dụ tệp 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: sao lưu nhiều thư mục

Lưu tập lệnh tại đường dẫn đã chỉ. Nó tạo vùng chứa có tên duy nhất và nhật ký cho mỗi nguồn, dừng khi lỗi và giữ mã thoát CLI. AES-128-GCM chạy được trên Free; nén và chia phần cần Pro hoặc 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: sao lưu không giám sát

Lưu tập lệnh Bash với kết thúc dòng LF. Chuẩn bị CLI và tệp bí mật tại các đường dẫn đã chỉ, rồi truyền thư mục nguồn làm đối số. Mỗi lần chạy có thư mục riêng. Lỗi để lại nhật ký và trả mã khác không; nguồn được giữ nguyên.

/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

Lập lịch bằng hệ điều hành

Các tác vụ chạy tập lệnh ở trên; cách dùng create này không cần Max. Đăng ký Windows chỉ chạy khi người dùng đăng nhập; nếu cần, cấu hình chạy khi đăng xuất trong Task Scheduler. Kiểm tra flock rồi thêm cron vào crontab của tài khoản sao lưu. Hai ví dụ chạy lúc 02:00 giờ địa phương và ngăn các lần chạy định kỳ chồng nhau. Kiểm tra quyền và thử thủ công trước.

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: vận hành bộ lập lịch

Tạo tài khoản dịch vụ lockbox với quyền cần thiết, kích hoạt Max cho tài khoản đó và chuẩn bị tệp mật khẩu UTF-8 riêng jobs.txt. add thêm chứ không cập nhật: chỉ dùng một lần cho mỗi tác vụ. Chạy một tiến trình cho mỗi tệp tác vụ và khởi động lại sau thay đổi. JSON trạng thái không khôi phục lịch sử: lần lặp quá hạn bị bỏ qua, tác vụ once quá hạn có thể chạy lại. Khi hệ điều hành khởi chạy định kỳ, dùng create thay vì lặp run-once. Bộ lập lịch dùng lại tên đầu ra.

/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

Tham chiếu lệnh

Tạo tùy chọn

Tùy chọn mở

Tùy chọn lập lịch

Dùng --language hoặc --lang để chọn ngôn ngữ bảng điều khiển và --quiet để ẩn tiến độ thông thường; lỗi vẫn được gửi đến luồng lỗi chuẩn. Ctrl+C yêu cầu hủy và trả về mã 1. Mã 2 nghĩa là cú pháp lệnh không hợp lệ; mã 3 nghĩa là một tính năng tạo không có trong phiên bản hiện tại. Mã 0 cũng bao gồm việc cố ý kích hoạt mật khẩu hủy, nên bản thân mã này không chứng minh tệp đã được giải nén. Kiểm tra đầu ra mong đợi trước các bước tự động hóa tiếp theo.

Mã thoát và giám sát

schedule run-once có thể trả không dù tác vụ lỗi; schedule status cũng trả không khi thiếu trạng thái. Kiểm tra savedAt, lastSuccessAt và lastError; [OK] có thể chỉ là Ready. Bộ giám sát giả định sao lưu hằng ngày, kiểm tra mỗi 30 giây và có thành công trong 26 giờ. Điều chỉnh ngưỡng. Trạng thái JSON là số; --quiet ẩn đầu ra thông thường khi create/open thành công.

$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

Khắc phục sự cố