תיעוד 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

לינוקס משתמשת באותם פקודות עם נתיבי סלש וקובץ בינארי ללא הסיומת .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

הפעלה ומצב רישיון

מפתח הרישיון מקושר ל-ID של המכשיר המודפס על ידי אותו בניית CLI. אם רישיון מועתק למחשב אחר, LockBox דוחה אותו ומוחזר למצב Free.

Windows בודקת את מיקומי נתוני היישום הקיימים של LockBox. לינוקס מאחסנת הפעלה ב- $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-..."

הפעלה בלינוקס

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

טריגר לינוקס

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"

מתזמן

פקודות המתזמן זמינות במהדורת מקס. הן מאחסנות את כל המטה-דאטה של המשימה בקובץ .lbxjobs מוצפן, כולל נתיב מקור, נתיב פלט, סיסמאות, סיסמת השמדה, מפתחות שכבות, דחיסה, ריפוד, חלוקה, והגדרת מחיקת תוכן המקור.

עבודות מתוזמנות רצות רק בזמן ש-LockBox.Cli.exe schedule run פועל. השתמש ב-Windows Task Scheduler, 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: גיבויים ללא השגחה

שמרו את סקריפט Bash עם סיומות שורה LF. הכינו את 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 פועל רק כשהמשתמש מחובר; הגדירו הפעלה ללא התחברות במתזמן המשימות לפי הצורך. הוסיפו cron ל-crontab של חשבון הגיבוי לאחר בדיקת התקנת flock. שתי הדוגמאות רצות בשעה 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 והכינו קובץ סיסמה נפרד jobs.txt בקידוד UTF-8. ‏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

פתרון תקלות