Voltar ao LockBox

Documentação LockBox CLI

CLI para Windows e Linux: criar, verificar e extrair contentores, automatizar cópias e executar scripts JSON. A verificação está disponível em todas as edições.

Início rápido

Coloque LockBox.Cli.exe em uma pasta incluída em PATH, ou chame-o pelo caminho completo. O marcador --cli é aceito por compatibilidade mas não é necessário na versão apenas CLI.

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

Fluxo de trabalho mínimo para criar e 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

O Linux usa os mesmos comandos com caminhos com barra e um binário sem o sufixo .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

Instalar e verificar a CLI

Extraia o ZIP adequado ao sistema e processador. O .NET está incluído. Compare o hash com SHA256SUMS.txt. Coloque a CLI no caminho absoluto indicado abaixo e verifique a ajuda e licença com a conta de cópias de segurança.

Linux também exige dependências nativas da distribuição, incluindo ICU e OpenSSL; o .NET incluído não as fornece. No Windows, a política de execução em vigor deve permitir 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 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

Pastas, caminhos e espaço

Adapte os caminhos. A pasta de origem não pode estar vazia e o contentor deve ficar fora dela. Reutilizar o nome substitui o contentor e as suas partes. Reserve espaço temporário junto do contentor e uma cópia da origem para tarefas agendadas. As unidades baseiam-se em 1024; o preenchimento acrescenta 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.txt

Preparar ficheiros de segredos

Gere os segredos uma única vez, guarde uma cópia protegida e restrinja o acesso aos ficheiros. Os exemplos impedem a substituição de chaves existentes. Os ficheiros UTF-8 preservam espaços e removem quebras de linha finais. Guarde as chaves originais para abrir cópias antigas.

$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

Ativação e status da licença

A chave de licença está vinculada à ID do dispositivo impressa pela mesma versão CLI. Se uma licença for copiada para outro PC, o LockBox a rejeita e reverte para Free.

O Windows verifica os locais existentes de dados da aplicação LockBox. O Linux armazena a ativação em $XDG_CONFIG_HOME/lockbox/.lockbox.license, depois ~/.config/lockbox/.lockbox.license, usando ~/.lockbox/.lockbox.license como reserva.

Obter ID do dispositivo

.\LockBox.Cli.exe device-id

Verificar edição atual

.\LockBox.Cli.exe license

Ativar a partir de um arquivo de licença

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

Ativar a partir de uma variável de ambiente

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

Ativação inline

A ativação inline funciona, mas pode vazar através do histórico do shell ou logs de processo.

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

Ativação no Linux

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

Manipulação de segredos

Prefira variáveis de ambiente ou arquivos. Segredos embutidos são úteis apenas para testes. Senhas mestres e chaves de camada devem ser preservadas: sem elas, o contêiner não pode ser aberto.

PropósitoEm linhaAmbienteArquivo
Senha mestre--master value--master-env ENV--master-file path
Criar chave de camada--layer ALG=KEY--layer-env ALG=ENV--layer-file ALG=FILE
Abrir chave de camada--key value--key-env ENV--key-file path
Senha do arquivo do agendador--password value--password-env ENV--password-file path
Senha de destruição do contêiner--destruction-password value--destruction-password-env ENV--destruction-password-file path
Chave de licença--license value--license-env ENV--license-file path

Segredos baseados em arquivo

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

Algoritmos e geração de chaves

Use algorithms para ver todos os perfis suportados e edições mínimas. Use keygen para chaves de camada.

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

Aliases de comandos suportados:

algorithms
list-algorithms
profiles

keygen
generate-key
generate-keys

Para contentores criados com palavras-passe das camadas:

Criar contêineres

A criação empacota a pasta, comprime-a opcionalmente, encripta-a por camadas e grava o contentor. O preenchimento aleatório opcional é acrescentado fora dos dados encriptados.

Opções obrigatórias

  • --source ou -s: pasta de origem.
  • --output ou -o: caminho de saída .lbx.
  • --master, --master-env ou --master-file.
  • Pelo menos uma camada: --layer, --layer-env ou --layer-file.

Contêiner 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

Contêiner 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

Preenchimento 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 contêiner em 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

A primeira parte mantém .lbx. Partes adicionais usam .lbx1, .lbx2 e assim por diante. Mantenha todas as partes na mesma pasta.

