Cleanup

files/o2.txt.otp.asc

@@ -1,7 +0,0 @@
------BEGIN OTP MESSAGE-----
-Version: v1.0.0
-Pad-ChkSum: d0aaeb745bfbc62b1ed8c0eca4f8dc016f4fd9ed49130979f2bb25a2a3c8192e
-Pad-Offset: 128
-
-6+JsEJWRpLI2Z62tSw3EMiIjyTWVk0IfSek1to0/nYPXrswMzCtlultBcA==
------END OTP MESSAGE-----

files/test_decrypt.txt

@@ -1 +0,0 @@
-Test file content for decryption

files/test_file.txt

@@ -1 +0,0 @@
-Hello, this is a test file for encryption!

files/test_file.txt.otp.asc

@@ -1,7 +0,0 @@
------BEGIN OTP MESSAGE-----
-Version: v0.2.29
-Pad-ChkSum: d0d4a489354348b08d8c7b324814d8c50010042e9da47f2c973f32a16a09101b
-Pad-Offset: 57
-
-05S8GfS0tFfczNMUz0xrieFGoPSREM4uo5QhFGoBCcOzjfTXTDMt3hRtAQ==
------END OTP MESSAGE-----

files/test_input.txt

@@ -1 +0,0 @@
-This is a test file for encryption.

otp.c

@@ -14,6 +14,7 @@
 #include <fcntl.h>
 #include <math.h>
 #include "nostr_chacha20.h"
