Version v0.2.21 - Implement interactive file encryption and decryption in menu system

.clinerules/workspace_rules.md

@@ -0,0 +1,4 @@
+
+When building, use build.sh, not make. 
+
+Use it as follows: build.sh -m "useful comment on changes being made"

README.md

@@ -164,11 +164,9 @@ Offset | Size | Field               | Description
 4      | 2    | Version           | Format version (currently 1)
 6      | 32   | Pad Checksum      | Binary pad checksum (32 bytes)
 38     | 8    | Pad Offset        | Offset in pad file (uint64_t)
-46     | 2    | Filename Length   | Original filename length (uint16_t)
+46     | 4    | File Mode         | Original file permissions (uint32_t)
-48     | var  | Original Filename | Original filename string
+50     | 8    | File Size         | Original file size (uint64_t)
-var    | 4    | File Mode         | Original file permissions (uint32_t)
+58     | var  | Encrypted Data    | XOR-encrypted file contents
-var    | 8    | File Size         | Original file size (uint64_t)
-var    | var  | Encrypted Data    | XOR-encrypted file contents
 ```
 
 ### .otp.asc File Format (ASCII Armored)
@@ -185,7 +183,7 @@ Pad-Offset: <decimal-offset-value>
 -----END OTP MESSAGE-----
 ```
 
-**Note:** ASCII armored files lose original filename and permission metadata.
+**Note:** ASCII armored files do not preserve original file permissions metadata.
 
 ## Usage Examples
 

debug.c

@@ -0,0 +1 @@
+int main() { printf("Testing direct filename: %d\n", strncmp("97d9d82b5414a9439102f3811fb90ab1d6368a00d33229a18b306476f9d04f82.pad", "97", 2)); return 0; }

otp.c