Exemplo Max com nove camadas

$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

Sintaxe alternativa de algoritmo/chave

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

Excluir origem após criação manual bem-sucedida

.\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 exclui a pasta de origem apenas após o contêiner ser criado com sucesso. O agendador tem uma opção diferente: --delete-source-contents.

Encriptar com chaves aleatórias

Senha de destruição do contêiner

O Max edition pode adicionar uma senha de destruição separada a um contêiner. Se essa senha for inserida posteriormente como a senha mestre, o LockBox sobrescreve imediatamente o contêiner sem confirmação. Isto é destinado a cenários de pressão coercitiva. Mantenha-a separada da senha mestre real.

O comando verifica o espaço livre no disco, criptografa os dados originais do contêiner com um segredo aleatório novo e AES-256-GCM em um arquivo temporário, normaliza o resultado para o tamanho exato original, substitui o arquivo original e esquece o segredo aleatório. Para contêineres divididos, cada parte .lbx, .lbx1, .lbx2 na mesma pasta é substituída, preservando os tamanhos originais das partes.

Criar com uma senha de destruição

$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

Acionar destruição sem chaves de camada

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

Acionamento no Linux

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

Após a destruição bem-sucedida, o contêiner não é mais um arquivo válido do LockBox. O CLI retorna o código de saída 0 porque a ação de destruição solicitada foi concluída com sucesso.

Para contentores criados com palavras-passe das camadas:

Abrir contêineres

open extrai um contêiner para a pasta de saída. Para a extração normal, as chaves de camada devem ser fornecidas na mesma ordem usada durante a criação. Para um fluxo de trabalho com senha de destruição, apenas o caminho do contêiner, o caminho de saída e a senha de destruição como senha mestre são necessários.

Abrir um contêiner de uma camada

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

Abrir um contêiner dividido

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

Abrir um contêiner de múltiplas camadas

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

Apelidos

open
decrypt
extract

Encriptar com chaves aleatórias

Verificar contentor

Verifique metadados, partes do contentor, cada camada de encriptação e somas de verificação dos ficheiros. Disponível em Free, Pro e Max no Windows, Android e CLI.

Para contentores criados com palavras-passe das camadas: O terminal interativo pede palavras-passe e chaves sem mostrar a introdução. Na automatização, forneça-as explicitamente pela ordem das camadas. Não é necessária uma pasta de saída. Códigos: 0 válido, 1 erro ou cancelamento, 2 argumentos incorretos. Redirecionar a saída pode guardar um relatório.

.\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 o contentor após a criação

Ative a verificação após criar para validar automaticamente as cópias. A origem só é eliminada após sucesso; erros ou cancelamento preservam-na. O agendador integrado continua a exigir 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"]
    }
  ]
}

A verificação é feita na memória. Os dados descodificados e o relatório não são guardados no disco. O Android pode guardar partes encriptadas na cache. As sessões de verificação e relatórios não são guardados. A paginação e os dumps do sistema ficam fora desta garantia.

Um resultado válido confirma a integridade do arquivo, não a correspondência com a pasta original. O formato não autentica o preenchimento aleatório nem o verificador da palavra-passe de destruição. A verificação nunca aciona a destruição.

Verificar uma cópia por restauro

Crie um pequeno report.csv para testar. Extraia para uma pasta nova, que preserva dentro dela o nome da pasta de origem. Mantenha todas as partes juntas e compare com a origem inalterada. A extração exige espaço temporário gravável junto do contentor. Proteja também os ficheiros restaurados sem cifragem.

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

Agendador

Os comandos do agendador estão disponíveis na edição Max. Eles armazenam todos os metadados da tarefa em um arquivo .lbxjobs criptografado, incluindo o caminho da origem, caminho de saída, senhas, senha de destruição, chaves de camada, compressão, preenchimento, divisão e a configuração de excluir-conteúdos-da-origem.

Os trabalhos agendados são executados apenas enquanto LockBox.Cli.exe schedule run estiver em execução. Use o Agendador de Tarefas do Windows, systemd do Linux, cron, um wrapper de serviço ou uma sessão de console de longa duração se você precisar que o trabalhador inicie automaticamente após a reinicialização.

Valores de frequência

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

Adicionar uma tarefa diária de backup criptografado

$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

