Offset  Length  Field           Description
──────  ──────  ─────────────   ─────────────────────────────
0       1       version         Format version (currently 1)
1       32      salt            Argon2id salt (random per backup)
33      12      nonce           AES-GCM nonce (random per encryption)
45      variable ciphertext     AES-256-GCM output + 16-byte auth tag

{
  "schema_version": 1,
  "version": 1,
  "created_at": "2026-03-10T14:30:00Z",
  "original_file": ".env.production",
  "tool_version": "0.2.1",
  "content": "DATABASE_URL=postgresql://...\nAPI_KEY=sk-...\n"
}

// From backup.rs encrypt_content():
let params = Params::new(65536, 3, 1, Some(32))?;
let argon2 = Argon2::new(Algorithm::Argon2id, Version::V0x13, params);

// Fresh salt for key derivation (32 bytes)
let mut salt_bytes = [0u8; 32];
OsRng.fill_bytes(&mut salt_bytes);

// Fresh nonce for encryption (12 bytes)
let mut nonce_bytes = [0u8; 12];
OsRng.fill_bytes(&mut nonce_bytes);

# Two backups of identical .env with same password:
$ evnx backup --output a.backup  # password: "correct-horse"
$ evnx backup --output b.backup  # password: "correct-horse"

$ diff a.backup b.backup  # Files are DIFFERENT (Base64 output varies)

use dialoguer::Password;

let password = Password::new()
    .with_prompt("Enter encryption password")
    .interact()?;  // No echo, reads from TTY

use zeroize::Zeroize;

// After password is no longer needed:
password.zeroize();  // Overwrites heap buffer with zeros

// Minimum length check (sanity guard, not cryptographic guarantee)
if password.len() < 8 {
    return Err(anyhow!("Password must be at least 8 characters (got {})", password.len()));
}

#[cfg(unix)]
{
    use std::os::unix::fs::OpenOptionsExt;
    use std::fs::OpenOptions;

    let mut file = OpenOptions::new()
        .write(true)
        .create(true)
        .truncate(true)
        .mode(0o600)  // rw------- : owner read/write only
        .open(path)?;
    // ... write content ...
}

// Simplified atomic write pattern
fn atomic_write(path: &str, content: &[u8]) -> Result<()> {
    let temp = NamedTempFile::new_in(parent_dir)?;  // Random name in same dir
    temp.write_all(content)?;
    temp.sync_all()?;  // Ensure data on disk
    temp.persist(path)?;  // Atomic rename

    #[cfg(unix)]
    set_permissions(path, 0o600)?;  // Set permissions after persist
    Ok(())
}

# 1. Verify backup feature is enabled
cargo build --features backup 2>&1 | grep -q "Compiling evnx" && echo "✓ Feature enabled"

# 2. Check for known dependency vulnerabilities
cargo audit  # Requires cargo-audit installed

# 3. Verify Rust toolchain is up to date
rustc --version  # Should be >= 1.75.0 for latest crypto crate compatibility

# 4. Test backup/restore roundtrip
echo "TEST_SECRET=super_secret_value" > .env.test
evnx backup --env .env.test --output test.backup  # Interactive password
evnx restore test.backup --output .env.test.restored --dry-run  # Verify metadata

# 5. Verify file permissions
ls -l .env.test.backup  # Should show -rw------- (0o600) on Unix

# 6. Confirm no network activity
strace -e trace=network evnx backup --env .env.test 2>&1 | grep -E "connect|sendto" || echo "✓ No network calls"

# 7. Validate password policy compliance
# (evnx enforces min 8 chars; consider org policy for stronger requirements)

# 8. Ensure backup storage is encrypted at rest
# (Use LUKS, FileVault, or cloud KMS for backup directory)

# 9. Document password recovery procedure
# (Since passwords are unrecoverable, define team protocol for lost passwords)

# 10. Schedule periodic restore tests
# (A backup you can't restore is not a backup)

// In backup.rs encrypt_content():
// Default: Params::new(65536, 3, 1, Some(32))

// For memory-constrained environments (less secure):
let params = Params::new(16384, 2, 1, Some(32))?;  // 16 MiB, 2 iterations

// For high-security environments (slower):
let params = Params::new(262144, 4, 1, Some(32))?;  // 256 MiB, 4 iterations

// Future interface (not yet implemented):
evnx backup --recipient "age1qyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqszqgpqyqs"  // age public key

# 1. Verify backup file integrity
wc -c .env.backup  # Should be > 61 bytes (min: 1+32+12+16 Base64-encoded)

# 2. Check Base64 validity
base64 -d .env.backup > /dev/null && echo "✓ Valid Base64" || echo "✗ Corrupt Base64"

# 3. Test with known-good password
# (If you have a test backup with known password)

# 4. Try restore with --dry-run to see if metadata parses
evnx restore .env.backup --dry-run  # Still prompts for password

# Check system RNG health
cat /dev/random | head -c 32 | base64  # Should produce output without error

# If RNG is broken, address OS-level issue first

# GitHub Actions example
- name: Restore backup
  env:
    ENV_PASSWORD: ${{ secrets.ENV_BACKUP_PASSWORD }}
  run: |
    # Use --password ONLY with secrets manager injection
    evnx restore backup.env --password "$ENV_PASSWORD"