+#include "otp.h"
 
 // Custom base64 character set
 static const char base64_chars[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
@@ -44,148 +45,15 @@ static const int base64_decode_table[256] = {
 #define FILES_DIR "files"
 #define MAX_ENTROPY_BUFFER 32768  // 32KB entropy buffer
 
-// Decrypt operation modes for universal decrypt function
+////////////////////////////////////////////////////////////////////////////////
-typedef enum {
+////////////////////////////////////////////////////////////////////////////////
-    DECRYPT_MODE_INTERACTIVE,    // Interactive text decryption with prompts
+//      GLOBAL VARIABLES
-    DECRYPT_MODE_SILENT,         // Silent text decryption (no prompts/labels)
+////////////////////////////////////////////////////////////////////////////////
-    DECRYPT_MODE_FILE_TO_TEXT,   // File to text output with prompts
+////////////////////////////////////////////////////////////////////////////////
-    DECRYPT_MODE_FILE_TO_FILE    // File to file output (binary)
-} decrypt_mode_t;
 
-// Global variable for current pads directory (can be local or OTP thumb drive)
 static char current_pads_dir[512] = DEFAULT_PADS_DIR;
-
-// Global variable for default pad path from preferences
 static char default_pad_path[1024] = "";
-
+static int is_interactive_mode = 0;
-// Function prototypes
-int main(int argc, char* argv[]);
-int interactive_mode(void);
-int command_line_mode(int argc, char* argv[]);
-int pipe_mode(int argc, char* argv[], const char* piped_text);
-
-// Stdin detection functions
-int has_stdin_data(void);
-char* read_stdin_text(void);
-
-// Preferences management functions
-int load_preferences(void);
-int save_preferences(void);
-char* get_preference(const char* key);
-int set_preference(const char* key, const char* value);
-char* get_default_pad_path(void);
-int set_default_pad_path(const char* pad_path);
-
-// OTP thumb drive detection function
-int detect_otp_thumb_drive(char* otp_drive_path, size_t path_size);
-
-// Editor and file manager functions
-char* get_preferred_editor(void);
-char* get_preferred_file_manager(void);
-int launch_text_editor(const char* initial_content, char* result_buffer, size_t buffer_size);
-int launch_file_manager(const char* start_directory, char* selected_file, size_t buffer_size);
-
-// Core functions
-int generate_pad(uint64_t size_bytes, int show_progress);
-int encrypt_text(const char* pad_identifier, const char* input_text);
-int decrypt_text(const char* pad_identifier, const char* encrypted_message);
-int decrypt_text_silent(const char* pad_identifier, const char* encrypted_message);
-int encrypt_file(const char* pad_identifier, const char* input_file, const char* output_file, int ascii_armor);
-int decrypt_file(const char* input_file, const char* output_file);
-int decrypt_binary_file(FILE* input_fp, const char* output_file);
-int decrypt_ascii_file(const char* input_file, const char* output_file);
-
-// Enhanced entropy system functions
-typedef struct {
-    size_t target_bytes;           // Target entropy to collect
-    size_t collected_bytes;        // Bytes collected so far
-    size_t unique_keys;           // Number of unique keys pressed
-    double collection_start_time; // Start timestamp
-    double last_keypress_time;    // Last keypress timestamp
-    unsigned char quality_score;  // Entropy quality (0-100)
-    int auto_complete_enabled;    // Allow auto-complete at minimum
-    unsigned char key_histogram[256]; // Track key frequency
-} entropy_collection_state_t;
-
-int setup_raw_terminal(struct termios* original_termios);
-void restore_terminal(struct termios* original_termios);
-int collect_entropy_with_feedback(unsigned char* entropy_buffer, size_t target_bytes,
-                                 size_t* collected_bytes, int allow_early_exit);
-void display_entropy_progress(const entropy_collection_state_t* state);
-void draw_progress_bar(double percentage, int width);
-void draw_quality_bar(double quality, int width, const char* label);
-double calculate_timing_quality(const entropy_collection_state_t* state);
-double calculate_variety_quality(const entropy_collection_state_t* state);
-unsigned char calculate_overall_quality(const entropy_collection_state_t* state);
-double get_precise_time(void);
-int derive_chacha20_params(const unsigned char* entropy_data, size_t entropy_size,
-                          unsigned char key[32], unsigned char nonce[12]);
-int add_entropy_to_pad(const char* pad_chksum, const unsigned char* entropy_data,
-                      size_t entropy_size, int show_progress);
-int handle_add_entropy_to_pad(const char* pad_chksum);
-
-// Enhanced entropy system helper functions
-int update_pad_checksum_after_entropy(const char* old_chksum, char* new_chksum);
-int rename_pad_files_safely(const char* old_chksum, const char* new_chksum);
-int is_pad_unused(const char* pad_chksum);
-
-// Directory management
-int ensure_pads_directory(void);
-void get_pad_path(const char* chksum, char* pad_path, char* state_path);
-const char* get_files_directory(void);
-void get_default_file_path(const char* filename, char* result_path, size_t result_size);
-
-// Utility functions
-uint64_t parse_size_string(const char* size_str);
-char* find_pad_by_prefix(const char* prefix);
-int show_pad_info(const char* chksum);
-void show_progress(uint64_t current, uint64_t total, time_t start_time);
-
-// File operations
-int read_state_offset(const char* pad_chksum, uint64_t* offset);
-int write_state_offset(const char* pad_chksum, uint64_t offset);
-int calculate_checksum(const char* filename, char* checksum_hex);
-// Universal core functions for code consolidation
-int universal_xor_operation(const unsigned char* data, size_t data_len,
-                           const unsigned char* pad_data, unsigned char* result);
-int parse_ascii_message(const char* message, char* chksum, uint64_t* offset, char* base64_data);
-int load_pad_data(const char* pad_chksum, uint64_t offset, size_t length, unsigned char** pad_data);
-int generate_ascii_armor(const char* chksum, uint64_t offset, const unsigned char* encrypted_data,
-                        size_t data_length, char** ascii_output);
-int validate_pad_integrity(const char* pad_path, const char* expected_chksum);
-
-// Universal decrypt function - consolidates all decrypt operations
-int universal_decrypt(const char* input_data, const char* output_target, decrypt_mode_t mode);
-
-char* custom_base64_encode(const unsigned char* input, int length);
-unsigned char* custom_base64_decode(const char* input, int* output_length);
-
-// Menu functions
-void show_main_menu(void);
-int handle_generate_menu(void);
-int handle_encrypt_menu(void);
-int handle_decrypt_menu(void);
-int handle_pads_menu(void);
-int handle_text_encrypt(void);
-int handle_file_encrypt(void);
-
-// Enhanced input functions
-int get_filename_with_default(const char* prompt, const char* default_path, char* result, size_t result_size);
-
-// Directory display functions
-void get_directory_display(const char* file_path, char* result, size_t result_size);
-
-// Unified pad selection function
-typedef enum {
-    PAD_FILTER_ALL,           // Show all pads
-    PAD_FILTER_UNUSED_ONLY    // Show only unused pads (0% usage)
-} pad_filter_type_t;
-
-char* select_pad_interactive(const char* title, const char* prompt, pad_filter_type_t filter_type, int allow_cancel);
-
-void print_usage(const char* program_name);
-
-
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -197,19 +65,14 @@ int main(int argc, char* argv[]) {
     // Load preferences first
     load_preferences();
     
-    // Check for piped input first (before any output)
+    // Detect interactive mode: only true when running with no arguments
-    int is_pipe_mode = (argc == 1 && has_stdin_data());
+    is_interactive_mode = (argc == 1);
-    
-    // Check for decrypt command with piped input
-    int is_decrypt_pipe = (argc == 2 && 
-                          (strcmp(argv[1], "decrypt") == 0 || strcmp(argv[1], "-d") == 0) && 
-                          has_stdin_data());
     
     // Check for OTP thumb drive on startup
     char otp_drive_path[512];
     if (detect_otp_thumb_drive(otp_drive_path, sizeof(otp_drive_path))) {
-        // Only show messages in interactive/command mode, not pipe mode
+        // Only show messages in interactive mode
-        if (!is_pipe_mode && !is_decrypt_pipe) {
+        if (is_interactive_mode) {
             printf("Detected OTP thumb drive: %s\n", otp_drive_path);
             printf("Using as default pads directory for this session.\n\n");
         }
@@ -217,17 +80,7 @@ int main(int argc, char* argv[]) {
         current_pads_dir[sizeof(current_pads_dir) - 1] = '\0';
     }
     
-    if (is_pipe_mode) {
+    if (is_interactive_mode) {
-        // No arguments but has piped data - enter pipe mode
-        char* piped_text = read_stdin_text();
-        if (piped_text) {
-            int result = pipe_mode(argc, argv, piped_text);
-            free(piped_text);
-            return result;
-        }
-        // If reading stdin failed, fall back to interactive mode
-        return interactive_mode();
-    } else if (argc == 1) {
         return interactive_mode();
     } else {
         return command_line_mode(argc, argv);
@@ -244,8 +97,8 @@ int main(int argc, char* argv[]) {
 
 int command_line_mode(int argc, char* argv[]) {
     // Check for help flags first
-    if (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--h") == 0 || 
+    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 || strcmp(argv[1], "--help") == 0 ||
         strcmp(argv[1], "help") == 0) {
         print_usage(argv[0]);
         return 0;
@@ -265,6 +118,16 @@ int command_line_mode(int argc, char* argv[]) {
         return generate_pad(size, 1);  // Use simplified pad generation
     }
     else if (strcmp(argv[1], "encrypt") == 0 || strcmp(argv[1], "-e") == 0) {
+        // Check for piped input first
+        if (has_stdin_data()) {
+            char* piped_text = read_stdin_text();
+            if (piped_text) {
+                int result = pipe_mode(argc, argv, piped_text);
+                free(piped_text);
+                return result;
+            }
+        }
+        
         if (argc < 2 || argc > 4) {
             printf("Usage: %s encrypt|-e [pad_chksum_or_prefix] [text_to_encrypt]\n", argv[0]);
             return 1;
@@ -334,7 +197,7 @@ int command_line_mode(int argc, char* argv[]) {
                 // Piped decrypt mode - read stdin and decrypt silently
                 char* piped_message = read_stdin_text();
                 if (piped_message) {
-                    int result = decrypt_text_silent(NULL, piped_message);
+                    int result = decrypt_text(NULL, piped_message);
                     free(piped_message);
                     return result;
                 }
@@ -346,7 +209,7 @@ int command_line_mode(int argc, char* argv[]) {
             // Check if the argument looks like an encrypted message (starts with -----)
             if (strncmp(argv[2], "-----BEGIN OTP MESSAGE-----", 27) == 0) {
                 // Inline decrypt with message only - use silent mode for command line
-                return decrypt_text_silent(NULL, argv[2]);
+                return decrypt_text(NULL, argv[2]);
             } else {
                 // Check if it's a file (contains . or ends with known extensions)
                 if (strstr(argv[2], ".") != NULL) {
@@ -366,7 +229,7 @@ int command_line_mode(int argc, char* argv[]) {
             } else {
                 // Legacy format: pad_chksum and message, or file with output
                 // Use silent mode for command line when message is provided
-                return decrypt_text_silent(argv[2], argv[3]);
+                return decrypt_text(argv[2], argv[3]);
             }
         }
         else if (argc == 5 && strcmp(argv[3], "-o") == 0) {
@@ -467,7 +330,7 @@ int interactive_mode(void) {
 void show_main_menu(void) {
 
 
-    printf("\n=========================== Main Menu - OTP v0.2.106 ===========================\n\n");
+    printf("\n=========================== Main Menu - OTP v0.2.111 ===========================\n\n");
 
     printf(" \033[4mT\033[0mext encrypt\n");    //TEXT ENCRYPT
     printf(" \033[4mF\033[0mile encrypt\n");    //FILE ENCRYPT
@@ -535,7 +398,7 @@ int handle_encrypt_menu(void) {
     if (choice == 1) {
         // Text encryption - use unified pad selection
         char* selected_pad = select_pad_interactive("=== Select Pad for Text Encryption ===",
-                                                  "Select pad (by prefix or number)",
+                                                  "Select pad (by prefix)",
                                                   PAD_FILTER_ALL, 1);
         if (!selected_pad) {
             printf("Text encryption cancelled.\n");
@@ -823,30 +686,7 @@ char* find_pad_by_prefix(const char* prefix) {
         }
     }
     
-    // If no hex prefix matches and it looks like a small number, try number selection
+    // Only prefix matching is supported
-    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) {
-                if (entry->d_name[0] == '.') continue;
-                if (!strstr(entry->d_name, ".pad")) continue;
-                if (strlen(entry->d_name) != 68) continue;
-                
-                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;
-                }
-            }
-        }
-    }
     
     closedir(dir);
     
@@ -864,32 +704,11 @@ char* find_pad_by_prefix(const char* prefix) {
     } else {
         printf("Multiple matches found for '%s':\n", prefix);
         for (int i = 0; i < match_count; i++) {
-            printf("%d. %.16s...\n", i + 1, matches[i]);
+            printf("  %.16s...\n", matches[i]);
         }
-        printf("Please be more specific or enter a number (1-%d): ", match_count);
+        printf("Please be more specific with your prefix.\n");
-        fflush(stdout);
         
-        char choice_input[64];
+        // Free all matches and return NULL
-        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]);
         }
@@ -1258,8 +1077,6 @@ int add_entropy_to_pad(const char* pad_chksum, const unsigned char* entropy_data
 ////////////////////////////////////////////////////////////////////////////////
 
 
-
-
 int encrypt_text(const char* pad_identifier, const char* input_text) {
     char* pad_chksum = find_pad_by_prefix(pad_identifier);
     if (!pad_chksum) {
@@ -1311,23 +1128,29 @@ int encrypt_text(const char* pad_identifier, const char* input_text) {
         text_buffer[sizeof(text_buffer) - 1] = '\0';
     } else {
         // Get input text from user (interactive mode)
-        printf("\nText input options:\n");
+        if (is_interactive_mode) {
-        printf(" 1. Type text directly\n");
+            printf("\nText input options:\n");
-        printf(" 2. Use text editor\n");
+            printf(" 1. Type text directly\n");
-        printf("Enter choice (1-2): ");
+            printf(" 2. Use text editor\n");
-        
+            printf("Enter choice (1-2): ");
-        char input_choice[10];
-        if (!fgets(input_choice, sizeof(input_choice), stdin)) {
-            printf("Error: Failed to read input\n");
-            free(pad_chksum);
-            return 1;
         }
         
-        if (atoi(input_choice) == 2) {
+        char input_choice[10] = "1"; // Default to direct input in non-interactive mode
+        if (is_interactive_mode) {
+            if (!fgets(input_choice, sizeof(input_choice), stdin)) {
+                printf("Error: Failed to read input\n");
+                free(pad_chksum);
+                return 1;
+            }
+        }
+        
+        if (is_interactive_mode && atoi(input_choice) == 2) {
             // Use text editor
             if (launch_text_editor(NULL, text_buffer, sizeof(text_buffer)) != 0) {
-                printf("Falling back to direct text input.\n");
+                if (is_interactive_mode) {
-                printf("Enter text to encrypt: ");
+                    printf("Falling back to direct text input.\n");
+                    printf("Enter text to encrypt: ");
+                }
                 fflush(stdout);
                 
                 if (fgets(text_buffer, sizeof(text_buffer), stdin) == NULL) {
@@ -1344,8 +1167,10 @@ int encrypt_text(const char* pad_identifier, const char* input_text) {
             }
         } else {
             // Direct text input
-            printf("Enter text to encrypt: ");
+            if (is_interactive_mode) {
-            fflush(stdout);
+                printf("Enter text to encrypt: ");
+                fflush(stdout);
+            }
             
             if (fgets(text_buffer, sizeof(text_buffer), stdin) == NULL) {
                 printf("Error: Failed to read input\n");
@@ -1453,15 +1278,10 @@ int encrypt_text(const char* pad_identifier, const char* input_text) {
 }
 
 int decrypt_text(const char* pad_identifier, const char* encrypted_message) {
-    // Use universal decrypt function with interactive mode
+    // Use universal decrypt function with mode based on global interactive mode detection
     (void)pad_identifier; // Suppress unused parameter warning - chksum comes from message
-    return universal_decrypt(encrypted_message, NULL, DECRYPT_MODE_INTERACTIVE);
+    decrypt_mode_t mode = is_interactive_mode ? DECRYPT_MODE_INTERACTIVE : DECRYPT_MODE_SILENT;
-}
+    return universal_decrypt(encrypted_message, NULL, mode);
-
-int decrypt_text_silent(const char* pad_identifier, const char* encrypted_message) {
-    // Use universal decrypt function with silent mode
-    (void)pad_identifier; // Suppress unused parameter warning - chksum comes from message
-    return universal_decrypt(encrypted_message, NULL, DECRYPT_MODE_SILENT);
 }
 
 int encrypt_file(const char* pad_identifier, const char* input_file, const char* output_file, int ascii_armor) {
@@ -1938,16 +1758,12 @@ int write_state_offset(const char* pad_chksum, uint64_t offset) {
 }
 
 
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//      DIRECTORY MANAGEMENT FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
-
-
-
-
-
-
-
-
-// Directory management functions
 int ensure_pads_directory(void) {
     struct stat st = {0};
     if (stat(current_pads_dir, &st) == -1) {
@@ -1958,7 +1774,6 @@ int ensure_pads_directory(void) {
     return 0;
 }
 
-
 const char* get_files_directory(void) {
     struct stat st = {0};
     if (stat(FILES_DIR, &st) == 0 && S_ISDIR(st.st_mode)) {
@@ -2639,7 +2454,6 @@ int derive_chacha20_params(const unsigned char* entropy_data, size_t entropy_siz
     return 0; // Success
 }
 
-
 // Check if a pad is unused (0% usage)
 int is_pad_unused(const char* pad_chksum) {
     uint64_t used_bytes;
@@ -2649,7 +2463,6 @@ int is_pad_unused(const char* pad_chksum) {
     return (used_bytes <= 32); // Only reserved bytes used (32 bytes for checksum encryption)
 }
 
-
 // Safely rename pad files (pad and state) from old to new checksum
 int rename_pad_files_safely(const char* old_chksum, const char* new_chksum) {
     char old_pad_path[1024], new_pad_path[1024];
@@ -2865,7 +2678,6 @@ void restore_terminal(struct termios* original_termios) {
 
 
 
-
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 //      UNIVERSAL CORE FUNCTIONS FOR CODE CONSOLIDATION
@@ -2956,8 +2768,8 @@ int load_pad_data(const char* pad_chksum, uint64_t offset, size_t length, unsign
         return 1; // Error: null pointer
     }
     
-    char pad_path[MAX_HASH_LENGTH + 20];
+    char pad_path[1024];
-    char state_path[MAX_HASH_LENGTH + 20];
+    char state_path[1024];
     get_pad_path(pad_chksum, pad_path, state_path);
     
     // Check if pad file exists
@@ -3036,7 +2848,7 @@ int generate_ascii_armor(const char* chksum, uint64_t offset, const unsigned cha
     strcpy(*ascii_output, "-----BEGIN OTP MESSAGE-----\n");
     
     char temp_line[256];
-    snprintf(temp_line, sizeof(temp_line), "Version: v0.2.106\n");
+    snprintf(temp_line, sizeof(temp_line), "Version: v0.2.111\n");
     strcat(*ascii_output, temp_line);
     
     snprintf(temp_line, sizeof(temp_line), "Pad-ChkSum: %s\n", chksum);
@@ -3292,17 +3104,28 @@ int universal_decrypt(const char* input_data, const char* output_target, decrypt
             printf("Note: ASCII format does not preserve original filename/permissions\n");
         }
     } else {
-        // Text output to stdout
+        // Text output to stdout - need to allocate space for null terminator
-        ciphertext[ciphertext_len] = '\0';
+        char* decrypted_text = malloc(ciphertext_len + 1);
+        if (!decrypted_text) {
+            printf("Error: Memory allocation failed for output\n");
+            free(ciphertext);
+            free(pad_data);
+            return 1;
+        }
+        
+        memcpy(decrypted_text, ciphertext, ciphertext_len);
+        decrypted_text[ciphertext_len] = '\0';
         
         if (mode == DECRYPT_MODE_SILENT) {
             // Silent mode - just output the text
-            printf("%s\n", (char*)ciphertext);
+            printf("%s\n", decrypted_text);
             fflush(stdout);
         } else {
             // Interactive mode - with label
-            printf("Decrypted: %s\n", (char*)ciphertext);
+            printf("Decrypted: %s\n", decrypted_text);
         }
+        
+        free(decrypted_text);
     }
     
     // Cleanup
@@ -3506,7 +3329,6 @@ int get_filename_with_default(const char* prompt, const char* default_path, char
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-
 char* get_preferred_editor(void) {
     // Check EDITOR environment variable first
     char* editor = getenv("EDITOR");
@@ -3787,9 +3609,6 @@ int handle_file_encrypt(void) {
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 
-
-
-
 int calculate_checksum(const char* filename, char* checksum_hex) {
     FILE* file = fopen(filename, "rb");
     if (!file) {
@@ -3841,8 +3660,6 @@ int calculate_checksum(const char* filename, char* checksum_hex) {
     return 0;
 }
 
-
-
 // Unified pad selection function - extracts the best UI from handle_pads_menu()
 char* select_pad_interactive(const char* title, const char* prompt, pad_filter_type_t filter_type, int allow_cancel) {
     // Get list of pads from current directory
@@ -4054,26 +3871,17 @@ char* select_pad_interactive(const char* title, const char* prompt, pad_filter_t
         return NULL;
     }
     
-    // Find matching pad by prefix or number
+    // Find matching pad by prefix only
     int selected_pad = -1;
     int match_count = 0;
     
-    // Check if input is a number first
+    // Try prefix matching only
-    char* endptr;
+    for (int i = 0; i < pad_count; i++) {
-    int selection = strtol(input, &endptr, 10);
+        if (strncmp(input, pads[i].chksum, strlen(input)) == 0) {
-    if (*endptr == '\0' && selection >= 1 && selection <= pad_count) {
+            if (match_count == 0) {
-        // Valid number selection
+                selected_pad = i;
-        selected_pad = selection - 1;
-        match_count = 1;
-    } else {
-        // Try prefix matching
-        for (int i = 0; i < pad_count; i++) {
-            if (strncmp(input, pads[i].chksum, strlen(input)) == 0) {
-                if (match_count == 0) {
-                    selected_pad = i;
-                }
-                match_count++;
             }
+            match_count++;
         }
     }
     
@@ -4281,7 +4089,7 @@ int handle_pads_menu(void) {
     } else if (toupper(input[0]) == 'A') {
         // Add entropy to pad - use unified function with unused pads filter
         char* selected_pad = select_pad_interactive("=== Select Unused Pad for Entropy Addition ===",
-                                                  "Select unused pad (by prefix or number)",
+                                                  "Select unused pad (by prefix)",
                                                   PAD_FILTER_UNUSED_ONLY, 1);
         if (!selected_pad) {
             printf("Entropy addition cancelled.\n");
@@ -4586,7 +4394,7 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
 }
 
 void print_usage(const char* program_name) {
-    printf("OTP Cipher - One Time Pad Implementation v0.2.106\n");
+    printf("OTP Cipher - One Time Pad Implementation v0.2.111\n");
     printf("Built for testing entropy system\n");
     printf("Usage:\n");
     printf("  %s                                         - Interactive mode\n", program_name);
@@ -4611,5 +4419,5 @@ void print_usage(const char* program_name) {
     printf("  %s -g 1GB                                   - Generate 1GB pad\n", program_name);
     printf("  %s -l                                       - List pads\n", program_name);
     printf("\nSize examples: 1GB, 5TB, 512MB, 2048 (bytes)\n");
-    printf("Pad selection: Full chksum, prefix, or number from list\n");
+    printf("Pad selection: Full chksum or prefix\n");
 }

otp.h

@@ -0,0 +1,239 @@
+#ifndef OTP_H
+#define OTP_H
+
+////////////////////////////////////////////////////////////////////////////////
+//      OTP CIPHER - FUNCTION PROTOTYPES HEADER
+//      One Time Pad Implementation v0.2.109
+//      
+//      This header file contains all function prototypes extracted from otp.c
+//      Organized by functional categories for better maintainability
+////////////////////////////////////////////////////////////////////////////////
+
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <termios.h>
+#include <sys/stat.h>
+#include <time.h>
+
+// Constants
+#define MAX_INPUT_SIZE 4096
+#define MAX_LINE_LENGTH 1024
+#define MAX_HASH_LENGTH 65
+#define PROGRESS_UPDATE_INTERVAL (64 * 1024 * 1024)  // 64MB intervals
+#define DEFAULT_PADS_DIR "pads"
+#define FILES_DIR "files"
+#define MAX_ENTROPY_BUFFER 32768  // 32KB entropy buffer
+
+////////////////////////////////////////////////////////////////////////////////
+//      TYPE DEFINITIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// Decrypt operation modes for universal decrypt function
+typedef enum {
+    DECRYPT_MODE_INTERACTIVE,    // Interactive text decryption with prompts
+    DECRYPT_MODE_SILENT,         // Silent text decryption (no prompts/labels)
+    DECRYPT_MODE_FILE_TO_TEXT,   // File to text output with prompts
+    DECRYPT_MODE_FILE_TO_FILE    // File to file output (binary)
+} decrypt_mode_t;
+
+// Pad filter types for selection functions
+typedef enum {
+    PAD_FILTER_ALL,           // Show all pads
+    PAD_FILTER_UNUSED_ONLY    // Show only unused pads (0% usage)
+} pad_filter_type_t;
+
+// Enhanced entropy system state structure
+typedef struct {
+    size_t target_bytes;           // Target entropy to collect
+    size_t collected_bytes;        // Bytes collected so far
+    size_t unique_keys;           // Number of unique keys pressed
+    double collection_start_time; // Start timestamp
+    double last_keypress_time;    // Last keypress timestamp
+    unsigned char quality_score;  // Entropy quality (0-100)
+    int auto_complete_enabled;    // Allow auto-complete at minimum
+    unsigned char key_histogram[256]; // Track key frequency
+} entropy_collection_state_t;
+
+////////////////////////////////////////////////////////////////////////////////
+//      CORE APPLICATION FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// Main application entry points
+int main(int argc, char* argv[]);
+int interactive_mode(void);
+int command_line_mode(int argc, char* argv[]);
+int pipe_mode(int argc, char* argv[], const char* piped_text);
+
+////////////////////////////////////////////////////////////////////////////////
+//      INPUT/OUTPUT DETECTION FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// Stdin detection functions
+int has_stdin_data(void);
+char* read_stdin_text(void);
+
+////////////////////////////////////////////////////////////////////////////////
+//      PREFERENCES MANAGEMENT FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// Configuration and preferences handling
+int load_preferences(void);
+int save_preferences(void);
+char* get_preference(const char* key);
+int set_preference(const char* key, const char* value);
+char* get_default_pad_path(void);
+int set_default_pad_path(const char* pad_path);
+
+////////////////////////////////////////////////////////////////////////////////
+//      HARDWARE DETECTION FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// OTP thumb drive detection function
+int detect_otp_thumb_drive(char* otp_drive_path, size_t path_size);
+
+////////////////////////////////////////////////////////////////////////////////
+//      EXTERNAL TOOL INTEGRATION FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// Editor and file manager functions
+char* get_preferred_editor(void);
+char* get_preferred_file_manager(void);
+int launch_text_editor(const char* initial_content, char* result_buffer, size_t buffer_size);
+int launch_file_manager(const char* start_directory, char* selected_file, size_t buffer_size);
+
+////////////////////////////////////////////////////////////////////////////////
+//      CORE CRYPTOGRAPHIC OPERATIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// Primary encryption/decryption functions
+int generate_pad(uint64_t size_bytes, int show_progress);
+int encrypt_text(const char* pad_identifier, const char* input_text);
+int decrypt_text(const char* pad_identifier, const char* encrypted_message);
+int encrypt_file(const char* pad_identifier, const char* input_file, const char* output_file, int ascii_armor);
+int decrypt_file(const char* input_file, const char* output_file);
+int decrypt_binary_file(FILE* input_fp, const char* output_file);
+int decrypt_ascii_file(const char* input_file, const char* output_file);
+
+////////////////////////////////////////////////////////////////////////////////
+//      ENHANCED ENTROPY SYSTEM FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// Terminal control for entropy collection
+int setup_raw_terminal(struct termios* original_termios);
+void restore_terminal(struct termios* original_termios);
+
+// Entropy collection and feedback
+int collect_entropy_with_feedback(unsigned char* entropy_buffer, size_t target_bytes,
+                                 size_t* collected_bytes, int allow_early_exit);
+void display_entropy_progress(const entropy_collection_state_t* state);
+void draw_progress_bar(double percentage, int width);
+void draw_quality_bar(double quality, int width, const char* label);
+
+// Entropy quality calculation
+double calculate_timing_quality(const entropy_collection_state_t* state);
+double calculate_variety_quality(const entropy_collection_state_t* state);
+unsigned char calculate_overall_quality(const entropy_collection_state_t* state);
+double get_precise_time(void);
+
+// Entropy processing and application
+int derive_chacha20_params(const unsigned char* entropy_data, size_t entropy_size,
+                          unsigned char key[32], unsigned char nonce[12]);
+int add_entropy_to_pad(const char* pad_chksum, const unsigned char* entropy_data,
+                      size_t entropy_size, int show_progress);
+int handle_add_entropy_to_pad(const char* pad_chksum);
+
+// Enhanced entropy system helper functions
+int update_pad_checksum_after_entropy(const char* old_chksum, char* new_chksum);
+int rename_pad_files_safely(const char* old_chksum, const char* new_chksum);
+int is_pad_unused(const char* pad_chksum);
+
+////////////////////////////////////////////////////////////////////////////////
+//      DIRECTORY MANAGEMENT FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// Directory handling and path management
+int ensure_pads_directory(void);
+void get_pad_path(const char* chksum, char* pad_path, char* state_path);
+const char* get_files_directory(void);
+void get_default_file_path(const char* filename, char* result_path, size_t result_size);
+void get_directory_display(const char* file_path, char* result, size_t result_size);
+
+////////////////////////////////////////////////////////////////////////////////
+//      UTILITY FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// General utility and helper functions
+uint64_t parse_size_string(const char* size_str);
+char* find_pad_by_prefix(const char* prefix);
+int show_pad_info(const char* chksum);
+void show_progress(uint64_t current, uint64_t total, time_t start_time);
+
+////////////////////////////////////////////////////////////////////////////////
+//      FILE OPERATIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// File state and checksum operations
+int read_state_offset(const char* pad_chksum, uint64_t* offset);
+int write_state_offset(const char* pad_chksum, uint64_t offset);
+int calculate_checksum(const char* filename, char* checksum_hex);
+
+////////////////////////////////////////////////////////////////////////////////
+//      UNIVERSAL CORE FUNCTIONS FOR CODE CONSOLIDATION
+////////////////////////////////////////////////////////////////////////////////
+
+// Consolidated cryptographic operations
+int universal_xor_operation(const unsigned char* data, size_t data_len,
+                           const unsigned char* pad_data, unsigned char* result);
+int parse_ascii_message(const char* message, char* chksum, uint64_t* offset, char* base64_data);
+int load_pad_data(const char* pad_chksum, uint64_t offset, size_t length, unsigned char** pad_data);
+int generate_ascii_armor(const char* chksum, uint64_t offset, const unsigned char* encrypted_data,
+                        size_t data_length, char** ascii_output);
+int validate_pad_integrity(const char* pad_path, const char* expected_chksum);
+
+// Universal decrypt function - consolidates all decrypt operations
+int universal_decrypt(const char* input_data, const char* output_target, decrypt_mode_t mode);
+
+////////////////////////////////////////////////////////////////////////////////
+//      BASE64 ENCODING FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// Custom base64 implementation
+char* custom_base64_encode(const unsigned char* input, int length);
+unsigned char* custom_base64_decode(const char* input, int* output_length);
+
+////////////////////////////////////////////////////////////////////////////////
+//      MENU SYSTEM FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// Interactive menu interface functions
+void show_main_menu(void);
+int handle_generate_menu(void);
+int handle_encrypt_menu(void);
+int handle_decrypt_menu(void);
+int handle_pads_menu(void);
+int handle_text_encrypt(void);
+int handle_file_encrypt(void);
+
+////////////////////////////////////////////////////////////////////////////////
+//      ENHANCED INPUT FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// Advanced input handling
+int get_filename_with_default(const char* prompt, const char* default_path, char* result, size_t result_size);
+
+////////////////////////////////////////////////////////////////////////////////
+//      PAD SELECTION FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// Unified pad selection interface
+char* select_pad_interactive(const char* title, const char* prompt, pad_filter_type_t filter_type, int allow_cancel);
+
+////////////////////////////////////////////////////////////////////////////////
+//      USAGE AND HELP FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// Help and usage display
+void print_usage(const char* program_name);
+
+#endif // OTP_H