Adicionar uma tarefa que exclui o conteúdo da pasta de origem após o sucesso

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

Adicionar um arquivo mensal com preenchimento e 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 tarefas salvas

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

Executar o trabalhador do agendador

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

Executar tarefas pendentes uma vez e sair

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

Mostrar o status de execução mais recente

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

Os marcadores de status são [OK], [RUNNING] e [FAILED]. Uma tarefa que falhou inclui o motivo e avisa ao usuário para entrar em contato com o suporte se o problema se repetir.

Encriptar com chaves aleatórias

Windows, Android e CLI: Free, Pro e Max, dentro dos limites de cada edição. Indisponível no agendador e na criação rápida do Explorador.

Sem inventar ou memorizar palavras-passe de cada camada. Guarde o arquivo de chaves e a sua palavra-passe; os metadados continuam a exigir uma palavra-passe mestra.

  1. Ative as chaves aleatórias no primeiro ecrã do assistente e escolha os algoritmos. Após a criação, guarde o arquivo de chaves e copie a palavra-passe antes de fechar a aplicação. A palavra-passe principal continua a ser obrigatória.
  2. Guarde o arquivo diretamente numa unidade USB ou noutro suporte amovível para não deixar uma cópia neste computador. Guarde a palavra-passe separadamente. O LockBox nunca grava chaves extraídas no disco.
  3. Carregue o arquivo de chaves e introduza a sua palavra-passe para todas as camadas, ou selecione um ficheiro de chave em cada passo de desencriptação.

O ZIP AES-256 contém um keys.zip encriptado: os nomes e a quantidade de chaves ficam ocultos. Outros programas exigem duas extrações. key_1.lbxkey corresponde ao primeiro passo de desencriptação, a camada exterior. Não altere os nomes dos ficheiros para importar o arquivo.

As chaves aleatórias são fortes, mas perder o arquivo ou a sua palavra-passe significa perder acesso aos dados. Mantenha-os seguros e acessíveis. As palavras-passe memorizadas têm vantagem sobre os segredos escritos. As chaves aleatórias são incompatíveis com a destruição do contentor. Esta função é desativada no modo de chaves.

A eliminação da origem deve aguardar a gravação e verificação do arquivo de chaves.

CLI guarda em --keys-archive e mostra a palavra-passe mesmo com --quiet. Repita --key-file pela ordem de desencriptação: key_1, key_2… Use --keys-archive-password-env para evitar a palavra-passe no histórico 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 quando um fluxo de trabalho tiver várias etapas. O executor de scripts oferece suporte a create, open, verify, keygen, algorithms, device-id, license e activate.

Criar e abrir em um único 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 após uma etapa com falha

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

Ativar a partir do script

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

Campos JSON e regras de execução

Os caminhos são relativos à pasta de trabalho do processo. As variáveis em cadeias não são expandidas. Ordem das chaves: keys, keyEnvs, keyFiles. stopOnError é true por predefinição; false continua mas devolve o primeiro código de erro. Cancelar termina a execução. O JSON não suporta comandos do agendador.

