Version v0.3.50 - Fixing browsing behavior

Makefile

@@ -1,13 +1,13 @@
 CC = gcc
-CFLAGS = -Wall -Wextra -std=c99 -Isrc -Isrc/miniz -Isrc/microtar
+CFLAGS = -Wall -Wextra -std=c99 -Isrc -Iminiz -Imicrotar/src
-CFLAGS_MINIZ = -Wall -Wextra -std=c99 -D_POSIX_C_SOURCE=200112L -Isrc -Isrc/miniz -Isrc/microtar -Wno-unused-function -Wno-implicit-function-declaration
+CFLAGS_MINIZ = -Wall -Wextra -std=c99 -D_POSIX_C_SOURCE=200112L -Isrc -Iminiz -Imicrotar/src -Wno-unused-function -Wno-implicit-function-declaration
 LIBS = -lm
 LIBS_STATIC = -static -lm
 ARCH = $(shell uname -m)
 TARGET = build/otp-$(ARCH)
 SOURCES = $(wildcard src/*.c)
-MINIZ_SOURCES = $(wildcard src/miniz/*.c)
+MINIZ_SOURCES = $(wildcard miniz/*.c)
-MICROTAR_SOURCES = $(wildcard src/microtar/*.c)
+MICROTAR_SOURCES = $(wildcard microtar/src/*.c)
 OBJS = $(SOURCES:.c=.o)
 MINIZ_OBJS = $(MINIZ_SOURCES:.c=.o)
 MICROTAR_OBJS = $(MICROTAR_SOURCES:.c=.o)
@@ -30,11 +30,11 @@ src/%.o: src/%.c
 	$(CC) $(CFLAGS) -c $< -o $@
 
 # Compile miniz library files with reduced warnings
-src/miniz/%.o: src/miniz/%.c
+miniz/%.o: miniz/%.c
 	$(CC) $(CFLAGS_MINIZ) -c $< -o $@
 
 # Compile microtar library files normally
-src/microtar/%.o: src/microtar/%.c
+microtar/src/%.o: microtar/src/%.c
 	$(CC) $(CFLAGS) -c $< -o $@
 
 clean:

README.md

@@ -43,6 +43,7 @@ One-time pads can be trivially encrypted and decrypted using pencil and paper, m
 ## Features
 
 - **Perfect Security**: Implements true one-time pad encryption with information-theoretic security
+- **Traffic Analysis Resistance**: Exponential bucketing with ISO/IEC 9797-1 Method 2 (Padmé) padding hides message lengths
 - **Text & File Encryption**: Supports both inline text and file encryption
 - **Multiple Output Formats**: Binary (.otp) and ASCII armored (.otp.asc) file formats
 - **Hardware RNG Support**: Direct entropy collection from TrueRNG USB devices with automatic detection
@@ -58,14 +59,14 @@ One-time pads can be trivially encrypted and decrypted using pencil and paper, m
 
 ### Download Pre-Built Binaries
 
-**[Download Current Linux x86](https://git.laantungir.net/laantungir/otp/releases/download/v0.3.44/otp-v0.3.44-linux-x86_64)**
+**[Download Current Linux x86](https://git.laantungir.net/laantungir/otp/releases/download/v0.3.49/otp-v0.3.49-linux-x86_64)**
 
-**[Download Current Raspberry Pi 64](https://git.laantungir.net/laantungir/otp/releases/download/v0.3.44/otp-v0.3.44-linux-arm64)**
+**[Download Current Raspberry Pi 64](https://git.laantungir.net/laantungir/otp/releases/download/v0.3.49/otp-v0.3.49-linux-arm64)**
 
 After downloading:
 ```bash
 # Rename for convenience, then make executable
-mv otp-v0.3.44-linux-x86_64 otp
+mv otp-v0.3.49-linux-x86_64 otp
 chmod +x otp
 
 # Run it
@@ -189,8 +190,23 @@ git tag v1.0.0    # Next build: v1.0.1
 - Custom 256-bit XOR checksum for pad identification (encrypted with pad data)
 - Read-only pad files to prevent accidental modification
 - State tracking to prevent pad reuse
+- **Message Length Hiding**: Exponential bucketing (256B, 512B, 1KB, 2KB, 4KB...) prevents traffic analysis
+- **ISO/IEC 9797-1 Method 2 Padding**: Standard-compliant Padmé padding with 0x80 marker
 - **Zero external crypto dependencies** - completely self-contained implementation
 
+### Message Padding
+
+All encrypted messages and files are automatically padded using exponential bucketing to resist traffic analysis attacks:
+
+- **Minimum size**: 256 bytes
+- **Bucket sizes**: 256B → 512B → 1KB → 2KB → 4KB → 8KB → ...
+- **Padding method**: ISO/IEC 9797-1 Method 2 (Padmé padding)
+  - Appends `0x80` byte after message
+  - Fills remaining space with `0x00` bytes
+  - Unambiguous padding removal during decryption
+
+**Example**: A 10-byte message is padded to 256 bytes, while a 300-byte message is padded to 512 bytes. This provides strong protection for small messages where length leakage matters most, with logarithmic overhead for larger messages.
+
 ## Project Structure
 
 ```
@@ -205,6 +221,7 @@ otp/
 │   ├── ui.c             # Interactive user interface and menu system
 │   ├── state.c          # Global state management (pads directory, preferences)
 │   ├── crypto.c         # Core cryptographic operations (XOR, base64)
+│   ├── padding.c        # Message padding (exponential bucketing, Padmé padding)
 │   ├── pads.c           # Pad management and file operations
 │   ├── entropy.c        # Entropy collection from various sources
 │   ├── trng.c           # Hardware RNG device detection and collection
@@ -217,6 +234,7 @@ otp/
 ├── pads/                # OTP pad storage directory (created at runtime)
 ├── files/               # Encrypted file storage (created at runtime)
 └── tests/               # Test scripts and utilities
+    └── test_padding.sh  # Padding implementation tests
 ```
 
 ## Architecture
@@ -227,6 +245,7 @@ The OTP cipher uses a modular architecture with clean separation of concerns:
 - **ui.c**: Interactive user interface, menus, and terminal management
 - **state.c**: Global state management (pads directory, terminal dimensions, preferences)
 - **crypto.c**: Core cryptographic operations (XOR encryption, base64 encoding)
+- **padding.c**: Message padding implementation (exponential bucketing, ISO/IEC 9797-1 Method 2)
 - **pads.c**: Pad file management, checksums, and state tracking
 - **entropy.c**: Entropy collection from keyboard, dice, files, and hardware RNG
 - **trng.c**: Hardware RNG device detection and entropy collection from USB devices

build.sh

@@ -346,10 +346,29 @@ clean_project() {
 }
 
 install_project() {
-    print_status "Installing OTP project..."
+    print_status "Building project before installation..."
+    
+    # Build the project first (without version increment for install)
+    print_status "Cleaning previous build..."
+    make clean
+    
+    print_status "Building OTP project for x86_64..."
+    make CC=gcc ARCH=x86_64
+    if [ $? -ne 0 ]; then
+        print_error "Build failed"
+        return 1
+    fi
+    print_success "Build completed successfully"
+    
+    # Clean up object files after successful build
+    print_status "Cleaning up object files..."
+    rm -f src/*.o miniz/*.o microtar/src/*.o
+    
+    # Now install
+    print_status "Installing OTP project to system..."
     make install
     if [ $? -eq 0 ]; then
-        print_success "Installation completed"
+        print_success "Installation completed - binary installed to /usr/local/bin/otp"
     else
         print_error "Installation failed"
         return 1

otp

@@ -1 +0,0 @@
-./build/otp-x86_64

src/archive.c

@@ -10,12 +10,12 @@
 #include <dirent.h>
 #include <time.h>
 #include "main.h"
-#include "microtar/microtar.h"
+#include "microtar.h"
 
 // Suppress warnings from miniz header
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wunused-function"
-#include "miniz/miniz.h"
+#include "miniz.h"
 #pragma GCC diagnostic pop
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -476,7 +476,18 @@ int decrypt_and_extract_directory(const char* encrypted_file, const char* output
         unlink(temp_decrypted);
     } else {
         // Not compressed, assume it's already TAR
-        rename(temp_decrypted, temp_tar);
+        printf("File is not compressed, using as TAR directly...\n");
+        if (rename(temp_decrypted, temp_tar) != 0) {
+            printf("Error: Failed to rename decrypted file to TAR file\n");
+            unlink(temp_decrypted);
+            return 1;
+        }
+    }
+
+    // Verify TAR file exists before extraction
+    if (access(temp_tar, F_OK) != 0) {
+        printf("Error: TAR file does not exist at '%s'\n", temp_tar);
+        return 1;
     }
 
     printf("Extracting archive...\n");

src/crypto.c

@@ -401,18 +401,40 @@ int encrypt_text(const char* pad_identifier, const char* input_text) {
         return 1;
     }
 
-    // Check if we have enough pad space
+    // Calculate chunk size for padding (exponential bucketing)
-    struct stat pad_stat;
+    size_t chunk_size = calculate_chunk_size(input_len);
-    if (stat(pad_path, &pad_stat) != 0) {
+    
-        printf("Error: Cannot get pad file size\n");
+    // Allocate buffer for padded message
+    unsigned char* padded_buffer = malloc(chunk_size);
+    if (!padded_buffer) {
+        printf("Error: Memory allocation failed\n");
+        free(pad_chksum);
+        return 1;
+    }
+    
+    // Copy message to buffer and apply padding
+    memcpy(padded_buffer, text_buffer, input_len);
+    if (apply_padme_padding(padded_buffer, input_len, chunk_size) != 0) {
+        printf("Error: Failed to apply padding\n");
+        free(padded_buffer);
         free(pad_chksum);
         return 1;
     }
 
-    if (current_offset + input_len > (uint64_t)pad_stat.st_size) {
+    // Check if we have enough pad space (now using chunk_size instead of input_len)
+    struct stat pad_stat;
+    if (stat(pad_path, &pad_stat) != 0) {
+        printf("Error: Cannot get pad file size\n");
+        free(padded_buffer);
+        free(pad_chksum);
+        return 1;
+    }
+
+    if (current_offset + chunk_size > (uint64_t)pad_stat.st_size) {
         printf("Error: Not enough pad space remaining\n");
         printf("Need: %lu bytes, Available: %lu bytes\n",
-               input_len, (uint64_t)pad_stat.st_size - current_offset);
+               chunk_size, (uint64_t)pad_stat.st_size - current_offset);
+        free(padded_buffer);
         free(pad_chksum);
         return 1;
     }
@@ -432,37 +454,40 @@ int encrypt_text(const char* pad_identifier, const char* input_text) {
         return 1;
     }
 
-    unsigned char* pad_data = malloc(input_len);
+    unsigned char* pad_data = malloc(chunk_size);
-    if (fread(pad_data, 1, input_len, pad_file) != input_len) {
+    if (fread(pad_data, 1, chunk_size, pad_file) != chunk_size) {
         printf("Error: Cannot read pad data\n");
         free(pad_data);
         fclose(pad_file);
+        free(padded_buffer);
         free(pad_chksum);
         return 1;
     }
     fclose(pad_file);
 
-    // Use universal XOR operation for encryption
+    // Use universal XOR operation for encryption (now with padded data)
-    unsigned char* ciphertext = malloc(input_len);
+    unsigned char* ciphertext = malloc(chunk_size);
-    if (universal_xor_operation((const unsigned char*)text_buffer, input_len, pad_data, ciphertext) != 0) {
+    if (universal_xor_operation(padded_buffer, chunk_size, pad_data, ciphertext) != 0) {
         printf("Error: Encryption operation failed\n");
         free(pad_data);
         free(ciphertext);
+        free(padded_buffer);
         free(pad_chksum);
         return 1;
     }
 
-    // Update state offset
+    // Update state offset (now using chunk_size)
-    if (write_state_offset(pad_chksum, current_offset + input_len) != 0) {
+    if (write_state_offset(pad_chksum, current_offset + chunk_size) != 0) {
         printf("Warning: Failed to update state file\n");
     }
 
-    // Use universal ASCII armor generator
+    // Use universal ASCII armor generator (now with chunk_size)
     char* ascii_output;
-    if (generate_ascii_armor(pad_chksum, current_offset, ciphertext, input_len, &ascii_output) != 0) {
+    if (generate_ascii_armor(pad_chksum, current_offset, ciphertext, chunk_size, &ascii_output) != 0) {
         printf("Error: Failed to generate ASCII armor\n");
         free(pad_data);
         free(ciphertext);
+        free(padded_buffer);
         free(pad_chksum);
         return 1;
     }
@@ -479,6 +504,7 @@ int encrypt_text(const char* pad_identifier, const char* input_text) {
     // Cleanup
     free(pad_data);
     free(ciphertext);
+    free(padded_buffer);
     free(ascii_output);
     free(pad_chksum);
 
@@ -632,6 +658,22 @@ int universal_decrypt(const char* input_data, const char* output_target, decrypt
         return 1;
     }
 
+    // Remove padding to get actual message
+    size_t actual_msg_len;
+    if (remove_padme_padding(ciphertext, ciphertext_len, &actual_msg_len) != 0) {
+        if (mode == DECRYPT_MODE_SILENT) {
+            fprintf(stderr, "Error: Invalid padding - message may be corrupted\n");
+        } else {
+            printf("Error: Invalid padding - message may be corrupted\n");
+        }
+        free(ciphertext);
+        free(pad_data);
+        return 1;
+    }
+    
+    // Update ciphertext_len to actual message length
+    ciphertext_len = actual_msg_len;
+
     // Output based on mode
     if (mode == DECRYPT_MODE_FILE_TO_FILE) {
         // Write to output file
@@ -740,6 +782,9 @@ int encrypt_file(const char* pad_identifier, const char* input_file, const char*
         return 1;
     }
 
+    // Calculate chunk size for padding (exponential bucketing)
+    size_t chunk_size = calculate_chunk_size(file_size);
+
     // Check if pad file exists
     if (access(pad_path, R_OK) != 0) {
         printf("Error: Pad file %s not found\n", pad_path);
@@ -774,10 +819,10 @@ int encrypt_file(const char* pad_identifier, const char* input_file, const char*
         return 1;
     }
 
-    if (current_offset + file_size > (uint64_t)pad_stat.st_size) {
+    if (current_offset + chunk_size > (uint64_t)pad_stat.st_size) {
         printf("Error: Not enough pad space remaining\n");
-        printf("Need: %lu bytes, Available: %lu bytes\n",
+        printf("Need: %lu bytes (file: %lu + padding), Available: %lu bytes\n",
-               file_size, (uint64_t)pad_stat.st_size - current_offset);
+               chunk_size, file_size, (uint64_t)pad_stat.st_size - current_offset);
         free(pad_chksum);
         return 1;
     }
@@ -822,66 +867,93 @@ int encrypt_file(const char* pad_identifier, const char* input_file, const char*
         return 1;
     }
 
-    // Read and encrypt file
+    // Allocate buffer for padded file data
-    unsigned char buffer[64 * 1024];
+    unsigned char* file_data = malloc(file_size);
-    unsigned char pad_buffer[64 * 1024];
+    if (!file_data) {
-    unsigned char* encrypted_data = malloc(file_size);
+        printf("Error: Memory allocation failed\n");
-    uint64_t bytes_processed = 0;
+        fclose(input_fp);
+        fclose(pad_file);
+        free(pad_chksum);
+        return 1;
+    }
 
     printf("Encrypting %s...\n", input_file);
 
-    while (bytes_processed < file_size) {
+    // Read entire file
-        uint64_t chunk_size = sizeof(buffer);
+    if (fread(file_data, 1, file_size, input_fp) != file_size) {
-        if (file_size - bytes_processed < chunk_size) {
+        printf("Error: Cannot read input file\n");
-            chunk_size = file_size - bytes_processed;
+        free(file_data);
-        }
+        fclose(input_fp);
-
+        fclose(pad_file);
-        // Read file data
+        free(pad_chksum);
-        if (fread(buffer, 1, chunk_size, input_fp) != chunk_size) {
+        return 1;
-            printf("Error: Cannot read input file data\n");
-            free(encrypted_data);
-            fclose(input_fp);
-            fclose(pad_file);
-            free(pad_chksum);
-            return 1;
-        }
-
-        // Read pad data
-        if (fread(pad_buffer, 1, chunk_size, pad_file) != chunk_size) {
-            printf("Error: Cannot read pad data\n");
-            free(encrypted_data);
-            fclose(input_fp);
-            fclose(pad_file);
-            free(pad_chksum);
-            return 1;
-        }
-
-        // Use universal XOR operation for encryption
-        if (universal_xor_operation(buffer, chunk_size, pad_buffer, &encrypted_data[bytes_processed]) != 0) {
-            printf("Error: Encryption operation failed\n");
-            free(encrypted_data);
-            fclose(input_fp);
-            fclose(pad_file);
-            free(pad_chksum);
-            return 1;
-        }
-
-        bytes_processed += chunk_size;
-
-        // Show progress for large files (> 10MB)
-        if (file_size > 10 * 1024 * 1024 && bytes_processed % (1024 * 1024) == 0) {
-            // show_progress(bytes_processed, file_size, start_time); // MOVED TO src/util.c
-        }
     }
-
-    if (file_size > 10 * 1024 * 1024) {
-        // show_progress(file_size, file_size, start_time); // MOVED TO src/util.c
-        printf("\n");
-    }
-
     fclose(input_fp);
+
+    // Allocate buffer for padded data
+    unsigned char* padded_data = malloc(chunk_size);
+    if (!padded_data) {
+        printf("Error: Memory allocation failed\n");
+        free(file_data);
+        fclose(pad_file);
+        free(pad_chksum);
+        return 1;
+    }
+
+    // Copy file data and apply padding
+    memcpy(padded_data, file_data, file_size);
+    free(file_data);
+    
+    if (apply_padme_padding(padded_data, file_size, chunk_size) != 0) {
+        printf("Error: Failed to apply padding\n");
+        free(padded_data);
+        fclose(pad_file);
+        free(pad_chksum);
+        return 1;
+    }
+
+    // Read pad data
+    unsigned char* pad_data = malloc(chunk_size);
+    if (!pad_data) {
+        printf("Error: Memory allocation failed\n");
+        free(padded_data);
+        fclose(pad_file);
+        free(pad_chksum);
+        return 1;
+    }
+
+    if (fread(pad_data, 1, chunk_size, pad_file) != chunk_size) {
+        printf("Error: Cannot read pad data\n");
+        free(padded_data);
+        free(pad_data);
+        fclose(pad_file);
+        free(pad_chksum);
+        return 1;
+    }
     fclose(pad_file);
 
+    // Encrypt padded data
+    unsigned char* encrypted_data = malloc(chunk_size);
+    if (!encrypted_data) {
+        printf("Error: Memory allocation failed\n");
+        free(padded_data);
+        free(pad_data);
+        free(pad_chksum);
+        return 1;
+    }
+
+    if (universal_xor_operation(padded_data, chunk_size, pad_data, encrypted_data) != 0) {
+        printf("Error: Encryption operation failed\n");
+        free(padded_data);
+        free(pad_data);
+        free(encrypted_data);
+        free(pad_chksum);
+        return 1;
+    }
+
+    free(padded_data);
+    free(pad_data);
+
     // Write output file
     if (ascii_armor) {
         // ASCII armored format - same as message format
@@ -893,9 +965,9 @@ int encrypt_file(const char* pad_identifier, const char* input_file, const char*
             return 1;
         }
 
-        // Use universal ASCII armor generator
+        // Use universal ASCII armor generator (now with chunk_size)
         char* ascii_output;
-        if (generate_ascii_armor(pad_chksum, current_offset, encrypted_data, file_size, &ascii_output) != 0) {
+        if (generate_ascii_armor(pad_chksum, current_offset, encrypted_data, chunk_size, &ascii_output) != 0) {
             printf("Error: Failed to generate ASCII armor\n");
             fclose(output_fp);
             free(encrypted_data);
@@ -941,17 +1013,17 @@ int encrypt_file(const char* pad_identifier, const char* input_file, const char*
         uint32_t file_mode = input_stat.st_mode;
         fwrite(&file_mode, sizeof(uint32_t), 1, output_fp);
 
-        // File size: 8 bytes
+        // File size: 8 bytes (original file size, not padded)
         fwrite(&file_size, sizeof(uint64_t), 1, output_fp);
 
-        // Encrypted data
+        // Encrypted data (padded)
-        fwrite(encrypted_data, 1, file_size, output_fp);
+        fwrite(encrypted_data, 1, chunk_size, output_fp);
 
         fclose(output_fp);
     }
 
-    // Update state offset
+    // Update state offset (now using chunk_size)
-    if (write_state_offset(pad_chksum, current_offset + file_size) != 0) {
+    if (write_state_offset(pad_chksum, current_offset + chunk_size) != 0) {
         printf("Warning: Failed to update state file\n");
     }
 
@@ -1012,14 +1084,14 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
     unsigned char pad_chksum_bin[32];
     uint64_t pad_offset;
     uint32_t file_mode;
-    uint64_t file_size;
+    uint64_t original_file_size;
 
     if (fread(magic, 1, 4, input_fp) != 4 ||
         fread(&version, sizeof(uint16_t), 1, input_fp) != 1 ||
         fread(pad_chksum_bin, 1, 32, input_fp) != 32 ||
         fread(&pad_offset, sizeof(uint64_t), 1, input_fp) != 1 ||
         fread(&file_mode, sizeof(uint32_t), 1, input_fp) != 1 ||
-        fread(&file_size, sizeof(uint64_t), 1, input_fp) != 1) {
+        fread(&original_file_size, sizeof(uint64_t), 1, input_fp) != 1) {
         printf("Error: Cannot read binary header\n");
         fclose(input_fp);
         return 1;
@@ -1039,7 +1111,7 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
     pad_chksum_hex[64] = '\0';
 
     printf("Decrypting binary file...\n");
-    printf("File size: %lu bytes\n", file_size);
+    printf("Original file size: %lu bytes\n", original_file_size);
 
     // Check if we have the required pad
     char pad_path[MAX_HASH_LENGTH + 20];
@@ -1064,9 +1136,18 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
         output_file = default_output;
     }
 
-    // Read encrypted data
+    // Calculate chunk size (encrypted data is padded)
-    unsigned char* encrypted_data = malloc(file_size);
+    size_t chunk_size = calculate_chunk_size(original_file_size);
-    if (fread(encrypted_data, 1, file_size, input_fp) != file_size) {
+
+    // Read encrypted (padded) data
+    unsigned char* encrypted_data = malloc(chunk_size);
+    if (!encrypted_data) {
+        printf("Error: Memory allocation failed\n");
+        fclose(input_fp);
+        return 1;
+    }
+
+    if (fread(encrypted_data, 1, chunk_size, input_fp) != chunk_size) {
         printf("Error: Cannot read encrypted data\n");
         free(encrypted_data);
         fclose(input_fp);
@@ -1089,8 +1170,15 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
         return 1;
     }
 
-    unsigned char* pad_data = malloc(file_size);
+    unsigned char* pad_data = malloc(chunk_size);
-    if (fread(pad_data, 1, file_size, pad_file) != file_size) {
+    if (!pad_data) {
+        printf("Error: Memory allocation failed\n");
+        free(encrypted_data);
+        fclose(pad_file);
+        return 1;
+    }
+
+    if (fread(pad_data, 1, chunk_size, pad_file) != chunk_size) {
         printf("Error: Cannot read pad data\n");
         free(encrypted_data);
         free(pad_data);
@@ -1100,26 +1188,40 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
     fclose(pad_file);
 
     // Use universal XOR operation for decryption
-    if (universal_xor_operation(encrypted_data, file_size, pad_data, encrypted_data) != 0) {
+    if (universal_xor_operation(encrypted_data, chunk_size, pad_data, encrypted_data) != 0) {
         printf("Error: Decryption operation failed\n");
         free(encrypted_data);
         free(pad_data);
         return 1;
     }
 
-    // Write decrypted file
+    free(pad_data);
+
+    // Remove padding to get original file
+    size_t actual_file_size;
+    if (remove_padme_padding(encrypted_data, chunk_size, &actual_file_size) != 0) {
+        printf("Error: Invalid padding - file may be corrupted\n");
+        free(encrypted_data);
+        return 1;
+    }
+
+    // Verify the actual size matches the stored original size
+    if (actual_file_size != original_file_size) {
+        printf("Warning: Decrypted size (%lu) doesn't match stored size (%lu)\n",
+               actual_file_size, original_file_size);
+    }
+
+    // Write decrypted file (using actual_file_size)
     FILE* output_fp = fopen(output_file, "wb");
     if (!output_fp) {
         printf("Error: Cannot create output file %s\n", output_file);
         free(encrypted_data);
-        free(pad_data);
         return 1;
     }
 
-    if (fwrite(encrypted_data, 1, file_size, output_fp) != file_size) {
+    if (fwrite(encrypted_data, 1, actual_file_size, output_fp) != actual_file_size) {
         printf("Error: Cannot write decrypted data\n");
         free(encrypted_data);
-        free(pad_data);
         fclose(output_fp);
         return 1;
     }
@@ -1133,12 +1235,14 @@ int decrypt_binary_file(FILE* input_fp, const char* output_file) {
     printf("File decrypted successfully: %s\n", output_file);
     printf("Restored permissions and metadata\n");
 
-    // Pause before returning to menu to let user see the success message
+    // Only pause if output is not a temporary file (directory decryption uses /tmp/)
-    print_centered_header("File Decryption Complete", 1);
+    if (strncmp(output_file, "/tmp/", 5) != 0) {
+        // Pause before returning to menu to let user see the success message
+        print_centered_header("File Decryption Complete", 1);
+    }
 
     // Cleanup
     free(encrypted_data);
-    free(pad_data);
 
     return 0;
 }

src/main.h

@@ -23,7 +23,7 @@
 #include <ctype.h>
 
 // Version - Updated automatically by build.sh
-#define OTP_VERSION "v0.3.44"
+#define OTP_VERSION "v0.3.49"
 
 // Constants
 #define MAX_INPUT_SIZE 4096
@@ -267,6 +267,16 @@ 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);
 
+////////////////////////////////////////////////////////////////////////////////
+//      MESSAGE PADDING FUNCTIONS
+////////////////////////////////////////////////////////////////////////////////
+
+// Exponential bucketing and ISO/IEC 9797-1 Method 2 (Padmé) padding
+size_t calculate_chunk_size(size_t msg_len);
+int apply_padme_padding(unsigned char* buffer, size_t msg_len, size_t chunk_size);
+int remove_padme_padding(const unsigned char* buffer, size_t chunk_size, size_t* msg_len);
+void format_chunk_size(size_t chunk_size, char* buffer, size_t buffer_size);
+
 ////////////////////////////////////////////////////////////////////////////////
 //      UTILITY FUNCTIONS
 ////////////////////////////////////////////////////////////////////////////////
@@ -277,6 +287,7 @@ 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);
 void format_time_remaining(double seconds, char* buffer, size_t buffer_size);
+int is_escape_input(const char* input);
 
 ////////////////////////////////////////////////////////////////////////////////
 //      FILE OPERATIONS

src/padding.c

@@ -0,0 +1,92 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+#include "main.h"
+
+////////////////////////////////////////////////////////////////////////////////
+//      MESSAGE PADDING IMPLEMENTATION
+//      ISO/IEC 9797-1 Method 2 (Padmé Padding)
+//      with Exponential Bucketing for Traffic Analysis Resistance
+////////////////////////////////////////////////////////////////////////////////
+
+// Calculate required chunk size using exponential bucketing
+// Starting at 256 bytes, doubling each time
+// Provides strong protection against length analysis attacks
+size_t calculate_chunk_size(size_t msg_len) {
+    size_t chunk = 256;  // Minimum chunk size: 256 bytes
+    
+    // Need space for message + 0x80 byte (minimum 1 byte padding)
+    while (chunk < msg_len + 1) {
+        chunk *= 2;
+    }
+    
+    return chunk;
+}
+
+// Apply ISO/IEC 9797-1 Method 2 (Padmé) padding
+// Appends 0x80 byte followed by 0x00 bytes to reach chunk boundary
+// Returns 0 on success, non-zero on error
+int apply_padme_padding(unsigned char* buffer, size_t msg_len, size_t chunk_size) {
+    if (!buffer) {
+        return 1; // Error: null pointer
+    }
+    
+    if (chunk_size < msg_len + 1) {
+        return 2; // Error: chunk size too small for message + padding
+    }
+    
+    // Apply padding: 0x80 followed by 0x00 bytes
+    buffer[msg_len] = 0x80;
+    
+    // Fill remaining bytes with 0x00
+    if (chunk_size > msg_len + 1) {
+        memset(buffer + msg_len + 1, 0x00, chunk_size - msg_len - 1);
+    }
+    
+    return 0; // Success
+}
+
+// Remove ISO/IEC 9797-1 Method 2 (Padmé) padding
+// Scans backwards for 0x80 marker, validates padding
+// Returns 0 on success, non-zero on error
+// Sets msg_len to the actual message length (excluding padding)
+int remove_padme_padding(const unsigned char* buffer, size_t chunk_size, size_t* msg_len) {
+    if (!buffer || !msg_len) {
+        return 1; // Error: null pointer
+    }
+    
+    if (chunk_size == 0) {
+        return 2; // Error: invalid chunk size
+    }
+    
+    // Scan backwards from end to find 0x80 marker
+    for (int i = chunk_size - 1; i >= 0; i--) {
+        if (buffer[i] == 0x80) {
+            // Found the padding marker
+            *msg_len = i;
+            return 0; // Success
+        } else if (buffer[i] != 0x00) {
+            // Found non-zero, non-0x80 byte - invalid padding
+            return 3; // Error: invalid padding (corrupted or tampered data)
+        }
+    }
+    
+    // No 0x80 marker found - invalid padding
+    return 4; // Error: no padding marker found
+}
+
+// Helper function to get human-readable chunk size
+// Useful for debugging and user feedback
+void format_chunk_size(size_t chunk_size, char* buffer, size_t buffer_size) {
+    if (!buffer || buffer_size == 0) return;
+    
+    if (chunk_size < 1024) {
+        snprintf(buffer, buffer_size, "%zu bytes", chunk_size);
+    } else if (chunk_size < 1024 * 1024) {
+        snprintf(buffer, buffer_size, "%.1f KB", chunk_size / 1024.0);
+    } else if (chunk_size < 1024 * 1024 * 1024) {
+        snprintf(buffer, buffer_size, "%.1f MB", chunk_size / (1024.0 * 1024.0));
+    } else {
+        snprintf(buffer, buffer_size, "%.1f GB", chunk_size / (1024.0 * 1024.0 * 1024.0));
+    }
+}

src/state.c

@@ -1,10 +1,12 @@
 #include <string.h>
 #include <stdlib.h>
+#include <stdio.h>
 #include "main.h"
 
 // Global state variables
-static char current_pads_dir[512] = DEFAULT_PADS_DIR;
+static char current_pads_dir[512] = "";
 static int is_interactive_mode = 0;
+static int pads_dir_initialized = 0;
 
 // Terminal dimensions (moved from ui.c to state.c for global access)
 static int terminal_width = 80;  // Default fallback width
@@ -13,6 +15,18 @@ static int terminal_height = 24; // Default fallback height
 // Getters and setters for global state
 
 const char* get_current_pads_dir(void) {
+    // Initialize pads directory on first access if not already set
+    if (!pads_dir_initialized && strlen(current_pads_dir) == 0) {
+        char* home_dir = getenv("HOME");
+        if (home_dir) {
+            snprintf(current_pads_dir, sizeof(current_pads_dir), "%s/.otp/pads", home_dir);
+        } else {
+            // Fallback to relative path if HOME is not set
+            strncpy(current_pads_dir, DEFAULT_PADS_DIR, sizeof(current_pads_dir) - 1);
+        }
+        current_pads_dir[sizeof(current_pads_dir) - 1] = '\0';
+        pads_dir_initialized = 1;
+    }
     return current_pads_dir;
 }
 
@@ -20,6 +34,7 @@ void set_current_pads_dir(const char* dir) {
     if (dir) {
         strncpy(current_pads_dir, dir, sizeof(current_pads_dir) - 1);
         current_pads_dir[sizeof(current_pads_dir) - 1] = '\0';
+        pads_dir_initialized = 1;
     }
 }
 

src/ui.c

@@ -184,7 +184,7 @@ int handle_encrypt_menu(void) {
     printf("\nSelect encryption type:\n");
     printf(" 1. Text message\n");
     printf(" 2. File\n");
-    printf("Enter choice (1-2): ");
+    printf("Enter choice (1-2) or 'esc' to cancel: ");
 
     char choice_input[10];
     if (!fgets(choice_input, sizeof(choice_input), stdin)) {
@@ -192,6 +192,14 @@ int handle_encrypt_menu(void) {
         return 1;
     }
 
+    choice_input[strcspn(choice_input, "\n")] = 0;
+    
+    // Check for ESC/cancel
+    if (is_escape_input(choice_input)) {
+        printf("Returning to main menu...\n");
+        return 0;
+    }
+
     int choice = atoi(choice_input);
 
     if (choice == 1) {
@@ -213,7 +221,7 @@ int handle_encrypt_menu(void) {
         printf("\nFile selection options:\n");
         printf(" 1. Type file path directly\n");
         printf(" 2. Use file manager\n");
-        printf("Enter choice (1-2): ");
+        printf("Enter choice (1-2) or 'esc' to cancel: ");
 
         char file_choice[10];
         char input_file[512];
@@ -223,25 +231,45 @@ int handle_encrypt_menu(void) {
             return 1;
         }
 
+        file_choice[strcspn(file_choice, "\n")] = 0;
+        
+        // Check for ESC/cancel
+        if (is_escape_input(file_choice)) {
+            printf("Returning to main menu...\n");
+            return 0;
+        }
+
         if (atoi(file_choice) == 2) {
             // Use file manager
             if (launch_file_manager(".", input_file, sizeof(input_file)) != 0) {
                 printf("Falling back to manual file path entry.\n");
-                printf("Enter input file path: ");
+                printf("Enter input file path (or 'esc' to cancel): ");
                 if (!fgets(input_file, sizeof(input_file), stdin)) {
                     printf("Error: Failed to read input\n");
                     return 1;
                 }
                 input_file[strcspn(input_file, "\n")] = 0;
+                
+                // Check for ESC/cancel
+                if (is_escape_input(input_file)) {
+                    printf("Returning to main menu...\n");
+                    return 0;
+                }
             }
         } else {
             // Direct file path input
-            printf("Enter input file path: ");
+            printf("Enter input file path (or 'esc' to cancel): ");
             if (!fgets(input_file, sizeof(input_file), stdin)) {
                 printf("Error: Failed to read input\n");
                 return 1;
             }
             input_file[strcspn(input_file, "\n")] = 0;
+            
+            // Check for ESC/cancel
+            if (is_escape_input(input_file)) {
+                printf("Returning to main menu...\n");
+                return 0;
+            }
         }
 
         // Check if file exists
@@ -263,14 +291,24 @@ int handle_encrypt_menu(void) {
         printf("\nSelect output format:\n");
         printf(" 1. Binary (.otp) - preserves file permissions\n");
         printf(" 2. ASCII (.otp.asc) - text-safe format\n");
-        printf("Enter choice (1-2): ");
+        printf("Enter choice (1-2) or 'esc' to cancel: ");
 
         char format_input[10];
         if (!fgets(format_input, sizeof(format_input), stdin)) {
             printf("Error: Failed to read input\n");
+            free(selected_pad);
             return 1;
         }
 
+        format_input[strcspn(format_input, "\n")] = 0;
+        
+        // Check for ESC/cancel
+        if (is_escape_input(format_input)) {
+            printf("Returning to main menu...\n");
+            free(selected_pad);
+            return 0;
+        }
+
         int ascii_armor = (atoi(format_input) == 2) ? 1 : 0;
 
         // Generate default output filename with files directory and use enhanced input function
@@ -309,6 +347,7 @@ int handle_decrypt_menu(void) {
     printf("\n");
     print_centered_header("Smart Decrypt", 0);
     printf("Enter encrypted data (paste ASCII armor), file path, or press Enter to browse files:\n");
+    printf("(Type 'esc' or 'q' to return to main menu)\n");
 
     char input_line[MAX_LINE_LENGTH];
     if (!fgets(input_line, sizeof(input_line), stdin)) {
@@ -319,12 +358,45 @@ int handle_decrypt_menu(void) {
     // Remove newline
     input_line[strcspn(input_line, "\n")] = 0;
 
-    if (strlen(input_line) == 0) {
+    // Check for ESC/cancel
+    if (is_escape_input(input_line)) {
+        printf("Returning to main menu...\n");
+        return 0;
+    }
+
+    // Trim leading whitespace to handle pasted content better
+    char* trimmed_input = input_line;
+    while (*trimmed_input == ' ' || *trimmed_input == '\t') {
+        trimmed_input++;
+    }
+
+    // Check for ASCII armor FIRST, before checking for empty input
+    // This handles cases where pasted text starts with the header
+    if (strncmp(trimmed_input, "-----BEGIN OTP MESSAGE-----", 27) == 0) {
+        // Looks like ASCII armor - collect the full message
+        char full_message[MAX_INPUT_SIZE * 4] = {0};
+        strcat(full_message, input_line);
+        strcat(full_message, "\n");
+
+        printf("Continue pasting the message (end with -----END OTP MESSAGE-----):\n");
+
+        char line[MAX_LINE_LENGTH];
+        while (fgets(line, sizeof(line), stdin)) {
+            strncat(full_message, line, sizeof(full_message) - strlen(full_message) - 1);
+            if (strstr(line, "-----END OTP MESSAGE-----")) {
+                break;
+            }
+        }
+
+        return decrypt_text(NULL, full_message);
+    }
+    else if (strlen(trimmed_input) == 0) {
         // Empty input - launch file manager to browse for files
         char selected_file[512];
         if (launch_file_manager(get_files_directory(), selected_file, sizeof(selected_file)) != 0) {
-            printf("Error: Could not launch file manager\n");
+            printf("File browsing cancelled or failed.\n");
-            return 1;
+            printf("Returning to main menu...\n");
+            return 0;
         }
 
         // Generate smart default output filename with files directory and use enhanced input function
@@ -334,7 +406,15 @@ int handle_decrypt_menu(void) {
         temp_default[sizeof(temp_default) - 1] = '\0';
 
         // Remove common encrypted extensions to get a better default
-        if (strstr(temp_default, ".otp.asc")) {
+        if (strstr(temp_default, ".tar.gz.otp")) {
+            // Directory archive - remove .tar.gz.otp to get original directory name
+            char* ext_pos = strstr(temp_default, ".tar.gz.otp");
+            *ext_pos = '\0';
+        } else if (strstr(temp_default, ".tar.otp")) {
+            // Directory archive without compression - remove .tar.otp
+            char* ext_pos = strstr(temp_default, ".tar.otp");
+            *ext_pos = '\0';
+        } else if (strstr(temp_default, ".otp.asc")) {
             // Replace .otp.asc with original extension or no extension
             char* ext_pos = strstr(temp_default, ".otp.asc");
             *ext_pos = '\0';
@@ -374,35 +454,25 @@ int handle_decrypt_menu(void) {
             return decrypt_file(selected_file, output_file);
         }
     }
-    else if (strncmp(input_line, "-----BEGIN OTP MESSAGE-----", 27) == 0) {
-        // Looks like ASCII armor - collect the full message
-        char full_message[MAX_INPUT_SIZE * 4] = {0};
-        strcat(full_message, input_line);
-        strcat(full_message, "\n");
-
-        printf("Continue pasting the message (end with -----END OTP MESSAGE-----):\n");
-
-        char line[MAX_LINE_LENGTH];
-        while (fgets(line, sizeof(line), stdin)) {
-            strncat(full_message, line, sizeof(full_message) - strlen(full_message) - 1);
-            if (strstr(line, "-----END OTP MESSAGE-----")) {
-                break;
-            }
-        }
-
-        return decrypt_text(NULL, full_message);
-    }
     else {
         // Check if it looks like a file path
-        if (access(input_line, R_OK) == 0) {
+        if (access(trimmed_input, R_OK) == 0) {
             // It's a valid file - decrypt it with enhanced input for output filename
             char temp_default[512];
             char default_output[512];
-            strncpy(temp_default, input_line, sizeof(temp_default) - 1);
+            strncpy(temp_default, trimmed_input, sizeof(temp_default) - 1);
             temp_default[sizeof(temp_default) - 1] = '\0';
 
             // Remove common encrypted extensions to get a better default
-            if (strstr(temp_default, ".otp.asc")) {
+            if (strstr(temp_default, ".tar.gz.otp")) {
+                // Directory archive - remove .tar.gz.otp to get original directory name
+                char* ext_pos = strstr(temp_default, ".tar.gz.otp");
+                *ext_pos = '\0';
+            } else if (strstr(temp_default, ".tar.otp")) {
+                // Directory archive without compression - remove .tar.otp
+                char* ext_pos = strstr(temp_default, ".tar.otp");
+                *ext_pos = '\0';
+            } else if (strstr(temp_default, ".otp.asc")) {
                 // Replace .otp.asc with original extension or no extension
                 char* ext_pos = strstr(temp_default, ".otp.asc");
                 *ext_pos = '\0';
@@ -425,7 +495,7 @@ int handle_decrypt_menu(void) {
             }
 
             // Check if it's a directory archive
-            if (strstr(input_line, ".tar.gz.otp") || strstr(input_line, ".tar.otp")) {
+            if (strstr(trimmed_input, ".tar.gz.otp") || strstr(trimmed_input, ".tar.otp")) {
                 // It's a directory archive - extract to directory
                 char extract_dir[512];
                 strncpy(extract_dir, output_file, sizeof(extract_dir) - 1);
@@ -437,9 +507,9 @@ int handle_decrypt_menu(void) {
                 if (ext) *ext = '\0';
                 
                 printf("Extracting directory archive to: %s/\n", extract_dir);
-                return decrypt_and_extract_directory(input_line, extract_dir);
+                return decrypt_and_extract_directory(trimmed_input, extract_dir);
             } else {
-                return decrypt_file(input_line, output_file);
+                return decrypt_file(trimmed_input, output_file);
             }
         } else {
             printf("Input not recognized as ASCII armor or valid file path.\n");
@@ -508,14 +578,24 @@ int handle_file_encrypt(void) {
     printf("\nSelect output format:\n");
     printf(" 1. Binary (.otp) - preserves file permissions\n");
     printf(" 2. ASCII (.otp.asc) - text-safe format\n");
-    printf("Enter choice (1-2): ");
+    printf("Enter choice (1-2) or 'esc' to cancel: ");
 
     char format_input[10];
     if (!fgets(format_input, sizeof(format_input), stdin)) {
         printf("Error: Failed to read input\n");
+        free(selected_pad);
         return 1;
     }
 
+    format_input[strcspn(format_input, "\n")] = 0;
+    
+    // Check for ESC/cancel
+    if (is_escape_input(format_input)) {
+        printf("Returning to main menu...\n");
+        free(selected_pad);
+        return 0;
+    }
+
     int ascii_armor = (atoi(format_input) == 2) ? 1 : 0;
 
     // Generate default output filename
@@ -540,6 +620,184 @@ int handle_file_encrypt(void) {
     return result;
 }
 
+// Comparison function for qsort (case-insensitive)
+static int compare_dir_strings(const void *a, const void *b) {
+    return strcasecmp(*(const char**)a, *(const char**)b);
+}
+
+// Function to get list of subdirectories
+static int get_subdirs(const char *path, char ***subdirs) {
+    DIR *dir = opendir(path);
+    if (!dir) return 0;
+    
+    int count = 0;
+    int capacity = 10;
+    *subdirs = malloc(capacity * sizeof(char*));
+    
+    struct dirent *entry;
+    while ((entry = readdir(dir)) != NULL) {
+        if (entry->d_type == DT_DIR) {
+            // Skip . and ..
+            if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0)
+                continue;
+            
+            if (count >= capacity) {
+                capacity *= 2;
+                *subdirs = realloc(*subdirs, capacity * sizeof(char*));
+            }
+            (*subdirs)[count++] = strdup(entry->d_name);
+        }
+    }
+    closedir(dir);
+    
+    // Sort alphabetically
+    if (count > 0) {
+        qsort(*subdirs, count, sizeof(char*), compare_dir_strings);
+    }
+    
+    return count;
+}
+
+// Function to get a single keypress without echo
+static int getch_nav(void) {
+    struct termios oldt, newt;
+    int ch;
+    tcgetattr(STDIN_FILENO, &oldt);
+    newt = oldt;
+    newt.c_lflag &= ~(ICANON | ECHO);
+    tcsetattr(STDIN_FILENO, TCSANOW, &newt);
+    ch = getchar();
+    tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
+    return ch;
+}
+
+// Navigate directories with arrow keys
+static char* navigate_directory_interactive(void) {
+    char current_path[PATH_MAX];
+    char original_path[PATH_MAX];
+    getcwd(original_path, sizeof(original_path));
+    getcwd(current_path, sizeof(current_path));
+    
+    char **subdirs = NULL;
+    int subdir_count = 0;
+    int current_index = 0;
+    
+    printf("\nNavigate with arrow keys (UP/DOWN: cycle, RIGHT: enter, LEFT: back, ENTER: select, Q: cancel)\n");
+    printf("\033[?25l"); // Hide cursor
+    
+    while (1) {
+        // Clear line and show current path
+        printf("\r\033[K%s", current_path);
+        
+        // If we have subdirectories and an index, show current selection
+        if (subdir_count > 0 && current_index < subdir_count) {
+            printf("/%s", subdirs[current_index]);
+        }
+        
+        fflush(stdout);
+        
+        int ch = getch_nav();
+        
+        // Handle arrow keys (they come as escape sequences)
+        if (ch == 27) { // ESC sequence
+            getch_nav(); // Skip '['
+            ch = getch_nav();
+            
+            if (ch == 'A') { // UP arrow
+                // Load subdirs if not loaded
+                if (subdirs == NULL) {
+                    subdir_count = get_subdirs(current_path, &subdirs);
+                    current_index = 0;
+                } else if (subdir_count > 0) {
+                    current_index = (current_index - 1 + subdir_count) % subdir_count;
+                }
+            }
+            else if (ch == 'B') { // DOWN arrow
+                // Load subdirs if not loaded
+                if (subdirs == NULL) {
+                    subdir_count = get_subdirs(current_path, &subdirs);
+                    current_index = 0;
+                } else if (subdir_count > 0) {
+                    current_index = (current_index + 1) % subdir_count;
+                }
+            }
+            else if (ch == 'C') { // RIGHT arrow - go deeper
+                if (subdir_count > 0 && current_index < subdir_count) {
+                    // Navigate into selected directory
+                    char new_path[PATH_MAX];
+                    snprintf(new_path, sizeof(new_path), "%s/%s", current_path, subdirs[current_index]);
+                    
+                    if (chdir(new_path) == 0) {
+                        getcwd(current_path, sizeof(current_path));
+                        
+                        // Free old subdirs
+                        for (int i = 0; i < subdir_count; i++) {
+                            free(subdirs[i]);
+                        }
+                        free(subdirs);
+                        subdirs = NULL;
+                        
+                        // Load subdirs of new directory and show first one
+                        subdir_count = get_subdirs(current_path, &subdirs);
+                        current_index = 0;
+                    }
+                }
+            }
+            else if (ch == 'D') { // LEFT arrow - go up
+                if (chdir("..") == 0) {
+                    getcwd(current_path, sizeof(current_path));
+                    
+                    // Free old subdirs
+                    for (int i = 0; i < subdir_count; i++) {
+                        free(subdirs[i]);
+                    }
+                    free(subdirs);
+                    subdirs = NULL;
+                    subdir_count = 0;
+                    current_index = 0;
+                }
+            }
+        }
+        else if (ch == '\n' || ch == '\r') { // ENTER - confirm selection
+            // If a subdirectory is displayed, navigate into it first
+            if (subdir_count > 0 && current_index < subdir_count) {
+                char new_path[PATH_MAX];
+                snprintf(new_path, sizeof(new_path), "%s/%s", current_path, subdirs[current_index]);
+                
+                if (chdir(new_path) == 0) {
+                    getcwd(current_path, sizeof(current_path));
+                }
+            }
+            break;
+        }
+        else if (ch == 'q' || ch == 'Q') { // Q to quit
+            printf("\033[?25h\n"); // Show cursor
+            // Restore original directory
+            chdir(original_path);
+            // Clean up
+            for (int i = 0; i < subdir_count; i++) {
+                free(subdirs[i]);
+            }
+            free(subdirs);
+            return NULL;
+        }
+    }
+    
+    printf("\033[?25h\n"); // Show cursor
+    
+    // Clean up
+    for (int i = 0; i < subdir_count; i++) {
+        free(subdirs[i]);
+    }
+    free(subdirs);
+    
+    // Restore original directory before returning
+    char* result = strdup(current_path);
+    chdir(original_path);
+    
+    return result;
+}
+
 int handle_directory_encrypt(void) {
     printf("\n");
     print_centered_header("Directory Encrypt", 0);
@@ -547,8 +805,9 @@ int handle_directory_encrypt(void) {
     // Directory selection options
     printf("\nDirectory selection options:\n");
     printf(" 1. Type directory path directly\n");
-    printf(" 2. Use file manager (navigate to directory)\n");
+    printf(" 2. Navigate with arrow keys\n");
-    printf("Enter choice (1-2): ");
+    printf(" 3. Use file manager (navigate to directory)\n");
+    printf("Enter choice (1-3) or 'esc' to cancel: ");
 
     char choice_input[10];
     char dir_path[512];
@@ -558,25 +817,59 @@ int handle_directory_encrypt(void) {
         return 1;
     }
 
-    if (atoi(choice_input) == 2) {
+    choice_input[strcspn(choice_input, "\n")] = 0;
+    
+    // Check for ESC/cancel
+    if (is_escape_input(choice_input)) {
+        printf("Returning to main menu...\n");
+        return 0;
+    }
+
+    int choice = atoi(choice_input);
+    
+    if (choice == 2) {
+        // Use arrow key navigation
+        char* selected = navigate_directory_interactive();
+        if (!selected) {
+            printf("Directory selection cancelled.\n");
+            return 0;
+        }
+        strncpy(dir_path, selected, sizeof(dir_path) - 1);
+        dir_path[sizeof(dir_path) - 1] = '\0';
+        free(selected);
+        printf("Selected: %s\n", dir_path);
+    }
+    else if (choice == 3) {
         // Use directory manager
         if (launch_directory_manager(".", dir_path, sizeof(dir_path)) != 0) {
             printf("Falling back to manual directory path entry.\n");
-            printf("Enter directory path to encrypt: ");
+            printf("Enter directory path to encrypt (or 'esc' to cancel): ");
             if (!fgets(dir_path, sizeof(dir_path), stdin)) {
                 printf("Error: Failed to read input\n");
                 return 1;
             }
             dir_path[strcspn(dir_path, "\n")] = 0;
+            
+            // Check for ESC/cancel
+            if (is_escape_input(dir_path)) {
+                printf("Returning to main menu...\n");
+                return 0;
+            }
         }
     } else {
         // Direct directory path input
-        printf("Enter directory path to encrypt: ");
+        printf("Enter directory path to encrypt (or 'esc' to cancel): ");
         if (!fgets(dir_path, sizeof(dir_path), stdin)) {
             printf("Error: Failed to read input\n");
             return 1;
         }
         dir_path[strcspn(dir_path, "\n")] = 0;
+        
+        // Check for ESC/cancel
+        if (is_escape_input(dir_path)) {
+            printf("Returning to main menu...\n");
+            return 0;
+        }
     }
 
     // Check if directory exists
@@ -595,23 +888,20 @@ int handle_directory_encrypt(void) {
         return 1;
     }
 
-    // Generate default output filename in the same directory as the source
+    // Generate default output filename - append .tar.gz.otp to the directory path
     char default_output[1024];
-    const char* dir_name = strrchr(dir_path, '/');
     
-    if (dir_name) {
+    // Remove trailing slash if present
-        // Has a path component - save in same directory
+    char clean_path[512];
-        size_t parent_len = dir_name - dir_path;
+    strncpy(clean_path, dir_path, sizeof(clean_path) - 1);
-        char parent_dir[1024];
+    clean_path[sizeof(clean_path) - 1] = '\0';
-        strncpy(parent_dir, dir_path, parent_len);
+    
-        parent_dir[parent_len] = '\0';
+    size_t path_len = strlen(clean_path);
-        
+    if (path_len > 0 && clean_path[path_len - 1] == '/') {
-        dir_name++; // Skip the '/'
+        clean_path[path_len - 1] = '\0';
-        snprintf(default_output, sizeof(default_output), "%s/%s.tar.gz.otp", parent_dir, dir_name);
-    } else {
-        // No path component - save in current directory
-        snprintf(default_output, sizeof(default_output), "%s.tar.gz.otp", dir_path);
     }
+    
+    snprintf(default_output, sizeof(default_output), "%s.tar.gz.otp", clean_path);
 
     // Get output filename
     char output_file[512];

src/util.c

@@ -19,6 +19,7 @@
 
 // Global variables for preferences
 static char default_pad_path[1024] = "";
+static char pads_directory[1024] = "";
 
 void show_progress(uint64_t current, uint64_t total, time_t start_time) {
     time_t now = time(NULL);
@@ -161,7 +162,8 @@ int launch_text_editor(const char* initial_content, char* result_buffer, size_t
 
 char* get_preferred_file_manager(void) {
     // Try file managers in order of preference
-    const char* file_managers[] = {"ranger", "fzf", "nnn", "lf", NULL};
+    // fzf is first because it's more intuitive with fuzzy search
+    const char* file_managers[] = {"fzf", "ranger", "nnn", "lf", NULL};
 
     for (int i = 0; file_managers[i] != NULL; i++) {
         char command[512];
@@ -177,7 +179,8 @@ char* get_preferred_file_manager(void) {
 int launch_file_manager(const char* start_directory, char* selected_file, size_t buffer_size) {
     char* fm = get_preferred_file_manager();
     if (!fm) {
-        printf("No file manager found. Please install ranger, fzf, nnn, or lf.\n");
+        printf("No file manager found. Please install fzf, ranger, nnn, or lf.\n");
+        printf("Recommended: sudo apt install fzf\n");
         printf("Falling back to manual file path entry.\n");
         return 1; // Fall back to manual entry
     }
@@ -189,6 +192,13 @@ int launch_file_manager(const char* start_directory, char* selected_file, size_t
     int result = 1;
 
     printf("Opening %s for file selection...\n", fm);
+    
+    // Show helpful instructions based on file manager
+    if (strcmp(fm, "fzf") == 0) {
+        printf("Instructions: Type to search, use arrow keys, press Enter to select\n");
+    } else if (strcmp(fm, "ranger") == 0) {
+        printf("Instructions: Arrow keys or j/k to navigate, Enter or l to select, q to quit\n");
+    }
 
     if (strcmp(fm, "ranger") == 0) {
         snprintf(command, sizeof(command), "cd '%s' && ranger --choosefile=%s",
@@ -243,7 +253,8 @@ int launch_file_manager(const char* start_directory, char* selected_file, size_t
 int launch_directory_manager(const char* start_directory, char* selected_dir, size_t buffer_size) {
     char* fm = get_preferred_file_manager();
     if (!fm) {
-        printf("No file manager found. Please install ranger, fzf, nnn, or lf.\n");
+        printf("No file manager found. Please install fzf, ranger, nnn, or lf.\n");
+        printf("Recommended: sudo apt install fzf\n");
         printf("Falling back to manual directory path entry.\n");
         return 1; // Fall back to manual entry
     }
@@ -255,7 +266,13 @@ int launch_directory_manager(const char* start_directory, char* selected_dir, si
     int result = 1;
 
     printf("Opening %s for directory selection...\n", fm);
-    printf("Navigate INTO the directory you want to encrypt, then press 'q' to quit and select it.\n");
+    
+    // Show helpful instructions based on file manager
+    if (strcmp(fm, "fzf") == 0) {
+        printf("Instructions: Type to search, use arrow keys, press Enter to select directory\n");
+    } else if (strcmp(fm, "ranger") == 0) {
+        printf("Instructions: Navigate INTO the directory, then press 'q' to quit and select it\n");
+    }
 
     if (strcmp(fm, "ranger") == 0) {
         snprintf(command, sizeof(command), "cd '%s' && ranger --choosedir=%s",
@@ -317,6 +334,19 @@ int launch_directory_manager(const char* start_directory, char* selected_dir, si
     return 1; // Fall back to manual entry
 }
 
+// Helper function to check if input contains ESC key
+int is_escape_input(const char* input) {
+    // Check for ESC character (ASCII 27) or empty input after ESC
+    if (input && (input[0] == 27 || (input[0] == '\0' && strlen(input) == 0))) {
+        return 1;
+    }
+    // Also check for literal "esc" or "ESC" typed
+    if (input && (strcasecmp(input, "esc") == 0 || strcasecmp(input, "q") == 0)) {
+        return 1;
+    }
+    return 0;
+}
+
 // Stdin detection functions implementation
 int has_stdin_data(void) {
     // Check if stdin is a pipe/redirect (not a terminal)
@@ -506,6 +536,11 @@ int load_preferences(void) {
             if (strcmp(key, "default_pad") == 0) {
                 strncpy(default_pad_path, value, sizeof(default_pad_path) - 1);
                 default_pad_path[sizeof(default_pad_path) - 1] = '\0';
+            } else if (strcmp(key, "pads_directory") == 0) {
+                strncpy(pads_directory, value, sizeof(pads_directory) - 1);
+                pads_directory[sizeof(pads_directory) - 1] = '\0';
+                // Apply the pads directory from config
+                set_current_pads_dir(pads_directory);
             }
         }
     }
@@ -1109,6 +1144,12 @@ int save_preferences(void) {
     fprintf(file, "# OTP Preferences File\n");
     fprintf(file, "# This file is automatically generated and updated by the OTP program\n\n");
 
+    // Save pads directory
+    const char* current_pads = get_current_pads_dir();
+    if (current_pads && strlen(current_pads) > 0) {
+        fprintf(file, "pads_directory=%s\n", current_pads);
+    }
+
     if (strlen(default_pad_path) > 0) {
         fprintf(file, "default_pad=%s\n", default_pad_path);
     }

tests/test_padding.sh

@@ -0,0 +1,129 @@
+#!/bin/bash
+# Test script for message padding implementation
+
+set -e
+
+echo "=== Testing Message Padding Implementation ==="
+echo ""
+
+# Colors
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+NC='\033[0m' # No Color
+
+# Test counter
+TESTS_PASSED=0
+TESTS_FAILED=0
+
+# Function to run a test
+run_test() {
+    local test_name="$1"
+    local test_command="$2"
+    
+    echo -n "Testing: $test_name... "
+    if eval "$test_command" > /dev/null 2>&1; then
+        echo -e "${GREEN}PASS${NC}"
+        ((TESTS_PASSED++))
+        return 0
+    else
+        echo -e "${RED}FAIL${NC}"
+        ((TESTS_FAILED++))
+        return 1
+    fi
+}
+
+# Create a small test pad if it doesn't exist
+if [ ! -f "pads/"*.pad ]; then
+    echo "Creating test pad (1MB)..."
+    ./build/otp-x86_64 generate 1MB
+    echo ""
+fi
+
+# Get the first pad checksum
+PAD_CHKSUM=$(ls pads/*.pad | head -n 1 | xargs basename | sed 's/.pad$//')
+
+echo "Using pad: ${PAD_CHKSUM:0:16}..."
+echo ""
+
+# Test 1: Encrypt and decrypt a short message (should be padded to 256 bytes)
+echo "Test 1: Short message (10 bytes -> 256 bytes padded)"
+TEST_MSG="Hello Test"
+ENCRYPTED=$(echo "$TEST_MSG" | ./build/otp-x86_64 encrypt ${PAD_CHKSUM:0:8})
+DECRYPTED=$(echo "$ENCRYPTED" | ./build/otp-x86_64 decrypt)
+
+if [ "$DECRYPTED" = "$TEST_MSG" ]; then
+    echo -e "${GREEN}✓ Short message encryption/decryption successful${NC}"
+    ((TESTS_PASSED++))
+else
+    echo -e "${RED}✗ Short message failed${NC}"
+    echo "  Expected: $TEST_MSG"
+    echo "  Got: $DECRYPTED"
+    ((TESTS_FAILED++))
+fi
+echo ""
+
+# Test 2: Encrypt and decrypt a medium message (should be padded to 512 bytes)
+echo "Test 2: Medium message (~300 bytes -> 512 bytes padded)"
+TEST_MSG=$(printf 'A%.0s' {1..300})
+ENCRYPTED=$(echo "$TEST_MSG" | ./build/otp-x86_64 encrypt ${PAD_CHKSUM:0:8})
+DECRYPTED=$(echo "$ENCRYPTED" | ./build/otp-x86_64 decrypt)
+
+if [ "$DECRYPTED" = "$TEST_MSG" ]; then
+    echo -e "${GREEN}✓ Medium message encryption/decryption successful${NC}"
+    ((TESTS_PASSED++))
+else
+    echo -e "${RED}✗ Medium message failed${NC}"
+    ((TESTS_FAILED++))
+fi
+echo ""
+
+# Test 3: Encrypt and decrypt with special characters
+echo "Test 3: Special characters and unicode"
+TEST_MSG="Hello! @#$%^&*() 测试"
+ENCRYPTED=$(echo "$TEST_MSG" | ./build/otp-x86_64 encrypt ${PAD_CHKSUM:0:8})
+DECRYPTED=$(echo "$ENCRYPTED" | ./build/otp-x86_64 decrypt)
+
+if [ "$DECRYPTED" = "$TEST_MSG" ]; then
+    echo -e "${GREEN}✓ Special characters encryption/decryption successful${NC}"
+    ((TESTS_PASSED++))
+else
+    echo -e "${RED}✗ Special characters failed${NC}"
+    echo "  Expected: $TEST_MSG"
+    echo "  Got: $DECRYPTED"
+    ((TESTS_FAILED++))
+fi
+echo ""
+
+# Test 4: File encryption/decryption with padding
+echo "Test 4: File encryption/decryption"
+TEST_FILE="/tmp/otp_test_file.txt"
+echo "This is a test file for OTP encryption with padding." > "$TEST_FILE"
+
+./build/otp-x86_64 -f "$TEST_FILE" ${PAD_CHKSUM:0:8} -a -o /tmp/test_encrypted.otp.asc
+./build/otp-x86_64 decrypt /tmp/test_encrypted.otp.asc -o /tmp/test_decrypted.txt
+
+if diff "$TEST_FILE" /tmp/test_decrypted.txt > /dev/null 2>&1; then
+    echo -e "${GREEN}✓ File encryption/decryption successful${NC}"
+    ((TESTS_PASSED++))
+else
+    echo -e "${RED}✗ File encryption/decryption failed${NC}"
+    ((TESTS_FAILED++))
+fi
+
+# Cleanup
+rm -f "$TEST_FILE" /tmp/test_encrypted.otp.asc /tmp/test_decrypted.txt
+echo ""
+
+# Summary
+echo "=== Test Summary ==="
+echo -e "Tests passed: ${GREEN}${TESTS_PASSED}${NC}"
+echo -e "Tests failed: ${RED}${TESTS_FAILED}${NC}"
+echo ""
+
+if [ $TESTS_FAILED -eq 0 ]; then
+    echo -e "${GREEN}All tests passed!${NC}"
+    exit 0
+else
+    echo -e "${RED}Some tests failed.${NC}"
+    exit 1
+fi