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

सक्रियण और लाइसेंस स्थिति

लाइसेंस कुंजी उसी CLI बिल्ड द्वारा मुद्रित डिवाइस आईडी से बंधी होती है। यदि कोई लाइसेंस दूसरे पीसी पर कॉपी किया जाता है, तो लॉकबॉक्स इसे अस्वीकार कर देता है और फ्री पर लौट आता है।

विंडोज़ मौजूदा लॉकबॉक्स एप्लिकेशन डेटा स्थानों की जांच करता है। लिनक्स सक्रियण को $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

इनलाइन सक्रियण

इनलाइन सक्रियण काम करता है, लेकिन यह शेल इतिहास या प्रोसेस लॉग्स के माध्यम से लीक हो सकता है।

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

कंटेनर नष्ट करने का पासवर्ड

मैक्स संस्करण कंटेनर में अलग नष्ट करने का पासवर्ड जोड़ सकता है। यदि यह पासवर्ड बाद में मास्टर पासवर्ड के रूप में डाला जाता है, तो लॉकबॉक्स तुरंत बिना पुष्टि के कंटेनर को ओवरराइट कर देता है। यह जोर-जबर्दस्ती वाले परिदृश्यों के लिए बनाया गया है। इसे वास्तविक मास्टर पासवर्ड से अलग रखें।

यह कमांड खाली डिस्क स्पेस को सत्यापित करता है, मूल कंटेनर डेटा को एक नए रैंडम सीक्रेट और 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

सफल नष्ट करने के बाद कंटेनर अब एक वैध लॉकबॉक्स फ़ाइल नहीं है। 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 फ़ाइल में संग्रहीत करते हैं, जिसमें स्रोत पथ, आउटपुट पथ, पासवर्ड, विनाश पासवर्ड, लेयर की, संपीड़न, पैडिंग, विभाजन, और delete-source-contents सेटिंग शामिल हैं।

शेड्यूल की गई जॉब्स केवल तभी चलती हैं जब LockBox.Cli.exe schedule run चल रहा हो। विंडोज़ टास्क शेड्यूलर, लिनक्स systemd, क्रोन, एक सर्विस रैपर, या एक लंबे समय तक चलने वाली कंसोल सत्र का उपयोग करें यदि आपको वर्कर को रीबूट के बाद स्वचालित रूप से शुरू करना है।

फ्रीक्वेंसी मान

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 विकल्पों से जोड़ती है। सापेक्ष पथ प्रक्रिया की कार्य-निर्देशिका से शुरू होते हैं; चर और तारीखें नहीं बदली जातीं। प्रति फ़ील्ड एक गोपनीय स्रोत रखें। 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

सीआई आर्टिफैक्ट सुरक्षा

.\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 पंजीकरण केवल उपयोगकर्ता के लॉग इन रहने पर चलता है; आवश्यकता हो तो Task Scheduler में लॉग आउट रहते हुए चलना सेट करें। flock की उपलब्धता जाँचकर बैकअप खाते के crontab में cron जोड़ें। दोनों उदाहरण स्थानीय समय 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 कार्य फिर चल सकता है। सिस्टम से नियमित शुरुआत के लिए बार-बार run-once के बजाय create इस्तेमाल करें। शेड्यूलर आउटपुट नाम दोबारा उपयोग करता है।

/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

समस्या निवारण