{
  "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
source / sourceFolder / sourceFolderPath--sourcePasta a ser empacotada e criptografada.
output / outputContainerPath--outputCaminho de saída .lbx.
masterPassword--masterSenha mestra inline.
masterPasswordEnv--master-envLer senha mestra de variável de ambiente.
masterPasswordFile--master-fileLer senha mestra de arquivo de texto UTF-8.
layers[].algorithm + layers[].key--layerAdicionar ALGORITHM=KEY.
layers[].algorithm + layers[].keyEnv--layer-envAdicionar ALGORITHM=ENV.
layers[].algorithm + layers[].keyFile--layer-fileAdicionar ALGORITHM=FILE.
compression / compress--compressHabilitar compressão.
verifyAfterCreate--verify-after-createVerificar o contentor após a criação
padding--paddingO preenchimento aleatório aumenta o contentor para ocultar o tamanho dos dados. Estes bytes adicionais não são encriptados nem autenticados. B / KB / MB / GB / TB
paddingBytes--padding-bytesTamanho do preenchimento em bytes brutos.
split / splitSize--splitDividir saída em .lbx, .lbx1, .lbx2.
splitPartSizeBytes--split-bytesTamanho de cada parte em bytes brutos.
destructionPassword--destruction-passwordSenha de destruição inline somente para Max. Inserir esta senha depois como senha mestra sobrescreve o container imediatamente.
destructionPasswordEnv--destruction-password-envLer a senha de destruição somente para Max a partir de uma variável de ambiente.
destructionPasswordFile--destruction-password-fileLer a senha de destruição somente para Max a partir de um arquivo de texto UTF-8.
deleteSource / deleteSourceFolderAfterSuccess--delete-sourceExcluir a pasta de origem após a criação manual bem-sucedida.
container / containerPath--containerContêiner .lbx existente.
keys[]--keyChave de camada inline na ordem original.
keyEnvs[]--key-envChave de camada a partir de variável de ambiente.
keyFiles[]--key-fileChave de camada a partir de arquivo de texto UTF-8.

Receitas de automação

Backup de dump de banco de dados criptografado

$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

Proteção de artefatos 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

Transferência segura para parceiros

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

Arquivo de longo prazo

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

Exemplo de arquivo em lote

@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: copiar várias pastas

Guarde o script no caminho indicado. Cria um contentor com nome único e um registo por origem, para perante erros e preserva o código de saída CLI. AES-128-GCM funciona com Free; compressão e divisão exigem Pro ou 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
$LASTEXITCODE

Linux: cópias sem intervenção

Guarde o script Bash com finais de linha LF. Prepare a CLI e os segredos nos caminhos indicados e passe as pastas de origem como argumentos. Cada execução recebe um diretório próprio. Os erros deixam um registo e devolvem um código diferente de zero; as origens mantêm-se.

/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/reports

Agendar através do sistema operativo

Estas tarefas executam os scripts anteriores; este uso de create não exige Max. O registo Windows requer uma sessão iniciada; configure a execução sem sessão no Agendador, se necessário. Acrescente cron ao crontab do utilizador das cópias após verificar flock. Ambos os exemplos executam às 02:00 locais e evitam execuções agendadas sobrepostas. Verifique permissões e teste 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 -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: gerir o agendador

Crie a conta de serviço lockbox com as permissões necessárias, ative Max para essa conta e prepare o ficheiro UTF-8 separado jobs.txt com a palavra-passe. add acrescenta, não atualiza: use uma vez por tarefa. Mantenha um processo por ficheiro de tarefas e reinicie após alterações. O JSON de estado não repõe o histórico: ocorrências periódicas vencidas são ignoradas, uma tarefa once vencida pode repetir-se. Para arranques periódicos do sistema use create em vez de repetir run-once. O agendador reutiliza o nome de saída.

/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

Referência de comandos

ComandoPropósitoApelidos
helpMostrar ajuda do console.--help, -h, ?
device-idExibir ID do dispositivo PC para emissão de licença.deviceid, machine-id
licenseMostrar edição atual e caminho da licença.license-status, status
activateInstalar uma chave de licença vinculada ao dispositivo.activation
algorithmsListar algoritmos e edições mínimas.profiles, list-algorithms
keygenGerar chaves aleatórias.generate-key, generate-keys
createCriar contêiner criptografado.encrypt
openExtrair contêiner criptografado.decrypt, extract
verifyVerificar contentor—
scheduleGerenciar e executar tarefas agendadas.scheduler, scheduled-tasks
scriptExecutar arquivo de automação JSON.--script

Criar opções

--source, -sPasta a ser empacotada e criptografada.
--output, -oCaminho de saída .lbx.
--masterSenha mestra inline.
--master-envLer senha mestra de variável de ambiente.
--master-fileLer senha mestra de arquivo de texto UTF-8.
--layerAdicionar ALGORITHM=KEY.
--layer-envAdicionar ALGORITHM=ENV.
--layer-fileAdicionar ALGORITHM=FILE.
--algorithm, -aForma de algoritmo alternativa emparelhada com --key, --key-env ou --key-file.
--compressHabilitar compressão.
--no-compressDesabilitar compressão se configurada anteriormente.
--paddingO preenchimento aleatório aumenta o contentor para ocultar o tamanho dos dados. Estes bytes adicionais não são encriptados nem autenticados. B / KB / MB / GB / TB
--padding-bytesTamanho do preenchimento em bytes brutos.
--splitDividir saída em .lbx, .lbx1, .lbx2.
--split-bytesTamanho de cada parte em bytes brutos.
--no-splitDesabilitar divisão se configurada anteriormente.
--destruction-passwordSenha de destruição inline somente para Max. Inserir esta senha depois como senha mestra sobrescreve o container imediatamente.
--destruction-password-envLer a senha de destruição somente para Max a partir de uma variável de ambiente.
--destruction-password-fileLer a senha de destruição somente para Max a partir de um arquivo de texto UTF-8.
--delete-sourceExcluir a pasta de origem após a criação manual bem-sucedida.
--verify-after-createAtive a verificação após criar para validar automaticamente as cópias. A origem só é eliminada após sucesso; erros ou cancelamento preservam-na. O agendador integrado continua a exigir Max.

Opções de abertura

--container, -cContêiner .lbx existente.
--output, -oPasta de extração.
--master, --master-env, --master-fileFonte da senha mestre.
--key, -kChave de camada inline na ordem original.
--key-envChave de camada a partir de variável de ambiente.
--key-fileChave de camada a partir de arquivo de texto UTF-8.
—Permitido para fluxos de trabalho de senha de destruição. A extração normal falha após a leitura dos metadados se as chaves necessárias estiverem ausentes.

Opções do agendador

schedule addAdicionar uma tarefa ao .lbxjobs criptografado.
schedule listMostrar tarefas salvas.
schedule runExecutar trabalhador de longa duração.
schedule run-onceExecutar tarefas devidas uma vez e sair.
schedule statusLer o JSON de status de tempo de execução mais recente.
--tasks, --fileCaminho do arquivo de tarefa criptografado.
--password, --password-env, --password-fileSenha para o arquivo de tarefa.
--state, --status-fileCaminho do JSON de status de tempo de execução.
--nameNome da tarefa para schedule add.
--frequency, --everyFrequência da tarefa.
--start, --start-atData/hora de início local.
--delete-source-contentsExcluir o conteúdo da pasta de origem original após execução agendada bem-sucedida.
--poll-secondsIntervalo de polling do trabalhador para schedule run.

Use --language ou --lang para escolher o idioma da console e --quiet para ocultar o progresso habitual; os erros continuam na saída de erro padrão. Ctrl+C solicita cancelamento e retorna 1. O código 2 indica sintaxe inválida e 3 indica uma função de criação indisponível na edição atual. O código 0 também é retornado ao acionar intencionalmente a senha de destruição, portanto não comprova sozinho a extração de arquivos. Verifique o resultado esperado antes dos próximos passos de automação.

Códigos de saída e monitorização

schedule run-once devolve 1 se falhar uma tarefa com execução prevista. schedule status pode devolver 0 sem estado guardado. Verifique também lastSuccessAt e lastError. O exemplo assume cópias diárias e consultas a cada 30 segundos; ajuste a janela 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 -> Failed

Resolução de Problemas

Por que recebo o código de saída 3?

A edição atual não permite o recurso solicitado: muitas camadas, compressão, preenchimento criptográfico, divisão, agendador ou um algoritmo mais forte.

Por que a extração falha com um erro de tag de autenticação?

A senha mestre, a chave da camada, a ordem da camada ou o arquivo do contêiner está incorreto. Para contêineres divididos, verifique também se todas as partes estão presentes na mesma pasta.

Por que o agendador não é executado depois que fecho o console?

schedule run é o processo worker. Mantenha-o aberto ou inicie-o pelo Agendador de Tarefas do Windows ou por um wrapper de serviço.

Por que o comando schedule add falha imediatamente?

O agendador valida licença, pasta de origem, caminho de saída, algoritmos, senhas e espaço em disco disponível antes de salvar a tarefa.

Posso armazenar senhas do agendador dentro do arquivo .lbxjobs?

Sim. O arquivo .lbxjobs é criptografado com a senha do arquivo do agendador e armazena os metadados completos da tarefa, incluindo senhas de criptografia e chaves de camada.

O que acontece se uma execução agendada se sobrepõe à execução anterior?

O novo evento é ignorado, a tarefa reporta um status falho com uma explicação, e execuções futuras continuam após a conclusão da execução ativa.

Como evitar que segredos fiquem no histórico do shell?

Use --master-env, --master-file, --layer-env, --layer-file, --destruction-password-env, --destruction-password-file, --password-env e --password-file.