Version v0.2.108 - Fixed piping issues

otp.c

@@ -58,6 +58,9 @@ static char current_pads_dir[512] = DEFAULT_PADS_DIR;
 // Global variable for default pad path from preferences
 static char default_pad_path[1024] = "";
 
+// Global variable for pipe mode detection
+static int is_pipe_mode = 0;
+
 // Function prototypes
 int main(int argc, char* argv[]);
 int interactive_mode(void);
@@ -89,7 +92,6 @@ int launch_file_manager(const char* start_directory, char* selected_file, size_t
 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);
@@ -197,8 +199,8 @@ 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 all forms of piped input first (before any output)
+    is_pipe_mode = (argc == 1 && has_stdin_data()) || has_stdin_data();
     
     // Check for decrypt command with piped input
     int is_decrypt_pipe = (argc == 2 &&
@@ -208,7 +210,7 @@ int main(int argc, char* argv[]) {
     // 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 non-pipe mode
         if (!is_pipe_mode && !is_decrypt_pipe) {
             printf("Detected OTP thumb drive: %s\n", otp_drive_path);
             printf("Using as default pads directory for this session.\n\n");
@@ -218,12 +220,23 @@ int main(int argc, char* argv[]) {
     }
     
     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;
+        // Check if this is a decrypt command with piped input
+        if (argc == 2 && (strcmp(argv[1], "decrypt") == 0 || strcmp(argv[1], "-d") == 0)) {
+            // Piped decrypt mode - read stdin and decrypt silently
+            char* piped_message = read_stdin_text();
+            if (piped_message) {
+                int result = decrypt_text(NULL, piped_message);
+                free(piped_message);
+                return result;
+            }
+        } else {
+            // Regular pipe mode for encryption
+            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();
@@ -334,7 +347,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 +359,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 +379,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 +480,7 @@ int interactive_mode(void) {
 void show_main_menu(void) {
 
 
-    printf("\n=========================== Main Menu - OTP v0.2.105 ===========================\n\n");
+    printf("\n=========================== Main Menu - OTP v0.2.107 ===========================\n\n");
 
     printf(" \033[4mT\033[0mext encrypt\n");    //TEXT ENCRYPT
     printf(" \033[4mF\033[0mile encrypt\n");    //FILE ENCRYPT
@@ -1249,6 +1262,17 @@ 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 +1324,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");
-        printf(" 1. Type text directly\n");
-        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 (!is_pipe_mode) {
+            printf("\nText input options:\n");
+            printf(" 1. Type text directly\n");
+            printf(" 2. Use text editor\n");
+            printf("Enter choice (1-2): ");
         }
         
-        if (atoi(input_choice) == 2) {
+        char input_choice[10] = "1"; // Default to direct input in pipe mode
+        if (!is_pipe_mode) {
+            if (!fgets(input_choice, sizeof(input_choice), stdin)) {
+                printf("Error: Failed to read input\n");
+                free(pad_chksum);
+                return 1;
+            }
+        }
+        
+        if (!is_pipe_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");
-                printf("Enter text to encrypt: ");
+                if (!is_pipe_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 +1363,10 @@ int encrypt_text(const char* pad_identifier, const char* input_text) {
             }
         } else {
             // Direct text input
-            printf("Enter text to encrypt: ");
-            fflush(stdout);
+            if (!is_pipe_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,16 +1474,12 @@ 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 pipe 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_pipe_mode ? DECRYPT_MODE_SILENT : DECRYPT_MODE_INTERACTIVE;
+    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) {
     char* pad_chksum = find_pad_by_prefix(pad_identifier);
@@ -1926,190 +1954,14 @@ 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;
 
-    // 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
@@ -2599,7 +2451,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,7 +2656,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) {
@@ -2888,6 +2746,143 @@ 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 +2973,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 +3053,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.105\n");
+    snprintf(temp_line, sizeof(temp_line), "Version: v0.2.107\n");
     strcat(*ascii_output, temp_line);
     
     snprintf(temp_line, sizeof(temp_line), "Pad-ChkSum: %s\n", chksum);
@@ -3314,17 +3309,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 +3528,12 @@ 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 +3808,65 @@ 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
@@ -4540,7 +4610,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.105\n");
+    printf("OTP Cipher - One Time Pad Implementation v0.2.107\n");
     printf("Built for testing entropy system\n");
     printf("Usage:\n");
     printf("  %s                                         - Interactive mode\n", program_name);

test_encrypted.txt

@@ -0,0 +1,8 @@
+-----BEGIN OTP MESSAGE-----
+Version: v0.2.107
+Pad-ChkSum: d0aaeb745bfbc62b1ed8c0eca4f8dc016f4fd9ed49130979f2bb25a2a3c8192e
+Pad-Offset: 1786
+
+rRK8UkPc0t5bybg=
+-----END OTP MESSAGE-----
+