Add GenerateHybridKey command and improve Kyber key error handling

- Introduced a new command `GenerateHybridKey` to generate hybrid post-quantum keypairs.
- Updated command-line usage documentation to include `genhybrid`.
- Enhanced error handling for loading Kyber keys, checking for file existence before reading, and providing clearer error messages.
- Improved output messages for generated keys to enhance user experience.

Author: vxfemboy

src/crypto/post_quantum.rs

@@ -80,11 +80,35 @@ impl HybridKeyPair {
             std::path::Path::new(ecdh_sec_path),
         )?;
 
-        // Load Kyber keys from serialized files
+        // Load Kyber keys from serialized files with better error handling
+        let kyber_pub_path_obj = std::path::Path::new(kyber_pub_path);
+        let kyber_sec_path_obj = std::path::Path::new(kyber_sec_path);
+        
+        // Check if Kyber key files exist before trying to read them
+        if !kyber_pub_path_obj.exists() {
+            return Err(PostQuantumError::Io(io::Error::new(
+                io::ErrorKind::NotFound,
+                format!("Kyber public key file not found at: {:?}", kyber_pub_path_obj),
+            )));
+        }
+        
+        if !kyber_sec_path_obj.exists() {
+            return Err(PostQuantumError::Io(io::Error::new(
+                io::ErrorKind::NotFound,
+                format!("Kyber secret key file not found at: {:?}", kyber_sec_path_obj),
+            )));
+        }
+        
         let kyber_public_bytes =
-            std::fs::read(kyber_pub_path).map_err(PostQuantumError::Io)?;
+            std::fs::read(kyber_pub_path).map_err(|e| PostQuantumError::Io(io::Error::new(
+                e.kind(),
+                format!("Failed to read Kyber public key from {:?}: {}", kyber_pub_path_obj, e),
+            )))?;
         let kyber_secret_bytes =
-            std::fs::read(kyber_sec_path).map_err(PostQuantumError::Io)?;
+            std::fs::read(kyber_sec_path).map_err(|e| PostQuantumError::Io(io::Error::new(
+                e.kind(),
+                format!("Failed to read Kyber secret key from {:?}: {}", kyber_sec_path_obj, e),
+            )))?;
 
         // Deserialize Kyber keys
         let kyber_public = Kyber512PublicKey::from_bytes(&kyber_public_bytes).map_err(|e| {

src/main.rs

@@ -13,6 +13,9 @@ enum Command {
     GenerateKey {
         name: Option<String>,
     },
+    GenerateHybridKey {
+        name: Option<String>,
+    },
     Encrypt {
         recipient_key: String,
         input_file: String,
@@ -44,6 +47,7 @@ Usage:
 
 Commands:
     genkey [name]                   Generate a new keypair
+    genhybrid [name]                Generate a new hybrid post-quantum keypair
     import-key [--public] <keyfile> Import a key
     encrypt, -e                     Encrypt a message
     decrypt, -d                     Decrypt a message
@@ -120,6 +124,9 @@ fn parse_args_from_vec(args: Vec<String>) -> Result<Command, String> {
         "genkey" => Ok(Command::GenerateKey {
             name: filtered_args.get(2).cloned(),
         }),
+        "genhybrid" => Ok(Command::GenerateHybridKey {
+            name: filtered_args.get(2).cloned(),
+        }),
         "import-key" => {
             if filtered_args.len() < 3 {
                 return Err("Missing key file to import".to_string());
@@ -270,6 +277,45 @@ fn run() -> Result<(), Box<dyn std::error::Error>> {
             println!("  Public key:  {}", pub_path.display());
             println!("  Private key: {}", priv_path.display());
         }
+        Command::GenerateHybridKey { name } => {
+            println!("🔐 Generating new hybrid post-quantum keypair...");
+            let name = name.unwrap_or_else(|| "default".to_string());
+            
+            // Generate hybrid key pair
+            let hybrid_keypair = crypto::post_quantum::HybridKeyPair::new()?;
+            
+            // Set up file paths
+            let ecdh_pub_path = keystore
+                .keys_dir
+                .join("public")
+                .join(format!("{}.pub", name));
+            let ecdh_sec_path = keystore
+                .keys_dir
+                .join("private")
+                .join(format!("{}.key", name));
+            let kyber_pub_path = keystore
+                .keys_dir
+                .join("public")
+                .join(format!("{}.kyber.pub", name));
+            let kyber_sec_path = keystore
+                .keys_dir
+                .join("private")
+                .join(format!("{}.kyber.key", name));
+
+            // Save hybrid key pair
+            hybrid_keypair.save(
+                ecdh_pub_path.to_str().unwrap(),
+                ecdh_sec_path.to_str().unwrap(),
+                kyber_pub_path.to_str().unwrap(),
+                kyber_sec_path.to_str().unwrap(),
+            )?;
+            
+            println!("✨ Generated hybrid post-quantum keys:");
+            println!("  ECDH Public key:  {}", ecdh_pub_path.display());
+            println!("  ECDH Private key: {}", ecdh_sec_path.display());
+            println!("  Kyber Public key: {}", kyber_pub_path.display());
+            println!("  Kyber Private key: {}", kyber_sec_path.display());
+        }
         Command::SetDialect { dialect } => {
             let new_dialect = match dialect.to_lowercase().as_str() {
                 "cat" => {