@@ -151,6 +151,14 @@ int interactive_mode(void) {
 }
 
 int command_line_mode(int argc, char* argv[]) {
+    // Check for help flags first
+    if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--h") == 0 || 
+        strcmp(argv[1], "-help") == 0 || strcmp(argv[1], "--help") == 0 || 
+        strcmp(argv[1], "help") == 0) {
+        print_usage(argv[0]);
+        return 0;
+    }
+    
     if (strcmp(argv[1], "generate") == 0 || strcmp(argv[1], "-g") == 0) {
         if (argc != 3) {
             printf("Usage: %s generate|-g <size>\n", argv[0]);
@@ -249,8 +257,8 @@ int command_line_mode(int argc, char* argv[]) {
 void show_main_menu(void) {
     printf("=== Main Menu ===\n");
     printf("\033[4mG\033[0menerate new pad\n");
-    printf("\033[4mE\033[0mncrypt message\n");
+    printf("\033[4mE\033[0mncrypt data (text/file)\n");
-    printf("\033[4mD\033[0mecrypt message\n");
+    printf("\033[4mD\033[0mecrypt data (text/file)\n");
     printf("\033[4mL\033[0mist available pads\n");
     printf("\033[4mS\033[0mhow pad information\n");
     printf("E\033[4mx\033[0mit\n");
@@ -297,7 +305,7 @@ int handle_generate_menu(void) {
 }
 
 int handle_encrypt_menu(void) {
-    printf("\n=== Encrypt Message ===\n");
+    printf("\n=== Encrypt Data ===\n");
     
     int pad_count = list_available_pads();
     if (pad_count == 0) {
@@ -305,20 +313,143 @@ int handle_encrypt_menu(void) {
         return 1;
     }
     
-    printf("\nEnter pad selection (number, chksum, or prefix): ");
+    // Ask user to choose between text and file encryption
-    char input[MAX_HASH_LENGTH];
+    printf("\nSelect encryption type:\n");
-    if (!fgets(input, sizeof(input), stdin)) {
+    printf("1. Text message\n");
+    printf("2. File\n");
+    printf("Enter choice (1-2): ");
+    
+    char choice_input[10];
+    if (!fgets(choice_input, sizeof(choice_input), stdin)) {
         printf("Error: Failed to read input\n");
         return 1;
     }
     
-    input[strcspn(input, "\n")] = 0;
+    int choice = atoi(choice_input);
-    return encrypt_text(input, NULL);  // NULL for interactive mode
+    
+    if (choice == 1) {
+        // Text encryption
+        printf("\nEnter pad selection (number, chksum, or prefix): ");
+        char input[MAX_HASH_LENGTH];
+        if (!fgets(input, sizeof(input), stdin)) {
+            printf("Error: Failed to read input\n");
+            return 1;
+        }
+        
+        input[strcspn(input, "\n")] = 0;
+        return encrypt_text(input, NULL);  // NULL for interactive mode
+    }
+    else if (choice == 2) {
+        // File encryption
+        printf("\nEnter input file path: ");
+        char input_file[512];
+        if (!fgets(input_file, sizeof(input_file), stdin)) {
+            printf("Error: Failed to read input\n");
+            return 1;
+        }
+        input_file[strcspn(input_file, "\n")] = 0;
+        
+        // Check if file exists
+        if (access(input_file, R_OK) != 0) {
+            printf("Error: File '%s' not found or cannot be read\n", input_file);
+            return 1;
+        }
+        
+        printf("\nEnter pad selection (number, chksum, or prefix): ");
+        char pad_input[MAX_HASH_LENGTH];
+        if (!fgets(pad_input, sizeof(pad_input), stdin)) {
+            printf("Error: Failed to read input\n");
+            return 1;
+        }
+        pad_input[strcspn(pad_input, "\n")] = 0;
+        
+        // Ask for output format
+        printf("\nSelect output format:\n");
+        printf("1. Binary (.otp) - preserves file permissions\n");
+        printf("2. ASCII (.otp.asc) - text-safe format\n");
+        printf("Enter choice (1-2): ");
+        
+        char format_input[10];
+        if (!fgets(format_input, sizeof(format_input), stdin)) {
+            printf("Error: Failed to read input\n");
+            return 1;
+        }
+        
+        int ascii_armor = (atoi(format_input) == 2) ? 1 : 0;
+        
+        // Ask for custom output filename (optional)
+        printf("\nEnter output filename (or press Enter for default): ");
+        char output_file[512];
+        if (!fgets(output_file, sizeof(output_file), stdin)) {
+            printf("Error: Failed to read input\n");
+            return 1;
+        }
+        output_file[strcspn(output_file, "\n")] = 0;
+        
+        const char* output_filename = (strlen(output_file) > 0) ? output_file : NULL;
+        
+        return encrypt_file(pad_input, input_file, output_filename, ascii_armor);
+    }
+    else {
+        printf("Invalid choice. Please enter 1 or 2.\n");
+        return 1;
+    }
 }
 
 int handle_decrypt_menu(void) {
-    printf("\n=== Decrypt Message ===\n");
+    printf("\n=== Decrypt Data ===\n");
-    return decrypt_text(NULL, NULL);  // No pad selection needed - chksum comes from message
+    
+    // Ask user to choose between text/message and file decryption
+    printf("\nSelect decryption type:\n");
+    printf("1. Text message (ASCII armored)\n");
+    printf("2. File (.otp or .otp.asc)\n");
+    printf("Enter choice (1-2): ");
+    
+    char choice_input[10];
+    if (!fgets(choice_input, sizeof(choice_input), stdin)) {
+        printf("Error: Failed to read input\n");
+        return 1;
+    }
+    
+    int choice = atoi(choice_input);
+    
+    if (choice == 1) {
+        // Text/message decryption - interactive input
+        return decrypt_text(NULL, NULL);  // No pad selection needed - chksum comes from message
+    }
+    else if (choice == 2) {
+        // File decryption
+        printf("\nEnter encrypted file path (.otp or .otp.asc): ");
+        char input_file[512];
+        if (!fgets(input_file, sizeof(input_file), stdin)) {
+            printf("Error: Failed to read input\n");
+            return 1;
+        }
+        input_file[strcspn(input_file, "\n")] = 0;
+        
+        // Check if file exists
+        if (access(input_file, R_OK) != 0) {
+            printf("Error: File '%s' not found or cannot be read\n", input_file);
+            return 1;
+        }
+        
+        // Ask for custom output filename (optional)
+        printf("\nEnter output filename (or press Enter for default): ");
+        char output_file[512];
+        if (!fgets(output_file, sizeof(output_file), stdin)) {
+            printf("Error: Failed to read input\n");
+            return 1;
+        }
+        output_file[strcspn(output_file, "\n")] = 0;
+        
+        const char* output_filename = (strlen(output_file) > 0) ? output_file : NULL;
+        
+        return decrypt_file(input_file, output_filename);
+    }
+    else {
+        printf("Invalid choice. Please enter 1 or 2.\n");
+        return 1;
+    }
 }
 
 uint64_t parse_size_string(const char* size_str) {
@@ -365,40 +496,53 @@ uint64_t parse_size_string(const char* size_str) {
 
 char* find_pad_by_prefix(const char* prefix) {
     DIR* dir = opendir(PADS_DIR);
-    if (!dir) return NULL;
+    if (!dir) {
+        printf("Error: Cannot open pads directory\n");
+        return NULL;
+    }
     
     struct dirent* entry;
     char* matches[100];  // Store up to 100 matches
     int match_count = 0;
     
-    // Check if it's a number (for interactive menu selection)
+    // Always try hex prefix matching first
-    char* endptr;
+    size_t prefix_len = strlen(prefix);
-    int selection = strtol(prefix, &endptr, 10);
+    while ((entry = readdir(dir)) != NULL && match_count < 100) {
-    if (*endptr == '\0' && selection > 0) {
+        // Skip . and .. entries, and only process .pad files
-        // It's a number, find the nth pad
+        if (entry->d_name[0] == '.') continue;
-        int current = 0;
+        if (!strstr(entry->d_name, ".pad")) continue;
-        rewinddir(dir);
+        if (strlen(entry->d_name) != 68) continue; // 64 char chksum + ".pad"
-        while ((entry = readdir(dir)) != NULL && match_count == 0) {
+        
-            if (strstr(entry->d_name, ".pad") && strlen(entry->d_name) == 68) { // 64 char chksum + ".pad"
+        // Compare prefix with the filename (checksum part)
+        if (strncmp(entry->d_name, prefix, prefix_len) == 0) {
+            matches[match_count] = malloc(65);
+            strncpy(matches[match_count], entry->d_name, 64);
+            matches[match_count][64] = '\0';
+            match_count++;
+        }
+    }
+    
+    // If no hex prefix matches and it looks like a small number, try number selection
+    if (match_count == 0) {
+        char* endptr;
+        int selection = strtol(prefix, &endptr, 10);
+        if (*endptr == '\0' && selection > 0 && selection <= 100) {
+            // It's a number, find the nth pad
+            int current = 0;
+            rewinddir(dir);
+            while ((entry = readdir(dir)) != NULL) {
+                // Skip . and .. entries, and only process .pad files
+                if (entry->d_name[0] == '.') continue;
+                if (!strstr(entry->d_name, ".pad")) continue;
+                if (strlen(entry->d_name) != 68) continue; // 64 char chksum + ".pad"
+                
                 current++;
                 if (current == selection) {
                     matches[match_count] = malloc(65);
                     strncpy(matches[match_count], entry->d_name, 64);
                     matches[match_count][64] = '\0';
                     match_count = 1;
-                }
+                    break;
-            }
-        }
-    } else {
-        // Find pads that start with the prefix
-        size_t prefix_len = strlen(prefix);
-        while ((entry = readdir(dir)) != NULL && match_count < 100) {
-            if (strstr(entry->d_name, ".pad") && strlen(entry->d_name) == 68) {
-                if (strncmp(entry->d_name, prefix, prefix_len) == 0) {
-                    matches[match_count] = malloc(65);
-                    strncpy(matches[match_count], entry->d_name, 64);
-                    matches[match_count][64] = '\0';
-                    match_count++;
                 }
             }
         }
@@ -418,14 +562,35 @@ char* find_pad_by_prefix(const char* prefix) {
         printf("Multiple matches found for '%s':\n", prefix);
         for (int i = 0; i < match_count; i++) {
             printf("%d. %.16s...\n", i + 1, matches[i]);
-            if (i > 0) free(matches[i]);
         }
-        printf("Please be more specific.\n");
+        printf("Please be more specific or enter a number (1-%d): ", match_count);
-        char* result = matches[0];
+        fflush(stdout);
-        for (int i = 1; i < match_count; i++) {
+        
+        char choice_input[64];
+        if (fgets(choice_input, sizeof(choice_input), stdin)) {
+            choice_input[strcspn(choice_input, "\n")] = 0;
+            
+            // Check if it's a number
+            char* endptr;
+            int choice = strtol(choice_input, &endptr, 10);
+            if (*endptr == '\0' && choice >= 1 && choice <= match_count) {
+                // Valid choice, return selected pad
+                char* result = matches[choice - 1];
+                // Free the others
+                for (int i = 0; i < match_count; i++) {
+                    if (i != choice - 1) {
+                        free(matches[i]);
+                    }
+                }
+                return result;
+            }
+        }
+        
+        // Invalid choice or no input, free all and return NULL
+        for (int i = 0; i < match_count; i++) {
             free(matches[i]);
         }
-        return result;
+        return NULL;
     }
 }
 
@@ -1412,16 +1577,6 @@ int encrypt_file(const char* pad_identifier, const char* input_file, const char*
         // Pad offset: 8 bytes
         fwrite(&current_offset, sizeof(uint64_t), 1, output_fp);
         
-        // Original filename length and name
-        const char* base_filename = strrchr(input_file, '/');
-        if (base_filename) {
-            base_filename++; // Skip the '/'
-        } else {
-            base_filename = input_file;
-        }
-        uint16_t filename_len = strlen(base_filename);
-        fwrite(&filename_len, sizeof(uint16_t), 1, output_fp);
-        fwrite(base_filename, 1, filename_len, output_fp);
         
         // File mode: 4 bytes
         uint32_t file_mode = input_stat.st_mode;
@@ -1494,7 +1649,6 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
     uint16_t version;
     unsigned char pad_chksum_bin[32];
     uint64_t pad_offset;
-    uint16_t filename_len;
     uint32_t file_mode;
     uint64_t file_size;
     
@@ -1502,7 +1656,8 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
         fread(&version, sizeof(uint16_t), 1, input_fp) != 1 ||
         fread(pad_chksum_bin, 1, 32, input_fp) != 32 ||
         fread(&pad_offset, sizeof(uint64_t), 1, input_fp) != 1 ||
-        fread(&filename_len, sizeof(uint16_t), 1, input_fp) != 1) {
+        fread(&file_mode, sizeof(uint32_t), 1, input_fp) != 1 ||
+        fread(&file_size, sizeof(uint64_t), 1, input_fp) != 1) {
         printf("Error: Cannot read binary header\n");
         fclose(input_fp);
         return 1;
@@ -1514,25 +1669,6 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
         return 1;
     }
     
-    // Read original filename
-    char* original_filename = malloc(filename_len + 1);
-    if (fread(original_filename, 1, filename_len, input_fp) != filename_len) {
-        printf("Error: Cannot read original filename\n");
-        free(original_filename);
-        fclose(input_fp);
-        return 1;
-    }
-    original_filename[filename_len] = '\0';
-    
-    // Read remaining header
-    if (fread(&file_mode, sizeof(uint32_t), 1, input_fp) != 1 ||
-        fread(&file_size, sizeof(uint64_t), 1, input_fp) != 1) {
-        printf("Error: Cannot read file metadata\n");
-        free(original_filename);
-        fclose(input_fp);
-        return 1;
-    }
-    
     // Convert binary checksum to hex
     char pad_chksum_hex[65];
     for (int i = 0; i < 32; i++) {
@@ -1541,7 +1677,6 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
     pad_chksum_hex[64] = '\0';
     
     printf("Decrypting binary file...\n");
-    printf("Original filename: %s\n", original_filename);
     printf("File size: %lu bytes\n", file_size);
     
     // Check if we have the required pad
@@ -1553,7 +1688,6 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
         printf("Error: Required pad not found: %s\n", pad_chksum_hex);
         printf("Available pads:\n");
         list_available_pads();
-        free(original_filename);
         fclose(input_fp);
         return 1;
     }
@@ -1561,8 +1695,7 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
     // Determine output filename
     char default_output[512];
     if (output_file == NULL) {
-        strncpy(default_output, original_filename, sizeof(default_output) - 1);
+        snprintf(default_output, sizeof(default_output), "decrypted.bin");
-        default_output[sizeof(default_output) - 1] = '\0';
         output_file = default_output;
     }
     
@@ -1570,7 +1703,6 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
     unsigned char* encrypted_data = malloc(file_size);
     if (fread(encrypted_data, 1, file_size, input_fp) != file_size) {
         printf("Error: Cannot read encrypted data\n");
-        free(original_filename);
         free(encrypted_data);
         fclose(input_fp);
         return 1;
@@ -1581,14 +1713,12 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
     FILE* pad_file = fopen(pad_path, "rb");
     if (!pad_file) {
         printf("Error: Cannot open pad file\n");
-        free(original_filename);
         free(encrypted_data);
         return 1;
     }
     
     if (fseek(pad_file, pad_offset, SEEK_SET) != 0) {
         printf("Error: Cannot seek to offset in pad file\n");
-        free(original_filename);
         free(encrypted_data);
         fclose(pad_file);
         return 1;
@@ -1597,7 +1727,6 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
     unsigned char* pad_data = malloc(file_size);
     if (fread(pad_data, 1, file_size, pad_file) != file_size) {
         printf("Error: Cannot read pad data\n");
-        free(original_filename);
         free(encrypted_data);
         free(pad_data);
         fclose(pad_file);
@@ -1614,7 +1743,6 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
     FILE* output_fp = fopen(output_file, "wb");
     if (!output_fp) {
         printf("Error: Cannot create output file %s\n", output_file);
-        free(original_filename);
         free(encrypted_data);
         free(pad_data);
         return 1;
@@ -1622,7 +1750,6 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
     
     if (fwrite(encrypted_data, 1, file_size, output_fp) != file_size) {
         printf("Error: Cannot write decrypted data\n");
-        free(original_filename);
         free(encrypted_data);
         free(pad_data);
         fclose(output_fp);
@@ -1639,7 +1766,6 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
     printf("Restored permissions and metadata\n");
     
     // Cleanup
-    free(original_filename);
     free(encrypted_data);
     free(pad_data);