Version v0.3.4 - Checking build.sh

.gitignore

@@ -1,6 +1,8 @@
 otp
 pads/
+files/
 Gemini.md
 TropicOfCancer-HenryMiller.txt
+.gitea_token
 
 # Auto-generated files (none currently)

build.sh

@@ -150,38 +150,153 @@ update_source_version() {
     fi
 }
 
-# Build functions
-build_project() {
-    print_status "Cleaning previous build..."
-    make clean
-    increment_version
-    print_status "Building OTP project..."
-    make
+# Cross-platform build functions
+check_cross_compiler() {
+    if ! command -v aarch64-linux-gnu-gcc > /dev/null 2>&1; then
+        print_error "ARM64/AArch64 cross-compiler not found!"
+        print_error "Install with: sudo apt install gcc-aarch64-linux-gnu"
+        print_error "Or on other distros: gcc-cross-aarch64"
+        return 1
+    fi
+    return 0
+}
+
+upload_release_asset() {
+    local api_url="$1"
+    local token="$2"
+    local version="$3"
+    local filename="$4"
+    
+    if [ ! -f "$filename" ]; then
+        print_warning "Binary $filename not found, skipping upload"
+        return 1
+    fi
+    
+    print_status "Uploading $filename to release..."
+    
+    # Get release ID first
+    local release_id=$(curl -s -H "Authorization: token $token" \
+                       "$api_url/releases/tags/$version" | \
+                       grep -o '"id":[0-9]*' | head -n1 | cut -d: -f2)
+    
+    if [ -z "$release_id" ]; then
+        print_error "Could not get release ID for $version"
+        return 1
+    fi
+    
+    # Upload the asset
+    curl -X POST "$api_url/releases/$release_id/assets" \
+         -H "Authorization: token $token" \
+         -H "Content-Type: application/octet-stream" \
+         -T "$filename" \
+         --data-binary "@$filename" \
+         -G -d "name=$filename"
+    
     if [ $? -eq 0 ]; then
-        print_success "Build completed successfully"
+        print_success "Uploaded $filename successfully"
     else
-        print_error "Build failed"
+        print_warning "Failed to upload $filename"
         return 1
     fi
 }
 
-build_static() {
+create_gitea_release() {
+    local version="$1"
+    
+    # Read token from ~/.gitea_token
+    if [ ! -f "$HOME/.gitea_token" ]; then
+        print_error "No ~/.gitea_token found. Cannot create release."
+        print_error "Create ~/.gitea_token with your Gitea access token"
+        return 1
+    fi
+    
+    local token=$(cat "$HOME/.gitea_token" | tr -d '\n\r')
+    local api_url="https://git.laantungir.net/api/v1/repos/laantungir/otp"
+    
+    print_status "Creating Gitea release for $version..."
+    
+    # Create release
+    local response=$(curl -s -X POST "$api_url/releases" \
+         -H "Authorization: token $token" \
+         -H "Content-Type: application/json" \
+         -d "{\"tag_name\": \"$version\", \"name\": \"$version\", \"body\": \"Automated release for $version\"}")
+    
+    if echo "$response" | grep -q '"id"'; then
+        print_success "Created release $version"
+        
+        # Upload binaries
+        upload_release_asset "$api_url" "$token" "$version" "otp-x86_64"
+        upload_release_asset "$api_url" "$token" "$version" "otp-arm64"
+    else
+        print_warning "Release may already exist or creation failed"
+        print_status "Response: $response"
+        
+        # Try to upload to existing release anyway
+        upload_release_asset "$api_url" "$token" "$version" "otp-x86_64"
+        upload_release_asset "$api_url" "$token" "$version" "otp-arm64"
+    fi
+}
+
+build_project() {
     print_status "Cleaning previous build..."
     make clean
     increment_version
-    print_status "Building OTP project with static linking..."
-    make static
+    
+    # Check for cross-compiler
+    if ! check_cross_compiler; then
+        print_warning "ARM64/AArch64 cross-compiler not available, building x86_64 only"
+        
+        # Build x86_64 only
+        print_status "Building OTP project for x86_64..."
+        make CC=gcc
         if [ $? -eq 0 ]; then
-        print_success "Static build completed successfully"
+            mv otp otp-x86_64
+            print_success "x86_64 build completed successfully"
         else
-        print_error "Static build failed"
+            print_error "x86_64 build failed"
             return 1
         fi
+    else
+        # Build both architectures
+        print_status "Building OTP project for x86_64..."
+        make clean
+        make CC=gcc
+        if [ $? -eq 0 ]; then
+            mv otp otp-x86_64
+            print_success "x86_64 build completed successfully"
+        else
+            print_error "x86_64 build failed"
+            return 1
+        fi
+        
+        print_status "Building OTP project for ARM64/AArch64..."
+        make clean
+        make CC=aarch64-linux-gnu-gcc
+        if [ $? -eq 0 ]; then
+            mv otp otp-arm64
+            print_success "ARM64/AArch64 build completed successfully"
+        else
+            print_error "ARM64/AArch64 build failed"
+            return 1
+        fi
+    fi
+    
+    # Create Gitea release with binaries
+    if [ -f "$HOME/.gitea_token" ]; then
+        create_gitea_release "$NEW_VERSION"
+    else
+        print_warning "No ~/.gitea_token found. Skipping release creation."
+        print_warning "Create ~/.gitea_token with your Gitea access token to enable releases."
+    fi
+    
+    print_success "Build completed successfully"
 }
 
 clean_project() {
     print_status "Cleaning build artifacts..."
     make clean
+    # Remove cross-compiled binaries
+    rm -f otp-x86_64 otp-arm64
     print_success "Clean completed"
 }
 
@@ -212,9 +327,6 @@ case "${1:-build}" in
     build)
         build_project
         ;;
-    static)
-        build_static
-        ;;
     clean)
         clean_project
         ;;
