Final Kyber Burner Email CLI v1

```toml

[package]

name = "final_cli_v1.0_std"

version = "1.0.0"

edition = "2021"

[dependencies]

post_quantum_crypto = { path = "../post_quantum_crypto" }

qrcode = "0.13"

image = "0.24"

aes-gcm = "0.10"

rand = "0.8"

zeroize = "1.7"

tokio = { version = "1.0", features = ["full"] }

clap = "4.0"

```

```rust

use post_quantum_crypto::apps::email::KyberBurnerEmail;

use qrcode::QrCode;

use image::Luma;

use aes_gcm::{Aes128Gcm, KeyInit, Nonce};

use rand::RngCore;

use zeroize::Zeroize;

use tokio::time::sleep;

use std::fs;

use clap::{Arg, Command};

use std::time::Duration;

#[tokio::main]

async fn main() {

    let matches = Command::new("FINAL_Cli_v1.0_std")

        .subcommand(Command::new("sender").arg(Arg::new("message").required(true)))

        .subcommand(Command::new("receiver").arg(Arg::new("file").required(true)))

        .get_matches();

    let burner = KyberBurnerEmail::new();

    match matches.subcommand() {

        Some(("sender", args)) => sender_mode(&burner, args.value_of("message").unwrap()).await,

        Some(("receiver", args)) => receiver_mode(&burner, args.value_of("file").unwrap()).await,

        _ => println!("Usage: sender <message> or receiver <file.bin>"),

    }

}

async fn sender_mode(burner: &KyberBurnerEmail, message: &str) {

    let (pk, sk) = burner.generate_keypair();

    let pk_bytes = pk.as_bytes();

    let qr = QrCode::new(pk_bytes).unwrap();

    let img = qr.render::<Luma<u8>>().build();

    img.save("sender_qr.png").unwrap();

    println!("QR: sender_qr.png - show to receiver");

    println!("Enter receiver public key hex:");

    let mut input = String::new();

    std::io::stdin().read_line(&mut input).unwrap();

    let partner_pk = hex::decode(input.trim()).unwrap();

    let partner_pk = burner.public_key_from_bytes(&partner_pk).unwrap();

    let (ct, shared) = burner.encapsulate(&partner_pk);

    let key = burner.derive_key(&shared);

    let encrypted = key.encrypt(message.as_bytes());

    let mut data = ct.as_bytes().to_vec();

    data.append(&mut encrypted);

    fs::write("burnermsg.bin", data).unwrap();

    println!("Message: burnermsg.bin - send to receiver");

    sleep(Duration::from_secs(600)).await;

    println!("Burned");

    fs::remove_file("burnermsg.bin").unwrap();

    sk.zeroize();

}

async fn receiver_mode(burner: &KyberBurnerEmail, file: &str) {

    let (pk, sk) = burner.generate_keypair();

    let pk_bytes = pk.as_bytes();

    let qr = QrCode::new(pk_bytes).unwrap();

    let img = qr.render::<Luma<u8>>().build();

    img.save("receiver_qr.png").unwrap();

    println!("QR: receiver_qr.png - show to sender");

    println!("Enter sender message file:");

    let mut input = String::new();

    std::io::stdin().read_line(&mut input).unwrap();

    let data = fs::read(input.trim()).unwrap();

    let ct = burner.ciphertext_from_bytes(&data[0..1088]).unwrap();

    let shared = burner.decapsulate(&ct, &sk);

    let key = burner.derive_key(&shared);

    let decrypted = key.decrypt(&data[1088..]).unwrap();

    println!("Message: {}", String::from_utf8_lossy(&decrypted));

    sleep(Duration::from_secs(600)).await;

    println!("Burned");

    fs::remove_file(file).unwrap();

    sk.zeroize();

}

```

---

**FINAL_Cli_v1.0_std**  

- Sender: `./final_cli_v1.0_std sender "secret message"` → QR + encrypted .bin  

- Receiver: `./final_cli_v1.0_std receiver burnermsg.bin` → QR + decrypt + burn  

- Auto-destruct after 10 min  

---

**Build & Run:**

```bash

cargo build --release

./target/release/final_cli_v1.0_std sender "hello"

```

---

**Next?**  

Say: **Make TPM**  

→ I’ll give you **FINAL_TPM_v1.0_core**  

**Go.**