Documentación CLI de LockBox
CLI para Windows y Linux: crear, verificar y extraer contenedores, automatizar copias y ejecutar scripts JSON. La verificación funciona en todas las ediciones.
Inicio rápido
Coloque LockBox.Cli.exe en una carpeta incluida en PATH,
o llámelo por ruta completa. El marcador --cli se acepta por compatibilidad
pero no es obligatorio en la versión solo CLI.
.\LockBox.Cli.exe --help
.\LockBox.Cli.exe device-id
.\LockBox.Cli.exe algorithms
.\LockBox.Cli.exe keygen --count 3
Flujo de trabajo mínimo para crear y abrir:
$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 usa los mismos comandos con rutas con barra y un binario sin el sufijo .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_L1Instalar y comprobar la CLI
Extraiga el ZIP correspondiente al sistema y procesador. .NET está incluido. Compare el hash con SHA256SUMS.txt. Coloque la CLI en la ruta absoluta indicada a continuación y compruebe la ayuda y licencia con la cuenta de copias de seguridad.
Linux también necesita dependencias nativas de la distribución, como ICU y OpenSSL; el .NET incluido no las aporta. En Windows, la directiva de ejecución vigente debe permitir los scripts 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 SHA256uname -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.zipWindows 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.zipCarpetas, rutas y espacio
Adapte las rutas. La carpeta de origen no debe estar vacía y el contenedor debe quedar fuera de ella. Reutilizar el nombre de destino reemplaza el contenedor y sus partes. Reserve espacio temporal junto al contenedor y una copia del origen para tareas programadas. Las unidades se basan en 1024; el relleno añade bytes.
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.txtPreparar archivos de secretos
Genere los secretos una sola vez, guarde una copia protegida y limite el acceso a los archivos. Los ejemplos impiden reemplazar claves existentes. Los archivos UTF-8 conservan espacios y eliminan saltos de línea finales. Guarde las claves originales para abrir copias antiguas.
$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.txtEstado de activación y licencia
La clave de licencia está vinculada al ID del dispositivo impreso por la misma compilación CLI. Si se copia una licencia a otra PC, LockBox la rechaza y vuelve a Free.
Windows comprueba las ubicaciones de datos de la aplicación LockBox existentes. Linux almacena la activación en
$XDG_CONFIG_HOME/lockbox/.lockbox.license, luego
~/.config/lockbox/.lockbox.license, con ~/.lockbox/.lockbox.license
como respaldo.
Obtener ID del dispositivo
.\LockBox.Cli.exe device-id
Comprobar la edición actual
.\LockBox.Cli.exe license
Activar desde un archivo de licencia
.\LockBox.Cli.exe activate --license-file "C:\Licenses\lockbox-license.txt"
Activar desde una variable de entorno
$env:LBX_LICENSE = "LBX-LIC-..."
.\LockBox.Cli.exe activate --license-env LBX_LICENSE
Activación en línea
La activación en línea funciona, pero puede filtrarse a través del historial de la shell o los registros de procesos.
.\LockBox.Cli.exe activate --license "LBX-LIC-..."
Activación en Linux
export LBX_LICENSE="LBX-LIC-..."
./LockBox.Cli activate --license-env LBX_LICENSE
./LockBox.Cli licenseManejo de secretos
Prefiera variables de entorno o archivos. Los secretos en línea son útiles solo para pruebas. Las contraseñas maestras y las claves de capa deben conservarse: sin ellas, el contenedor no puede abrirse.
| Propósito | En línea | Entorno | Archivo |
|---|---|---|---|
| Contraseña maestra | --master value | --master-env ENV | --master-file path |
| Crear clave de capa | --layer ALG=KEY | --layer-env ALG=ENV | --layer-file ALG=FILE |
| Abrir clave de capa | --key value | --key-env ENV | --key-file path |
| Contraseña del archivo del programador | --password value | --password-env ENV | --password-file path |
| Contraseña de destrucción del contenedor | --destruction-password value | --destruction-password-env ENV | --destruction-password-file path |
| Clave de licencia | --license value | --license-env ENV | --license-file path |
Secretos basados en archivos
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.txtAlgoritmos y generación de claves
Use algorithms para ver todos los perfiles compatibles y las ediciones mínimas. Use keygen para claves de capa.
.\LockBox.Cli.exe algorithms
.\LockBox.Cli.exe keygen
.\LockBox.Cli.exe keygen --count 9
.\LockBox.Cli.exe generate-keys -n 20Alias de comandos compatibles:
algorithms
list-algorithms
profiles
keygen
generate-key
generate-keysPara contenedores creados con contraseñas de capa:
Crear contenedores
La creación empaqueta la carpeta, la comprime opcionalmente, la cifra por capas y escribe el contenedor. El relleno aleatorio opcional se añade fuera de los datos cifrados.
Opciones requeridas
--sourceo-s: carpeta de origen.--outputo-o: ruta de salida del.lbx.--master,--master-env, o--master-file.- Al menos una capa:
--layer,--layer-env, o--layer-file.
Contenedor AES mínimo
.\LockBox.Cli.exe create `
-s "D:\Data" `
-o "E:\Backups\data.lbx" `
--master-env LBX_MASTER `
--layer-env AES-128-GCM=LBX_L1
Contenedor comprimido
.\LockBox.Cli.exe create `
--source "D:\Exports" `
--output "E:\Backups\exports.lbx" `
--master-env LBX_MASTER `
--layer-env AES-256-GCM=LBX_L1 `
--compress
Relleno criptográfico
.\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
Dividir contenedor en partes
.\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
La primera parte mantiene .lbx. Las partes adicionales usan
.lbx1, .lbx2, y así sucesivamente. Mantenga todas las partes en la misma carpeta.
Ejemplo de Max de nueve capas
$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
Sintaxis alternativa de algoritmo/clave
.\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
Eliminar fuente tras creación manual exitosa
.\LockBox.Cli.exe create `
-s "D:\TempToEncrypt" `
-o "E:\Backups\temp.lbx" `
--master-env LBX_MASTER `
--layer-env AES-256-GCM=LBX_L1 `
--verify-after-create --delete-source
--delete-source elimina la carpeta de origen solo después de que el contenedor se haya creado con éxito.
El programador tiene una opción diferente: --delete-source-contents.
Contraseña de destrucción del contenedor
La edición Max puede añadir una contraseña de destrucción separada a un contenedor. Si esta contraseña se introduce más tarde como la contraseña maestra, LockBox sobrescribe inmediatamente el contenedor sin confirmación. Esto está diseñado para escenarios de presión o coacción. Mantenla separada de la verdadera contraseña maestra.
El comando verifica el espacio libre en disco, encripta los datos originales del contenedor con un nuevo
secreto aleatorio y AES-256-GCM en un archivo temporal, normaliza el resultado al tamaño exacto
del original, reemplaza el archivo original y olvida el secreto aleatorio. Para contenedores divididos, cada
.lbx, .lbx1, .lbx2 parte en la misma carpeta se reemplaza
manteniendo los tamaños originales de las partes.
Crear con una contraseña de destrucción
$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
Activar destrucción sin claves de capa
.\LockBox.Cli.exe open `
--container "E:\Backups\data.lbx" `
--output "D:\Restore" `
--master-env LBX_DESTROY
Disparador en Linux
export LBX_DESTROY="pressure-password"
./LockBox.Cli open \
--container "/backup/data.lbx" \
--output "/restore" \
--master-env LBX_DESTROY
Tras una destrucción exitosa, el contenedor ya no es un archivo válido de LockBox. La CLI devuelve
el código de salida 0 porque la acción de destrucción solicitada se completó correctamente.
Para contenedores creados con contraseñas de capa:
Abrir contenedores
open extrae un contenedor a la carpeta de salida. Para una extracción normal, las claves de capa deben
proporcionarse en el mismo orden usado durante la creación. Para un flujo de trabajo con contraseña de destrucción, solo se requieren
la ruta del contenedor, la ruta de salida y la contraseña de destrucción como contraseña maestra.
Abrir un contenedor de una sola capa
.\LockBox.Cli.exe open `
--container "E:\Backups\data.lbx" `
--output "D:\Restore" `
--master-env LBX_MASTER `
--key-env LBX_L1
Abrir un contenedor dividido
.\LockBox.Cli.exe open `
-c "E:\Backups\data.lbx" `
-o "D:\Restore" `
--master-env LBX_MASTER `
--key-env LBX_L1
Abrir un contenedor de varias capas
.\LockBox.Cli.exe open `
-c "E:\Backups\data-max.lbx" `
-o "D:\Restore" `
--master-env LBX_MASTER `
--key-env LBX_L1 `
--key-env LBX_L2 `
--key-env LBX_L3 `
--key-env LBX_L4 `
--key-env LBX_L5 `
--key-env LBX_L6 `
--key-env LBX_L7 `
--key-env LBX_L8 `
--key-env LBX_L9
Alias
open
decrypt
extract
Verificar contenedor
Compruebe los metadatos, las partes, cada capa de cifrado y las sumas de comprobación de los archivos. Disponible en Free, Pro y Max para Windows, Android y CLI.
Para contenedores creados con contraseñas de capa: El terminal interactivo pide contraseñas y claves sin mostrar lo escrito. La automatización debe proporcionarlas explícitamente en el orden de las capas. No hace falta carpeta de salida. Códigos: 0 válido, 1 error o cancelación, 2 argumentos incorrectos. Redirigir la salida puede guardar un informe.
.\LockBox.Cli.exe verify "E:\Backups\data.lbx"
.\LockBox.Cli.exe verify --container "E:\Backups\data.lbx" --master-env LBX_MASTER --key-env LBX_L1
./LockBox.Cli verify /backup/data.lbx --master-env LBX_MASTER --key-env LBX_L1
Verificar el contenedor tras crearlo
Active la verificación tras crear para comprobar las copias automáticamente. El origen solo se elimina tras una comprobación correcta; un error o cancelación lo conserva. El programador integrado sigue requiriendo Max.
./LockBox.Cli create --source /srv/data --output /backup/data.lbx --master-env LBX_MASTER --layer-env AES-128-GCM=LBX_L1 --verify-after-create
./LockBox.Cli schedule add --tasks /backup/daily.lbxjobs --password-env LBX_JOBS --name daily --frequency daily --start "$(date -d 'tomorrow 02:00' +%Y-%m-%dT%H:%M:%S)" --source /srv/data --output /backup/daily.lbx --master-env LBX_MASTER --layer-env AES-128-GCM=LBX_L1 --verify-after-create
{
"stopOnError": true,
"commands": [
{
"command": "create",
"source": "/srv/data",
"output": "/backup/data.lbx",
"masterPasswordEnv": "LBX_MASTER",
"layers": [{ "algorithm": "AES-128-GCM", "keyEnv": "LBX_L1" }],
"verifyAfterCreate": true
},
{
"command": "verify",
"container": "/backup/data.lbx",
"masterPasswordEnv": "LBX_MASTER",
"keyEnvs": ["LBX_L1"]
}
]
}
La verificación se realiza en memoria. No se guardan datos descifrados ni informes en el disco. Android puede almacenar partes cifradas en caché. No se guardan sesiones de verificación ni informes. La paginación y los volcados del sistema quedan fuera de esta garantía.
Un resultado válido confirma la integridad del archivo, no su coincidencia con la carpeta original. El formato no autentica el relleno aleatorio ni el verificador de la contraseña de destrucción. La verificación nunca activa la destrucción.
Comprobar una copia restaurándola
Cree un pequeño report.csv de prueba. Extraiga a una carpeta nueva, que contendrá el nombre de la carpeta original. Mantenga juntas todas las partes y compare con el origen sin modificar. La extracción necesita espacio temporal escribible junto al contenedor. Proteja también los archivos restaurados sin cifrar.
$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 $restoreset -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"Programador
Los comandos del programador están disponibles en la edición Max. Almacenan los metadatos completos de la tarea
en un archivo .lbxjobs encriptado, incluyendo la ruta de origen, ruta de salida,
contraseñas, contraseña de destrucción, claves de capas, compresión, relleno, división y
la configuración de eliminar el contenido de la fuente.
Los trabajos programados se ejecutan solo mientras LockBox.Cli.exe schedule run esté en funcionamiento.
Use el Programador de Tareas de Windows, systemd de Linux, cron, un envoltorio de servicio o una sesión de consola de larga duración
si necesita que el trabajador se inicie automáticamente después del reinicio.
Valores de frecuencia
once
30m
hourly
2h
3h
6h
9h
12h
18h
daily
2d
3d
5d
weekly
2w
monthly
2mo
3mo
6mo
9mo
yearly
Agregar una tarea diaria de respaldo encriptado
$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
Agregar una tarea que elimine el contenido de la carpeta de origen después del éxito
.\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 `
--verify-after-create --delete-source-contents
Agregar un archivo mensual con relleno y partes divididas
.\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
Listar tareas guardadas
.\LockBox.Cli.exe schedule list `
--tasks "E:\Backups\jobs.lbxjobs" `
--password-env LBX_JOBS_PASSWORD
Ejecutar el trabajador del programador
.\LockBox.Cli.exe schedule run `
--tasks "E:\Backups\jobs.lbxjobs" `
--password-env LBX_JOBS_PASSWORD `
--state "E:\Backups\jobs.status.json" `
--poll-seconds 30
Ejecutar las tareas pendientes una vez y salir
.\LockBox.Cli.exe schedule run-once `
--tasks "E:\Backups\jobs.lbxjobs" `
--password-env LBX_JOBS_PASSWORD `
--state "E:\Backups\jobs.status.json"
Mostrar el estado de ejecución más reciente
.\LockBox.Cli.exe schedule status --state "E:\Backups\jobs.status.json"
Los marcadores de estado son [OK], [RUNNING] y [FAILED].
Una tarea fallida incluye la razón e indica al usuario que contacte al soporte si el problema se repite.
Cifrar con claves aleatorias
Windows, Android y CLI: Free, Pro y Max, con los límites de cada edición. No está disponible en el programador ni en la creación rápida del Explorador.
Sin inventar ni recordar contraseñas para cada capa. Guarde el archivo de claves y su contraseña; los metadatos siguen requiriendo una contraseña maestra.
- Active las claves aleatorias en la primera pantalla del asistente y elija los algoritmos. Tras crear el contenedor, guarde el archivo de claves y copie su contraseña antes de cerrar la aplicación. La contraseña maestra sigue siendo obligatoria.
- Guarde el archivo directamente en una memoria USB u otro medio extraíble para no dejar copias en este equipo. Guarde la contraseña por separado. LockBox nunca escribe claves descomprimidas en disco.
- Cargue el archivo de claves e introduzca su contraseña para todas las capas, o seleccione un archivo de clave en cada paso de descifrado.
El ZIP AES-256 contiene un keys.zip cifrado: los nombres y la cantidad de claves están ocultos. Otros descompresores necesitan dos pasos. key_1.lbxkey corresponde al primer paso de descifrado, la capa exterior. No cambie los nombres de archivo para importar el ZIP.
Las claves aleatorias son seguras, pero perder el archivo o su contraseña implica perder acceso a los datos. Manténgalos seguros y accesibles. Las contraseñas memorizadas tienen ventaja sobre los secretos escritos. Las claves aleatorias son incompatibles con la destrucción del contenedor. Esta función se desactiva en modo de claves.
La eliminación del origen debe esperar a que se guarde y verifique el archivo de claves.
CLI guarda en --keys-archive y muestra su contraseña incluso con --quiet. Repita --key-file en orden de descifrado: key_1, key_2… Use --keys-archive-password-env para evitar guardar la contraseña en el historial de comandos.
./LockBox.Cli create --source /data/source --output /backup/data.lbx --master-env LBX_MASTER --random-keys --algorithm AES-128-GCM --keys-archive /media/usb/data-keys.zip --verify-after-create
./LockBox.Cli open --container /backup/data.lbx --output /data/restored --master-env LBX_MASTER --keys-archive /media/usb/data-keys.zip --keys-archive-password-env LBX_ARCHIVE_PASSWORD
./LockBox.Cli verify --container /backup/data.lbx --master-env LBX_MASTER --key-file /media/usb/key_1.lbxkey
.\LockBox.Cli.exe create --source "C:\Data" --output "D:\Backups\data.lbx" --master-env LBX_MASTER --random-keys --algorithm AES-128-GCM --keys-archive "E:\data-keys.zip"
.\LockBox.Cli.exe open --container "D:\Backups\data.lbx" --output "D:\Restored" --master-env LBX_MASTER --keys-archive "E:\data-keys.zip" --keys-archive-password-env LBX_ARCHIVE_PASSWORD
{
"commands": [{
"command": "create", "source": "/data/source", "output": "/backup/data.lbx",
"masterPasswordEnv": "LBX_MASTER", "randomKeys": true,
"algorithms": ["AES-128-GCM"], "keysArchive": "/media/usb/data-keys.zip",
"verifyAfterCreate": true
}]
}
Scripts JSON
Use --script cuando un flujo de trabajo tenga varios pasos. El ejecutor de scripts soporta
create, open, verify, keygen, algorithms,
device-id, license y activate.
Crear y abrir en un solo 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"
Continuar después de un paso fallido
{
"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" }
]
}
]
}
Activar desde un script
{
"commands": [
{
"command": "activate",
"licenseKeyFile": "C:\\Licenses\\lockbox-license.txt"
},
{ "command": "license" }
]
}Campos JSON y reglas de ejecución
Las rutas son relativas al directorio de trabajo del proceso. No se expanden variables en cadenas. Orden de claves: keys, keyEnvs, keyFiles. stopOnError es true por defecto; false continúa pero devuelve el primer código de error. Cancelar detiene la ejecución. JSON no admite comandos del programador.
{
"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.jsonsource / sourceFolder / sourceFolderPath | --source | Carpeta para empaquetar y cifrar. |
output / outputContainerPath | --output | Ruta de salida de .lbx. |
masterPassword | --master | Contraseña maestra en línea. |
masterPasswordEnv | --master-env | Leer la contraseña maestra desde la variable de entorno. |
masterPasswordFile | --master-file | Leer la contraseña maestra desde un archivo de texto UTF-8. |
layers[].algorithm + layers[].key | --layer | Agregar ALGORITHM=KEY. |
layers[].algorithm + layers[].keyEnv | --layer-env | Agregar ALGORITHM=ENV. |
layers[].algorithm + layers[].keyFile | --layer-file | Agregar ALGORITHM=FILE. |
compression / compress | --compress | Habilitar compresión. |
verifyAfterCreate | --verify-after-create | Verificar el contenedor tras crearlo |
padding | --padding | El relleno aleatorio aumenta el contenedor para ocultar el tamaño de los datos. Estos bytes adicionales no se cifran ni se autentican. B / KB / MB / GB / TB |
paddingBytes | --padding-bytes | Tamaño del relleno en bytes sin procesar. |
split / splitSize | --split | Dividir la salida en .lbx, .lbx1, .lbx2. |
splitPartSizeBytes | --split-bytes | Tamaño de la parte dividida en bytes sin procesar. |
destructionPassword | --destruction-password | Contraseña de destrucción solo Max en línea. Ingresarla más tarde como contraseña maestra sobrescribe inmediatamente el contenedor. |
destructionPasswordEnv | --destruction-password-env | Leer la contraseña de destrucción solo Max desde una variable de entorno. |
destructionPasswordFile | --destruction-password-file | Leer la contraseña de destrucción solo Max desde un archivo de texto UTF-8. |
deleteSource / deleteSourceFolderAfterSuccess | --delete-source | Eliminar la carpeta de origen después de la creación manual exitosa. |
container / containerPath | --container | Contenedor .lbx existente. |
keys[] | --key | Clave de capa en línea en el orden original. |
keyEnvs[] | --key-env | Clave de capa desde variable de entorno. |
keyFiles[] | --key-file | Clave de capa desde archivo de texto UTF-8. |
Recetas de automatización
Copia de seguridad de volcado de base de datos cifrada
$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
Protección de artefactos 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
Transferencia segura a socios
.\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
Archivo a largo plazo
.\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
Ejemplo de archivo por lotes
@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 OKWindows: copiar varias carpetas
Guarde el script en la ruta indicada. Crea un contenedor con nombre único y un registro por origen, se detiene ante errores y conserva el código de salida CLI. AES-128-GCM funciona en Free; la compresión y división requieren Pro o 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', '--verify-after-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
$LASTEXITCODELinux: copias sin intervención
Guarde el script Bash con finales de línea LF. Prepare la CLI y los secretos en las rutas indicadas y pase las carpetas de origen como argumentos. Cada ejecución tiene su propio directorio. Los errores dejan un registro y devuelven un código distinto de cero; los originales se conservan.
/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 --verify-after-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/reportsProgramar con el sistema operativo
Estas tareas ejecutan los scripts anteriores; este uso de create no requiere Max. El registro de Windows necesita una sesión iniciada; configure la ejecución sin sesión en el Programador si la necesita. Añada cron al crontab del usuario de copias tras comprobar flock. Ambos ejemplos se ejecutan a las 02:00 locales y evitan ejecuciones programadas simultáneas. Revise permisos y pruebe manualmente.
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 -e0 2 * * * /usr/bin/flock -n /srv/lockbox/backup.lock /bin/bash /srv/lockbox/backup.sh >> /srv/lockbox/cron.log 2>&1Max: administrar el planificador
Cree la cuenta de servicio lockbox con los permisos necesarios, active Max para ella y prepare un archivo UTF-8 independiente jobs.txt con la contraseña. add añade, no actualiza: úselo una vez por tarea. Mantenga un proceso por archivo de tareas y reinícielo tras modificarlo. El JSON de estado no restaura el historial: omite las repeticiones vencidas, pero una tarea once vencida puede ejecutarse otra vez. Para lanzamientos periódicos del sistema use create en lugar de repetir run-once. El planificador reutiliza el nombre de salida.
/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.targetsudo 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.jsonReferencia de comandos
| Comando | Propósito | Alias |
|---|---|---|
help | Mostrar ayuda de la consola. | --help, -h, ? |
device-id | Imprimir ID del dispositivo PC para emisión de licencia. | deviceid, machine-id |
license | Mostrar edición actual y ruta de la licencia. | license-status, status |
activate | Instalar una clave de licencia vinculada al dispositivo. | activation |
algorithms | Listar algoritmos y ediciones mínimas. | profiles, list-algorithms |
keygen | Generar claves aleatorias. | generate-key, generate-keys |
create | Crear contenedor cifrado. | encrypt |
open | Extraer contenedor cifrado. | decrypt, extract |
verify | Verificar contenedor | — |
schedule | Administrar y ejecutar tareas programadas. | scheduler, scheduled-tasks |
script | Ejecutar archivo de automatización JSON. | --script |
Crear opciones
--source, -s | Carpeta para empaquetar y cifrar. |
--output, -o | Ruta de salida de .lbx. |
--master | Contraseña maestra en línea. |
--master-env | Leer la contraseña maestra desde la variable de entorno. |
--master-file | Leer la contraseña maestra desde un archivo de texto UTF-8. |
--layer | Agregar ALGORITHM=KEY. |
--layer-env | Agregar ALGORITHM=ENV. |
--layer-file | Agregar ALGORITHM=FILE. |
--algorithm, -a | Forma de algoritmo alternativa emparejada con --key, --key-env, o --key-file. |
--compress | Habilitar compresión. |
--no-compress | Deshabilitar compresión si se configuró anteriormente. |
--padding | El relleno aleatorio aumenta el contenedor para ocultar el tamaño de los datos. Estos bytes adicionales no se cifran ni se autentican. B / KB / MB / GB / TB |
--padding-bytes | Tamaño del relleno en bytes sin procesar. |
--split | Dividir la salida en .lbx, .lbx1, .lbx2. |
--split-bytes | Tamaño de la parte dividida en bytes sin procesar. |
--no-split | Deshabilitar división si se configuró anteriormente. |
--destruction-password | Contraseña de destrucción solo Max en línea. Ingresarla más tarde como contraseña maestra sobrescribe inmediatamente el contenedor. |
--destruction-password-env | Leer la contraseña de destrucción solo Max desde una variable de entorno. |
--destruction-password-file | Leer la contraseña de destrucción solo Max desde un archivo de texto UTF-8. |
--delete-source | Eliminar la carpeta de origen después de la creación manual exitosa. |
--verify-after-create | Active la verificación tras crear para comprobar las copias automáticamente. El origen solo se elimina tras una comprobación correcta; un error o cancelación lo conserva. El programador integrado sigue requiriendo Max. |
Opciones de apertura
--container, -c | Contenedor .lbx existente. |
--output, -o | Carpeta de extracción. |
--master, --master-env, --master-file | Fuente de la contraseña maestra. |
--key, -k | Clave de capa en línea en el orden original. |
--key-env | Clave de capa desde variable de entorno. |
--key-file | Clave de capa desde archivo de texto UTF-8. |
— | Permitido para flujos de trabajo con contraseña de destrucción. La extracción normal falla después de leer los metadatos si faltan claves necesarias. |
Opciones del planificador
schedule add | Agregar una tarea a .lbxjobs cifrada. |
schedule list | Mostrar tareas guardadas. |
schedule run | Ejecutar trabajador de larga duración. |
schedule run-once | Ejecutar tareas pendientes una vez y salir. |
schedule status | Leer JSON con el estado de ejecución más reciente. |
--tasks, --file | Ruta del archivo de tareas cifrado. |
--password, --password-env, --password-file | Contraseña para el archivo de tareas. |
--state, --status-file | Ruta del JSON de estado de ejecución. |
--name | Nombre de la tarea para schedule add. |
--frequency, --every | Frecuencia de la tarea. |
--start, --start-at | Fecha/hora de inicio local. |
--delete-source-contents | Eliminar el contenido de la carpeta de origen original después de una ejecución programada exitosa. |
--poll-seconds | Intervalo de sondeo del trabajador para schedule run. |
Use --language o --lang para elegir el idioma de la consola y --quiet para ocultar el progreso habitual; los errores siguen apareciendo en la salida de error estándar. Ctrl+C solicita la cancelación y devuelve el código 1. El código 2 indica sintaxis incorrecta y el código 3 una función de creación no disponible en la edición actual. El código 0 también se devuelve al activar intencionadamente la contraseña de destrucción, por lo que no demuestra por sí solo que se extrajeran archivos. Verifique el resultado esperado antes de continuar la automatización.
Códigos de salida y supervisión
schedule run-once devuelve 1 si falla una tarea cuyo plazo ha llegado. schedule status puede devolver 0 sin estado guardado. Compruebe también lastSuccessAt y lastError. El ejemplo supone copias diarias y sondeos cada 30 segundos; ajuste su ventana de 26 horas.
$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 -> FailedSolución de problemas
¿Por qué obtengo el código de salida 3?
La edición actual no permite la función solicitada: demasiadas capas, compresión, padding criptográfico, división, planificador o un algoritmo más fuerte.
¿Por qué falla la extracción con un error de etiqueta de autenticación?
La contraseña maestra, la clave de capa, el orden de las capas o el archivo contenedor son incorrectos. Para contenedores divididos, también verifique que cada parte esté presente en la misma carpeta.
¿Por qué el planificador no se ejecuta después de cerrar la consola?
schedule run es el proceso trabajador. Manténgalo abierto o ejecútelo desde el Programador de tareas de Windows o un envolvente de servicio.
¿Por qué falla inmediatamente la adición de programación?
El planificador valida licencia, carpeta fuente, ruta de salida, algoritmos, contraseñas y espacio en disco disponible antes de guardar la tarea.
¿Puedo almacenar contraseñas del planificador dentro del archivo .lbxjobs?
Sí. El archivo .lbxjobs está encriptado con la contraseña del archivo del planificador y almacena todos los metadatos de la tarea, incluidas las contraseñas de cifrado y las claves de capa.
¿Qué sucede si una ejecución programada se superpone con la ejecución anterior?
El nuevo evento se omite, la tarea reporta un estado fallido con una explicación y las ejecuciones futuras continúan después de que la ejecución activa termine.
¿Cómo evito que los secretos queden en el historial de la shell?
Use --master-env, --master-file, --layer-env, --layer-file, --destruction-password-env, --destruction-password-file, --password-env y --password-file.