@@ -226,22 +338,29 @@ case "${1:-build}" in
         ;;
     *)
         echo "OTP Cipher Build Script"
-        echo "Usage: $0 [-m \"commit message\"] {build|static|clean|install|uninstall}"
+        echo "Usage: $0 [-m \"commit message\"] {build|clean|install|uninstall}"
         echo ""
         echo "Options:"
         echo "  -m, --message \"text\"  - Specify commit message (skips interactive prompt)"
         echo ""
         echo "Commands:"
-        echo "  build     - Build project with automatic version increment (default)"
-        echo "  static    - Build with static linking and version increment"
-        echo "  clean     - Clean build artifacts"
+        echo "  build     - Cross-compile for x86_64 and ARM64/AArch64 with automatic version increment (default)"
+        echo "  clean     - Clean build artifacts and cross-compiled binaries"
         echo "  install   - Install to system (requires build first)"
         echo "  uninstall - Remove from system"
         echo ""
+        echo "Build Output:"
+        echo "  otp-x86_64  - Native x86_64 binary"
+        echo "  otp-arm64   - ARM64/AArch64 binary for Raspberry Pi (if cross-compiler available)"
+        echo ""
+        echo "Gitea Integration:"
+        echo "  - Automatically creates releases with binaries if ~/.gitea_token exists"
+        echo "  - Requires: ARM64 cross-compiler (gcc-aarch64-linux-gnu)"
+        echo ""
         echo "Examples:"
         echo "  $0"
         echo "  $0 -m \"Fixed checksum parsing bug\""
-        echo "  $0 --message \"Added new feature\" static"
+        echo "  $0 --message \"Added new feature\" build"
         exit 1
         ;;
 esac

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
-    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 VARIABLES
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
-// 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] = "";
-
-// 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);
-
-
+static int is_interactive_mode = 0;
 
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
@@ -197,19 +65,14 @@ int main(int argc, char* argv[]) {
     // Load preferences first
     load_preferences();
     
-    // Check for piped input first (before any output)
-    int is_pipe_mode = (argc == 1 && has_stdin_data());
-    
-    // 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());
+    // Detect interactive mode: only true when running with no arguments
+    is_interactive_mode = (argc == 1);
     
     // 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
-        if (!is_pipe_mode && !is_decrypt_pipe) {
+        // Only show messages in interactive mode
+        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) {
-        // 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) {
+    if (is_interactive_mode) {
         return interactive_mode();
     } else {
         return command_line_mode(argc, argv);
@@ -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 v1.0.0 ===========================\n\n");
+    printf("\n=========================== Main Menu - OTP v0.3.3 ===========================\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
-    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;
-                }
-            }
-        }
-    }
+    // Only prefix matching is supported
     
     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);
-        fflush(stdout);
+        printf("Please be more specific with your prefix.\n");
         
-        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
+        // Free all matches and return NULL
         for (int i = 0; i < match_count; i++) {
             free(matches[i]);
         }
@@ -1249,6 +1068,15 @@ int add_entropy_to_pad(const char* pad_chksum, const unsigned char* entropy_data
     return 0;
 }
 
+
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//      ENCRYPT AND DECRYPT
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+
 int encrypt_text(const char* pad_identifier, const char* input_text) {
     char* pad_chksum = find_pad_by_prefix(pad_identifier);
     if (!pad_chksum) {
@@ -1300,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)
+        if (is_interactive_mode) {
             printf("\nText input options:\n");
             printf(" 1. Type text directly\n");
             printf(" 2. Use text editor\n");
             printf("Enter choice (1-2): ");
+        }
         
-        char input_choice[10];
+        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 (atoi(input_choice) == 2) {
+        if (is_interactive_mode && atoi(input_choice) == 2) {
             // Use text editor
             if (launch_text_editor(NULL, text_buffer, sizeof(text_buffer)) != 0) {
+                if (is_interactive_mode) {
                     printf("Falling back to direct text input.\n");
                     printf("Enter text to encrypt: ");
+                }
                 fflush(stdout);
                 
                 if (fgets(text_buffer, sizeof(text_buffer), stdin) == NULL) {
@@ -1333,8 +1167,10 @@ int encrypt_text(const char* pad_identifier, const char* input_text) {
             }
         } else {
             // Direct text input
+            if (is_interactive_mode) {
                 printf("Enter text to encrypt: ");
                 fflush(stdout);
+            }
             
             if (fgets(text_buffer, sizeof(text_buffer), stdin) == NULL) {
                 printf("Error: Failed to read input\n");
@@ -1442,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);
-}
-
-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);
+    decrypt_mode_t mode = is_interactive_mode ? DECRYPT_MODE_INTERACTIVE : DECRYPT_MODE_SILENT;
+    return universal_decrypt(encrypted_message, NULL, mode);
 }
 
 int encrypt_file(const char* pad_identifier, const char* input_file, const char* output_file, int ascii_armor) {
@@ -1926,193 +1757,13 @@ int write_state_offset(const char* pad_chksum, uint64_t offset) {
     return 0;
 }
 
-int calculate_checksum(const char* filename, char* checksum_hex) {
-    FILE* file = fopen(filename, "rb");
-    if (!file) {
-        return 1;
-    }
 
-    unsigned char checksum[32];
-    unsigned char buffer[64 * 1024];  // 64KB buffer for large files
-    size_t bytes_read;
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//      DIRECTORY MANAGEMENT FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
-    // Initialize checksum
-    memset(checksum, 0, 32);
-    size_t total_bytes = 0;
-    
-    // Calculate XOR checksum of entire file
-    while ((bytes_read = fread(buffer, 1, sizeof(buffer), file)) > 0) {
-        // Process this chunk with XOR checksum
-        for (size_t i = 0; i < bytes_read; i++) {
-            unsigned char bucket = (total_bytes + i) % 32;
-            checksum[bucket] ^= buffer[i] ^ (((total_bytes + i) >> 8) & 0xFF) ^ 
-                               (((total_bytes + i) >> 16) & 0xFF) ^ (((total_bytes + i) >> 24) & 0xFF);
-        }
-        total_bytes += bytes_read;
-    }
-    
-    fclose(file);
-    
-    // Now encrypt the checksum with the first 32 bytes of the pad
-    fseek(file = fopen(filename, "rb"), 0, SEEK_SET);
-    unsigned char pad_key[32];
-    if (fread(pad_key, 1, 32, file) != 32) {
-        fclose(file);
-        return 1;
-    }
-    fclose(file);
-    
-    // XOR encrypt the checksum with pad data to create unique identifier
-    unsigned char encrypted_checksum[32];
-    for (int i = 0; i < 32; i++) {
-        encrypted_checksum[i] = checksum[i] ^ pad_key[i];
-    }
-    
-    // Convert to hex string (64 characters)
-    for (int i = 0; i < 32; i++) {
-        sprintf(checksum_hex + (i * 2), "%02x", encrypted_checksum[i]);
-    }
-    checksum_hex[64] = '\0';
-    
-    return 0;
-}
-
-// Keyboard entropy functions
-int setup_raw_terminal(struct termios* original_termios) {
-    struct termios new_termios;
-    
-    if (tcgetattr(STDIN_FILENO, original_termios) != 0) {
-        return 1;
-    }
-    
-    new_termios = *original_termios;
-    new_termios.c_lflag &= ~(ICANON | ECHO);
-    new_termios.c_cc[VMIN] = 0;
-    new_termios.c_cc[VTIME] = 0;
-    
-    if (tcsetattr(STDIN_FILENO, TCSANOW, &new_termios) != 0) {
-        return 1;
-    }
-    
-    // Set stdin to non-blocking
-    int flags = fcntl(STDIN_FILENO, F_GETFL);
-    if (fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK) == -1) {
-        tcsetattr(STDIN_FILENO, TCSANOW, original_termios);
-        return 1;
-    }
-    
-    return 0;
-}
-
-void restore_terminal(struct termios* original_termios) {
-    tcsetattr(STDIN_FILENO, TCSANOW, original_termios);
-    
-    // Reset stdin to blocking
-    int flags = fcntl(STDIN_FILENO, F_GETFL);
-    fcntl(STDIN_FILENO, F_SETFL, flags & ~O_NONBLOCK);
-}
-
-// Enhanced entropy collection with visual feedback
-int collect_entropy_with_feedback(unsigned char* entropy_buffer, size_t target_bytes,
-                                 size_t* collected_bytes, int allow_early_exit) {
-    struct termios original_termios;
-    entropy_collection_state_t state = {0};
-    
-    // Initialize state
-    state.target_bytes = target_bytes;
-    state.auto_complete_enabled = allow_early_exit;
-    state.collection_start_time = get_precise_time();
-    
-    // Setup raw terminal
-    if (setup_raw_terminal(&original_termios) != 0) {
-        printf("Error: Cannot setup terminal for entropy collection\n");
-        return 1;
-    }
-    
-    // Clear screen area for display
-    printf("\n\n\n\n\n\n");
-    
-    unsigned char entropy_block[16];
-    struct timespec timestamp;
-    uint32_t sequence_counter = 0;
-    char key;
-    unsigned char seen_keys[256] = {0};
-    
-    *collected_bytes = 0;
-    
-    while (state.collected_bytes < target_bytes) {
-        // Update display
-        state.quality_score = calculate_overall_quality(&state);
-        display_entropy_progress(&state);
-        
-        // Non-blocking read
-        if (read(STDIN_FILENO, &key, 1) == 1) {
-            // Handle ESC key for early exit
-            if (key == 27 && allow_early_exit && state.collected_bytes >= 1024) {
-                break; // Early exit allowed
-            }
-            
-            // Record keypress timing
-            double current_time = get_precise_time();
-            state.last_keypress_time = current_time;
-            
-            // Update key histogram
-            state.key_histogram[(unsigned char)key]++;
-            
-            // Get high precision timestamp
-            clock_gettime(CLOCK_MONOTONIC, &timestamp);
-            
-            // Create enhanced entropy block: [key][timestamp][sequence][quality_bits]
-            entropy_block[0] = key;
-            memcpy(&entropy_block[1], &timestamp.tv_sec, 8);
-            memcpy(&entropy_block[9], &timestamp.tv_nsec, 4);
-            memcpy(&entropy_block[13], &sequence_counter, 2);
-            entropy_block[15] = (unsigned char)(current_time * 1000) & 0xFF; // Sub-millisecond timing
-            
-            // Add to entropy buffer
-            if (state.collected_bytes + 16 <= MAX_ENTROPY_BUFFER) {
-                memcpy(entropy_buffer + state.collected_bytes, entropy_block, 16);
-                state.collected_bytes += 16;
-            }
-            
-            sequence_counter++;
-            
-            // Track unique keys
-            if (!seen_keys[(unsigned char)key]) {
-                seen_keys[(unsigned char)key] = 1;
-                state.unique_keys++;
-            }
-        } else {
-            // No key available, just sleep and wait for keystrokes
-            usleep(10000); // 10ms delay - wait for keystrokes, don't add timing entropy
-        }
-        
-        // Auto-complete at target if enabled
-        if (state.collected_bytes >= target_bytes) {
-            break;
-        }
-    }
-    
-    // Final display update
-    state.quality_score = calculate_overall_quality(&state);
-    display_entropy_progress(&state);
-    
-    // Summary
-    double collection_time = get_precise_time() - state.collection_start_time;
-    printf("\n\n✓ Entropy collection complete!\n");
-    printf("  Collected: %zu bytes in %.1f seconds\n", state.collected_bytes, collection_time);
-    printf("  Quality: %d%% (Excellent: 80%%+, Good: 60%%+)\n", state.quality_score);
-    printf("  Unique keys: %zu\n", state.unique_keys);
-    
-    // Restore terminal
-    restore_terminal(&original_termios);
-    
-    *collected_bytes = state.collected_bytes;
-    return 0;
-}
-
-
-// Directory management functions
 int ensure_pads_directory(void) {
     struct stat st = {0};
     if (stat(current_pads_dir, &st) == -1) {
@@ -2123,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)) {
@@ -2599,7 +2249,14 @@ unsigned char* custom_base64_decode(const char* input, int* output_length) {
     return decoded;
 }
 
-// Enhanced entropy system implementation
+
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//      ADD ENTROPY
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
 
 double get_precise_time(void) {
     struct timespec ts;
@@ -2797,8 +2454,6 @@ int derive_chacha20_params(const unsigned char* entropy_data, size_t entropy_siz
     return 0; // Success
 }
 
-// Enhanced entropy system helper functions
-
 // Check if a pad is unused (0% usage)
 int is_pad_unused(const char* pad_chksum) {
     uint64_t used_bytes;
@@ -2808,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];
@@ -2888,6 +2542,142 @@ int update_pad_checksum_after_entropy(const char* old_chksum, char* new_chksum)
     return 0; // Success
 }
 
+// Enhanced entropy collection with visual feedback
+int collect_entropy_with_feedback(unsigned char* entropy_buffer, size_t target_bytes,
+                                 size_t* collected_bytes, int allow_early_exit) {
+    struct termios original_termios;
+    entropy_collection_state_t state = {0};
+    
+    // Initialize state
+    state.target_bytes = target_bytes;
+    state.auto_complete_enabled = allow_early_exit;
+    state.collection_start_time = get_precise_time();
+    
+    // Setup raw terminal
+    if (setup_raw_terminal(&original_termios) != 0) {
+        printf("Error: Cannot setup terminal for entropy collection\n");
+        return 1;
+    }
+    
+    // Clear screen area for display
+    printf("\n\n\n\n\n\n");
+    
+    unsigned char entropy_block[16];
+    struct timespec timestamp;
+    uint32_t sequence_counter = 0;
+    char key;
+    unsigned char seen_keys[256] = {0};
+    
+    *collected_bytes = 0;
+    
+    while (state.collected_bytes < target_bytes) {
+        // Update display
+        state.quality_score = calculate_overall_quality(&state);
+        display_entropy_progress(&state);
+        
+        // Non-blocking read
+        if (read(STDIN_FILENO, &key, 1) == 1) {
+            // Handle ESC key for early exit
+            if (key == 27 && allow_early_exit && state.collected_bytes >= 1024) {
+                break; // Early exit allowed
+            }
+            
+            // Record keypress timing
+            double current_time = get_precise_time();
+            state.last_keypress_time = current_time;
+            
+            // Update key histogram
+            state.key_histogram[(unsigned char)key]++;
+            
+            // Get high precision timestamp
+            clock_gettime(CLOCK_MONOTONIC, &timestamp);
+            
+            // Create enhanced entropy block: [key][timestamp][sequence][quality_bits]
+            entropy_block[0] = key;
+            memcpy(&entropy_block[1], &timestamp.tv_sec, 8);
+            memcpy(&entropy_block[9], &timestamp.tv_nsec, 4);
+            memcpy(&entropy_block[13], &sequence_counter, 2);
+            entropy_block[15] = (unsigned char)(current_time * 1000) & 0xFF; // Sub-millisecond timing
+            
+            // Add to entropy buffer
+            if (state.collected_bytes + 16 <= MAX_ENTROPY_BUFFER) {
+                memcpy(entropy_buffer + state.collected_bytes, entropy_block, 16);
+                state.collected_bytes += 16;
+            }
+            
+            sequence_counter++;
+            
+            // Track unique keys
+            if (!seen_keys[(unsigned char)key]) {
+                seen_keys[(unsigned char)key] = 1;
+                state.unique_keys++;
+            }
+        } else {
+            // No key available, just sleep and wait for keystrokes
+            usleep(10000); // 10ms delay - wait for keystrokes, don't add timing entropy
+        }
+        
+        // Auto-complete at target if enabled
+        if (state.collected_bytes >= target_bytes) {
+            break;
+        }
+    }
+    
+    // Final display update
+    state.quality_score = calculate_overall_quality(&state);
+    display_entropy_progress(&state);
+    
+    // Summary
+    double collection_time = get_precise_time() - state.collection_start_time;
+    printf("\n\n✓ Entropy collection complete!\n");
+    printf("  Collected: %zu bytes in %.1f seconds\n", state.collected_bytes, collection_time);
+    printf("  Quality: %d%% (Excellent: 80%%+, Good: 60%%+)\n", state.quality_score);
+    printf("  Unique keys: %zu\n", state.unique_keys);
+    
+    // Restore terminal
+    restore_terminal(&original_termios);
+    
+    *collected_bytes = state.collected_bytes;
+    return 0;
+}
+
+// Keyboard entropy functions
+int setup_raw_terminal(struct termios* original_termios) {
+    struct termios new_termios;
+    
+    if (tcgetattr(STDIN_FILENO, original_termios) != 0) {
+        return 1;
+    }
+    
+    new_termios = *original_termios;
+    new_termios.c_lflag &= ~(ICANON | ECHO);
+    new_termios.c_cc[VMIN] = 0;
+    new_termios.c_cc[VTIME] = 0;
+    
+    if (tcsetattr(STDIN_FILENO, TCSANOW, &new_termios) != 0) {
+        return 1;
+    }
+    
+    // Set stdin to non-blocking
+    int flags = fcntl(STDIN_FILENO, F_GETFL);
+    if (fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK) == -1) {
+        tcsetattr(STDIN_FILENO, TCSANOW, original_termios);
+        return 1;
+    }
+    
+    return 0;
+}
+
+void restore_terminal(struct termios* original_termios) {
+    tcsetattr(STDIN_FILENO, TCSANOW, original_termios);
+    
+    // Reset stdin to blocking
+    int flags = fcntl(STDIN_FILENO, F_GETFL);
+    fcntl(STDIN_FILENO, F_SETFL, flags & ~O_NONBLOCK);
+}
+
+
+
 ////////////////////////////////////////////////////////////////////////////////
 ////////////////////////////////////////////////////////////////////////////////
 //      UNIVERSAL CORE FUNCTIONS FOR CODE CONSOLIDATION
@@ -2978,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 state_path[MAX_HASH_LENGTH + 20];
+    char pad_path[1024];
+    char state_path[1024];
     get_pad_path(pad_chksum, pad_path, state_path);
     
     // Check if pad file exists
@@ -3058,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: v1.0.0\n");
+    snprintf(temp_line, sizeof(temp_line), "Version: v0.3.3\n");
     strcat(*ascii_output, temp_line);
     
     snprintf(temp_line, sizeof(temp_line), "Pad-ChkSum: %s\n", chksum);
@@ -3314,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
-        ciphertext[ciphertext_len] = '\0';
+        // Text output to stdout - need to allocate space for null terminator
+        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
@@ -3522,7 +3323,11 @@ int get_filename_with_default(const char* prompt, const char* default_path, char
     return 0;
 }
 
-// Editor and file manager implementations
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//      EDITOR AND FILE MANAGER
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
 
 char* get_preferred_editor(void) {
     // Check EDITOR environment variable first
@@ -3797,6 +3602,64 @@ int handle_file_encrypt(void) {
 }
 
 
+
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+//      PADS
+////////////////////////////////////////////////////////////////////////////////
+////////////////////////////////////////////////////////////////////////////////
+
+int calculate_checksum(const char* filename, char* checksum_hex) {
+    FILE* file = fopen(filename, "rb");
+    if (!file) {
+        return 1;
+    }
+    
+    unsigned char checksum[32];
+    unsigned char buffer[64 * 1024];  // 64KB buffer for large files
+    size_t bytes_read;
+    
+    // Initialize checksum
+    memset(checksum, 0, 32);
+    size_t total_bytes = 0;
+    
+    // Calculate XOR checksum of entire file
+    while ((bytes_read = fread(buffer, 1, sizeof(buffer), file)) > 0) {
+        // Process this chunk with XOR checksum
+        for (size_t i = 0; i < bytes_read; i++) {
+            unsigned char bucket = (total_bytes + i) % 32;
+            checksum[bucket] ^= buffer[i] ^ (((total_bytes + i) >> 8) & 0xFF) ^ 
+                               (((total_bytes + i) >> 16) & 0xFF) ^ (((total_bytes + i) >> 24) & 0xFF);
+        }
+        total_bytes += bytes_read;
+    }
+    
+    fclose(file);
+    
+    // Now encrypt the checksum with the first 32 bytes of the pad
+    fseek(file = fopen(filename, "rb"), 0, SEEK_SET);
+    unsigned char pad_key[32];
+    if (fread(pad_key, 1, 32, file) != 32) {
+        fclose(file);
+        return 1;
+    }
+    fclose(file);
+    
+    // XOR encrypt the checksum with pad data to create unique identifier
+    unsigned char encrypted_checksum[32];
+    for (int i = 0; i < 32; i++) {
+        encrypted_checksum[i] = checksum[i] ^ pad_key[i];
+    }
+    
+    // Convert to hex string (64 characters)
+    for (int i = 0; i < 32; i++) {
+        sprintf(checksum_hex + (i * 2), "%02x", encrypted_checksum[i]);
+    }
+    checksum_hex[64] = '\0';
+    
+    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
@@ -4008,19 +3871,11 @@ 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
-    char* endptr;
-    int selection = strtol(input, &endptr, 10);
-    if (*endptr == '\0' && selection >= 1 && selection <= pad_count) {
-        // Valid number selection
-        selected_pad = selection - 1;
-        match_count = 1;
-    } else {
-        // Try prefix matching
+    // Try prefix matching only
     for (int i = 0; i < pad_count; i++) {
         if (strncmp(input, pads[i].chksum, strlen(input)) == 0) {
             if (match_count == 0) {
@@ -4029,7 +3884,6 @@ char* select_pad_interactive(const char* title, const char* prompt, pad_filter_t
             match_count++;
         }
     }
-    }
     
     if (match_count == 0) {
         printf("No pad found matching '%s'\n", input);
@@ -4235,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");
@@ -4540,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 v1.0.0\n");
+    printf("OTP Cipher - One Time Pad Implementation v0.3.3\n");
     printf("Built for testing entropy system\n");
     printf("Usage:\n");
     printf("  %s                                         - Interactive mode\n", program_name);
@@ -4565,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