Reupload

src/entropy.c

@@ -457,20 +457,17 @@ int derive_chacha20_params(const unsigned char* entropy_data, size_t entropy_siz
     return 0; // Success
 }
 
-// Collect entropy from binary file
-int collect_file_entropy(unsigned char* entropy_buffer, size_t target_bytes,
-                        size_t* collected_bytes, int display_progress) {
+// Get file path and size information for entropy collection
+int get_file_entropy_info(char* file_path, size_t max_path_len, size_t* file_size, int display_progress) {
     if (display_progress) {
         print_centered_header("File Entropy Collection", 0);
         printf("Load entropy from binary file (.bin format)\n");
-        printf("Target: %zu bytes\n", target_bytes);
     }
 
     printf("Enter path to binary entropy file: ");
     fflush(stdout);
 
-    char file_path[512];
-    if (!fgets(file_path, sizeof(file_path), stdin)) {
+    if (!fgets(file_path, max_path_len, stdin)) {
         printf("Error: Failed to read input\n");
         return 1;
     }
@@ -490,12 +487,31 @@ int collect_file_entropy(unsigned char* entropy_buffer, size_t target_bytes,
         return 1;
     }
 
-    size_t file_size = file_stat.st_size;
-    if (file_size == 0) {
+    *file_size = file_stat.st_size;
+    if (*file_size == 0) {
         printf("Error: File is empty\n");
         return 1;
     }
 
+    if (display_progress) {
+        printf("✓ File found: %s\n", file_path);
+        printf("  Size: %zu bytes\n", *file_size);
+    }
+
+    return 0; // Success
+}
+
+// Collect entropy from binary file (legacy function for backward compatibility)
+int collect_file_entropy(unsigned char* entropy_buffer, size_t target_bytes,
+                        size_t* collected_bytes, int display_progress) {
+    char file_path[512];
+    size_t file_size;
+
+    // Get file path and size first
+    if (get_file_entropy_info(file_path, sizeof(file_path), &file_size, display_progress) != 0) {
+        return 1;
+    }
+
     if (file_size < target_bytes) {
         printf("Warning: File size (%zu bytes) is smaller than target (%zu bytes)\n",
                file_size, target_bytes);

src/pads.c

@@ -15,6 +15,7 @@
 #include <termios.h>
 #include <fcntl.h>
 #include <math.h>
+#include <errno.h>
 #include "../include/otp.h"
 
 
@@ -1021,6 +1022,61 @@ int handle_delete_pad(const char* chksum) {
     return 0;
 }
 
+// Helper function to temporarily make pad writable and store original permissions
+static int make_pad_temporarily_writable(const char* pad_path, mode_t* original_mode) {
+    struct stat st;
+    
+    // Get current permissions
+    if (stat(pad_path, &st) != 0) {
+        printf("Error: Cannot get pad file permissions: %s\n", strerror(errno));
+        return 1;
+    }
+    
+    // Store original permissions
+    *original_mode = st.st_mode;
+    
+    // Check if already writable
+    if (st.st_mode & S_IWUSR) {
+        return 0; // Already writable, no change needed
+    }
+    
+    // Make writable by adding write permission for owner
+    mode_t new_mode = st.st_mode | S_IWUSR;
+    if (chmod(pad_path, new_mode) != 0) {
+        printf("Error: Cannot make pad file writable: %s\n", strerror(errno));
+        return 1;
+    }
+    
+    printf("✓ Temporarily made pad writable for entropy addition\n");
+    return 0;
+}
+
+// Helper function to restore original pad permissions
+static int restore_pad_permissions(const char* pad_path, mode_t original_mode) {
+    struct stat st;
+    
+    // Get current permissions to check if they changed
+    if (stat(pad_path, &st) != 0) {
+        printf("Warning: Cannot check current pad permissions: %s\n", strerror(errno));
+        return 1;
+    }
+    
+    // Only restore if permissions are different from original
+    if (st.st_mode != original_mode) {
+        if (chmod(pad_path, original_mode) != 0) {
+            printf("Warning: Cannot restore original pad permissions: %s\n", strerror(errno));
+            return 1;
+        }
+        
+        // Check if we restored to read-only
+        if (!(original_mode & S_IWUSR)) {
+            printf("✓ Restored pad to read-only protection\n");
+        }
+    }
+    
+    return 0;
+}
+
 int handle_add_entropy_to_pad(const char* pad_chksum) {
     char header_text[128];
     snprintf(header_text, sizeof(header_text), "Add Entropy to Pad: %.16s...", pad_chksum);
@@ -1075,11 +1131,13 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
 
     size_t target_bytes;
 
+    // Declare variables that may be used later
+    char pad_path[1024] = "";
+    char state_path[1024] = "";
+
     // For TrueRNG, automatically use the full pad size
     if (entropy_source == ENTROPY_SOURCE_TRUERNG) {
         // Get the pad file size
-        char pad_path[1024];
-        char state_path[1024];
         get_pad_path(pad_chksum, pad_path, state_path);
 
         struct stat pad_stat;
@@ -1089,17 +1147,51 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
         }
 
         target_bytes = (size_t)pad_stat.st_size;
-        printf("\nTrueRNG selected - will enhance entire pad with hardware entropy\n");
+        printf("\nHardware RNG selected - will enhance entire pad with hardware entropy\n");
         printf("Pad size: %.2f GB (%zu bytes)\n",
-               (double)target_bytes / (1024.0 * 1024.0 * 1024.0), target_bytes);
+                (double)target_bytes / (1024.0 * 1024.0 * 1024.0), target_bytes);
+    } else if (entropy_source == ENTROPY_SOURCE_FILE) {
+        // Special handling for file entropy - ask for file path first
+        char file_path[512];
+        size_t file_size;
+
+        if (get_file_entropy_info(file_path, sizeof(file_path), &file_size, 1) != 0) {
+            return 1;
+        }
+
+        // Get pad size for comparison
+        get_pad_path(pad_chksum, pad_path, state_path);
+        struct stat pad_stat;
+        if (stat(pad_path, &pad_stat) != 0) {
+            printf("Error: Cannot get pad file size\n");
+            return 1;
+        }
+        uint64_t pad_size = pad_stat.st_size;
+
+        printf("\nFile vs Pad Size Analysis:\n");
+        printf("  Entropy file: %zu bytes\n", file_size);
+        printf("  Target pad: %.2f GB (%lu bytes)\n",
+               (double)pad_size / (1024.0 * 1024.0 * 1024.0), pad_size);
+
+        // Smart method selection based on file size vs pad size
+        if (file_size >= pad_size) {
+            printf("✓ Using Direct XOR method (file ≥ pad size)\n");
+            printf("  Method: Direct XOR - entropy file will be distributed across entire pad\n");
+            target_bytes = file_size; // Use entire file
+        } else {
+            printf("✓ Using ChaCha20 method (file < pad size)\n");
+            printf("  Method: ChaCha20 - entropy will be expanded to fill entire pad\n");
+            target_bytes = file_size; // Use entire file, ChaCha20 will expand it
+        }
+
+        printf("  Target entropy: %zu bytes\n", target_bytes);
     } else {
         // For other entropy sources, show the selection menu
         printf("\nEntropy collection options:\n");
         printf(" 1. Recommended (2048 bytes) - Optimal security\n");
         printf(" 2. Minimum (1024 bytes) - Good security\n");
-        printf(" 3. Maximum (4096 bytes) - Maximum security\n");
-        printf(" 4. Custom amount\n");
-        printf("Enter choice (1-4): ");
+        printf(" 3. Custom amount\n");
+        printf("Enter choice (1-3): ");
 
         char amount_input[10];
         if (!fgets(amount_input, sizeof(amount_input), stdin)) {
@@ -1118,10 +1210,7 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
                 target_bytes = 1024;
                 break;
             case 3:
-                target_bytes = 4096;
-                break;
-            case 4:
-                printf("Enter custom amount (512-8192 bytes): ");
+                printf("Enter custom amount (512+ bytes): ");
                 char custom_input[32];
                 if (!fgets(custom_input, sizeof(custom_input), stdin)) {
                     printf("Error: Failed to read input\n");
@@ -1129,8 +1218,8 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
                 }
 
                 size_t custom_amount = (size_t)atoi(custom_input);
-                if (custom_amount < 512 || custom_amount > 8192) {
-                    printf("Error: Invalid amount. Must be between 512 and 8192 bytes.\n");
+                if (custom_amount < 512) {
+                    printf("Error: Invalid amount. Must be at least 512 bytes.\n");
                     return 1;
                 }
                 target_bytes = custom_amount;
@@ -1143,11 +1232,146 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
 
     // For TrueRNG, detect all devices and present selection menu
     if (entropy_source == ENTROPY_SOURCE_TRUERNG) {
+        // Detect available hardware RNG devices
+        hardware_rng_device_t devices[10];
+        int num_devices_found = 0;
+
+        if (detect_all_hardware_rng_devices(devices, 10, &num_devices_found) != 0) {
+            printf("Error: Failed to detect hardware RNG devices\n");
+            return 1;
+        }
+
+        if (num_devices_found == 0) {
+            printf("No hardware RNG devices found.\n");
+            printf("\nSupported devices:\n");
+            printf("  - TrueRNG Original (VID: %s, PID: %s)\n", TRUERNG_VID, TRUERNG_ORIGINAL_PID);
+            printf("  - TrueRNG Pro (VID: %s, PID: %s)\n", TRUERNG_VID, TRUERNG_PRO_PID);
+            printf("  - TrueRNG Pro V2 (VID: %s, PID: %s)\n", TRUERNG_VID, TRUERNG_PRO_V2_PID);
+            printf("\nPlease connect a TrueRNG or SwiftRNG device and try again.\n");
+            return 1;
+        }
+
+        // Select device interactively
+        hardware_rng_device_t selected_device;
+        if (select_hardware_rng_device_interactive(devices, num_devices_found, &selected_device) != 0) {
+            printf("Device selection cancelled.\n");
+            return 1;
+        }
+
+        // Test device speed and estimate completion time
+        printf("\nTesting %s connection and speed...\n", selected_device.friendly_name);
+        printf("Device: %s (Type: %d)\n", selected_device.port_path, selected_device.device_type);
+
+        // Test with smaller amount (10KB) to avoid hanging on slow/unresponsive devices
+        const size_t test_bytes = 10 * 1024; // 10KB test (reduced from 100KB)
+        unsigned char* test_buffer = malloc(test_bytes);
+        if (!test_buffer) {
+            printf("Error: Cannot allocate test buffer\n");
+            return 1;
+        }
+
+        size_t test_collected = 0;
+        time_t test_start = time(NULL);
+
+        // Use non-blocking test to avoid hanging
+        int test_result = collect_truerng_entropy_from_device(&selected_device, test_buffer, test_bytes, &test_collected, 0);
+
+        time_t test_end = time(NULL);
+        double test_time = difftime(test_end, test_start);
+
+        free(test_buffer);
+
+        if (test_result != 0) {
+            printf("Error: Device test failed - cannot establish connection\n");
+            printf("This may be due to:\n");
+            printf("  - Device not properly connected\n");
+            printf("  - Incorrect device type identification\n");
+            printf("  - Serial port configuration issues\n");
+            printf("  - Device requires different baud rate or settings\n");
+            return 1;
+        }
+
+        if (test_collected == 0) {
+            printf("Error: Device returned no data - check device connection and type\n");
+            return 1;
+        }
+
+        if (test_time < 1.0) {
+            test_time = 1.0; // Minimum 1 second to avoid division by zero
+        }
+
+        // Calculate speed and estimate completion time
+        double bytes_per_second = test_collected / test_time;
+        double estimated_seconds = target_bytes / bytes_per_second;
+        double estimated_minutes = estimated_seconds / 60.0;
+        double estimated_hours = estimated_minutes / 60.0;
+
+        printf("✓ Device test successful!\n");
+        printf("  Test collected: %zu bytes in %.1f seconds\n", test_collected, test_time);
+        printf("  Speed: %.1f KB/s (%.1f MB/s)\n", bytes_per_second / 1024.0, bytes_per_second / (1024.0 * 1024.0));
+
+        printf("\nPad enhancement estimate:\n");
+        printf("  Pad size: %.2f GB (%zu bytes)\n", (double)target_bytes / (1024.0 * 1024.0 * 1024.0), target_bytes);
+
+        if (estimated_hours >= 1.0) {
+            printf("  Estimated time: %.1f hours\n", estimated_hours);
+        } else if (estimated_minutes >= 1.0) {
+            printf("  Estimated time: %.1f minutes\n", estimated_minutes);
+        } else {
+            printf("  Estimated time: %.1f seconds\n", estimated_seconds);
+        }
+
+        // Store original permissions and make pad temporarily writable
+        mode_t original_mode;
+        if (make_pad_temporarily_writable(pad_path, &original_mode) != 0) {
+            // If we can't make it writable, check if it's a filesystem issue
+            if (access(pad_path, F_OK) == 0 && access(pad_path, W_OK) != 0) {
+                printf("\nError: Cannot make pad file writable: %s\n", pad_path);
+                printf("Reason: %s\n", strerror(errno));
+
+                if (errno == EROFS) {
+                    printf("The filesystem appears to be read-only.\n");
+                    printf("This commonly occurs with:\n");
+                    printf("  - USB drives mounted read-only\n");
+                    printf("  - CD-ROM/DVD drives\n");
+                    printf("  - Network filesystems with read-only access\n");
+                } else if (errno == EACCES) {
+                    printf("Permission denied. Check file permissions.\n");
+                }
+
+                printf("\nTo fix this issue:\n");
+                printf("1. Remount the drive read-write: sudo mount -o remount,rw %s\n", pad_path);
+                printf("2. Copy the pad to local storage, enhance it, then copy back\n");
+                printf("3. Check file permissions: ls -la '%s'\n", pad_path);
+            }
+            return 1;
+        }
+
+        // Ask user for confirmation
+        printf("\n⚠ This will modify the entire pad file and update its checksum.\n");
+        printf("The process cannot be interrupted once started.\n");
+        printf("\nDo you want to continue with hardware entropy enhancement? (y/N): ");
+
+        char confirm_input[10];
+        if (!fgets(confirm_input, sizeof(confirm_input), stdin)) {
+            printf("Error: Failed to read input\n");
+            return 1;
+        }
+
+        if (toupper(confirm_input[0]) != 'Y') {
+            printf("Hardware entropy enhancement cancelled.\n");
+            return 0;
+        }
+
+        printf("\nStarting hardware entropy enhancement...\n");
+
         // Use streaming collection with selected device
-        int result = collect_truerng_entropy_streaming_from_device(NULL, pad_chksum, target_bytes, 1, 1);
+        int result = collect_truerng_entropy_streaming_from_device(&selected_device, pad_chksum, target_bytes, 1, 1);
 
         if (result != 0) {
             printf("Error: TrueRNG streaming entropy collection failed\n");
+            // Restore original permissions before returning
+            restore_pad_permissions(pad_path, original_mode);
             return 1;
         }
 
@@ -1161,11 +1385,21 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
             printf("  Old checksum: %.16s...\n", pad_chksum);
             printf("  New checksum: %.16s...\n", new_chksum);
             printf("✓ Pad files renamed to new checksum\n");
+            
+            // Restore permissions on the new pad file
+            char new_pad_path[1024];
+            const char* pads_dir = get_current_pads_dir();
+            snprintf(new_pad_path, sizeof(new_pad_path), "%s/%s.pad", pads_dir, new_chksum);
+            restore_pad_permissions(new_pad_path, original_mode);
         } else if (checksum_result == 2) {
             printf("ℹ Checksum unchanged (unusual but not an error)\n");
+            // Restore original permissions
+            restore_pad_permissions(pad_path, original_mode);
         } else {
             printf("⚠ Warning: Checksum update failed (entropy was added successfully)\n");
             printf("  You may need to manually handle the checksum update\n");
+            // Restore original permissions before returning
+            restore_pad_permissions(pad_path, original_mode);
             return 1;
         }
 
@@ -1205,6 +1439,21 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
 
     printf("\nProcessing entropy and modifying pad...\n");
 
+    // Get pad path and manage permissions for traditional entropy addition
+    if (strlen(pad_path) == 0) {
+        get_pad_path(pad_chksum, pad_path, state_path);
+    }
+    
+    // Store original permissions and make pad temporarily writable
+    mode_t original_mode;
+    if (make_pad_temporarily_writable(pad_path, &original_mode) != 0) {
+        printf("Error: Cannot make pad file writable for entropy addition\n");
+        // Clear entropy buffer for security
+        memset(entropy_buffer, 0, MAX_ENTROPY_BUFFER);
+        free(entropy_buffer);
+        return 1;
+    }
+
     // Add entropy to pad
     result = add_entropy_to_pad(pad_chksum, entropy_buffer, collected_bytes, 1);
 
@@ -1214,6 +1463,36 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
 
     if (result != 0) {
         printf("Error: Failed to add entropy to pad\n");
+        // Restore original permissions before returning
+        restore_pad_permissions(pad_path, original_mode);
+        return 1;
+    }
+
+    // Update checksum after entropy addition for traditional methods
+    printf("\n🔄 Updating pad checksum...\n");
+    char new_chksum[65];
+    int checksum_result = update_pad_checksum_after_entropy(pad_chksum, new_chksum);
+
+    if (checksum_result == 0) {
+        printf("✓ Pad checksum updated successfully\n");
+        printf("  Old checksum: %.16s...\n", pad_chksum);
+        printf("  New checksum: %.16s...\n", new_chksum);
+        printf("✓ Pad files renamed to new checksum\n");
+        
+        // Restore permissions on the new pad file
+        char new_pad_path[1024];
+        const char* pads_dir = get_current_pads_dir();
+        snprintf(new_pad_path, sizeof(new_pad_path), "%s/%s.pad", pads_dir, new_chksum);
+        restore_pad_permissions(new_pad_path, original_mode);
+    } else if (checksum_result == 2) {
+        printf("ℹ Checksum unchanged (unusual but not an error)\n");
+        // Restore original permissions
+        restore_pad_permissions(pad_path, original_mode);
+    } else {
+        printf("⚠ Warning: Checksum update failed (entropy was added successfully)\n");
+        printf("  You may need to manually handle the checksum update\n");
+        // Restore original permissions before returning
+        restore_pad_permissions(pad_path, original_mode);
         return 1;
     }
 

src/trng.c

@@ -15,6 +15,7 @@
 #include <termios.h>
 #include <fcntl.h>
 #include <math.h>
+#include <errno.h>
 #include "../nostr_chacha20.h"
 #include "../include/otp.h"
 
@@ -35,10 +36,10 @@ int collect_truerng_entropy(unsigned char* entropy_buffer, size_t target_bytes,
         if (display_progress) {
             printf("No hardware RNG devices found.\n");
             printf("\nSupported devices:\n");
-            printf("  - TrueRNG/SwiftRNG (PID: %s, VID: %s)\n", TRUERNG_VID, TRUERNG_PID);
-            printf("  - TrueRNGpro/SwiftRNGpro (PID: %s, VID: %s)\n", TRUERNGPRO_VID, TRUERNGPRO_PID);
-            printf("  - TrueRNGproV2/SwiftRNGproV2 (PID: %s, VID: %s)\n", TRUERNGPROV2_VID, TRUERNGPROV2_PID);
-            printf("\nPlease connect a TrueRNG or SwiftRNG device and try again.\n");
+            printf("  - TrueRNG Original (VID: %s, PID: %s)\n", TRUERNG_VID, TRUERNG_ORIGINAL_PID);
+            printf("  - TrueRNG Pro (VID: %s, PID: %s)\n", TRUERNG_VID, TRUERNG_PRO_PID);
+            printf("  - TrueRNG Pro V2 (VID: %s, PID: %s)\n", TRUERNG_VID, TRUERNG_PRO_V2_PID);
+            printf("\nPlease connect a TrueRNG device and try again.\n");
         }
         return 1;
     }
@@ -68,47 +69,504 @@ int collect_truerng_entropy(unsigned char* entropy_buffer, size_t target_bytes,
     return 0;
 }
 
-// Wrapper function to match the header declaration
-// Note: Full implementation moved to otp.c during modularization
-// This is a placeholder that should be implemented when the full streaming
-// functionality is moved to the trng module
+// Streaming entropy collection directly to pad file
 int collect_truerng_entropy_streaming_from_device(const hardware_rng_device_t* device, const char* pad_chksum,
                                                   size_t total_bytes, int display_progress, int entropy_mode) {
-    // For now, return an error - full implementation needs to be moved from otp.c
-    (void)device; // Suppress unused parameter warning
-    (void)pad_chksum;
-    (void)total_bytes;
-    (void)display_progress;
-    (void)entropy_mode;
+    (void)entropy_mode; // Suppress unused parameter warning
+    if (!device || !pad_chksum || total_bytes == 0) {
+        return 1; // Invalid parameters
+    }
 
-    fprintf(stderr, "Error: collect_truerng_entropy_streaming_from_device not yet implemented in modular version\n");
-    return 1; // Error
+
+    // Get pad file path
+    char pad_path[1024];
+    char state_path[1024];
+    get_pad_path(pad_chksum, pad_path, state_path);
+
+    // Check if pad exists and get size
+    struct stat pad_stat;
+    if (stat(pad_path, &pad_stat) != 0) {
+        if (display_progress) {
+            printf("Error: Pad file not found: %s\n", pad_path);
+        }
+        return 1;
+    }
+
+    uint64_t pad_size = pad_stat.st_size;
+    if (total_bytes > pad_size) {
+        if (display_progress) {
+            printf("Error: Requested entropy (%zu bytes) exceeds pad size (%lu bytes)\n", total_bytes, pad_size);
+        }
+        return 1;
+    }
+
+    // Open the RNG device
+    int device_fd = open(device->port_path, O_RDONLY | O_NOCTTY);
+    if (device_fd < 0) {
+        if (display_progress) {
+            printf("Error: Cannot open RNG device %s: %s\n", device->port_path, strerror(errno));
+        }
+        return 1;
+    }
+
+    // Configure serial port for this device type
+    if (configure_rng_serial_port(device_fd, device->device_type) != 0) {
+        if (display_progress) {
+            printf("Error: Failed to configure serial port for %s\n", device->friendly_name);
+        }
+        close(device_fd);
+        return 1;
+    }
+
+    // Standard delay for TrueRNG devices
+    usleep(100000); // 100ms
+
+    // Open pad file for read/write
+    FILE* pad_file = fopen(pad_path, "r+b");
+    if (!pad_file) {
+        if (display_progress) {
+            printf("Error: Cannot open pad file for modification: %s\n", pad_path);
+            printf("Reason: %s\n", strerror(errno));
+
+            // Provide additional diagnostics
+            if (errno == EROFS) {
+                printf("The filesystem appears to be read-only. Check if the drive is mounted read-only.\n");
+            } else if (errno == EACCES) {
+                printf("Permission denied. Check file permissions and mount options.\n");
+            } else if (errno == ENOENT) {
+                printf("File not found. The pad file may have been moved or deleted.\n");
+            } else if (errno == EISDIR) {
+                printf("Path is a directory, not a file.\n");
+            } else {
+                printf("This may be due to filesystem limitations or mount options.\n");
+            }
+
+            printf("\nTroubleshooting suggestions:\n");
+            printf("1. Ensure the external drive is mounted read-write: mount -o remount,rw /media/teknari/OTP_01\n");
+            printf("2. Check file permissions: ls -la '%s'\n", pad_path);
+            printf("3. Verify the drive supports the required operations\n");
+            printf("4. Try copying the pad to local storage, enhancing it, then copying back\n");
+        }
+        close(device_fd);
+        return 1;
+    }
+
+    if (display_progress) {
+        printf("Streaming entropy from %s to pad...\n", device->friendly_name);
+        printf("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1024.0*1024.0*1024.0), pad_size);
+        printf("Enhancing entire pad with hardware entropy\n");
+    }
+
+    // Process pad in chunks
+    unsigned char buffer[64 * 1024]; // 64KB chunks
+    size_t bytes_processed = 0;
+    time_t start_time = time(NULL);
+    int error_occurred = 0;
+
+    while (bytes_processed < total_bytes && !error_occurred) {
+        size_t chunk_size = sizeof(buffer);
+        if (total_bytes - bytes_processed < chunk_size) {
+            chunk_size = total_bytes - bytes_processed;
+        }
+
+        // Read entropy from device
+        ssize_t entropy_read = read(device_fd, buffer, chunk_size);
+        if (entropy_read < 0) {
+            if (errno == EINTR) {
+                continue; // Interrupted, try again
+            }
+            if (display_progress) {
+                printf("Error: Failed to read from TrueRNG device: %s\n", strerror(errno));
+                printf("Device may have been disconnected during operation.\n");
+            }
+            error_occurred = 1;
+            break;
+        }
+
+        if (entropy_read == 0) {
+            if (display_progress) {
+                printf("Error: TrueRNG device returned no data (device disconnected?)\n");
+            }
+            error_occurred = 1;
+            break;
+        }
+
+        // Read current pad data at this position
+        if (fseek(pad_file, bytes_processed, SEEK_SET) != 0) {
+            if (display_progress) {
+                printf("Error: Cannot seek to position %zu in pad file\n", bytes_processed);
+            }
+            error_occurred = 1;
+            break;
+        }
+
+        unsigned char pad_data[64 * 1024];
+        size_t pad_read = fread(pad_data, 1, entropy_read, pad_file);
+        if (pad_read != (size_t)entropy_read) {
+            if (display_progress) {
+                printf("Error: Cannot read pad data at position %zu\n", bytes_processed);
+            }
+            error_occurred = 1;
+            break;
+        }
+
+        // XOR entropy with existing pad data
+        for (size_t i = 0; i < (size_t)entropy_read; i++) {
+            pad_data[i] ^= buffer[i];
+        }
+
+        // Seek back and write modified data
+        if (fseek(pad_file, bytes_processed, SEEK_SET) != 0) {
+            if (display_progress) {
+                printf("Error: Cannot seek back to position %zu in pad file\n", bytes_processed);
+            }
+            error_occurred = 1;
+            break;
+        }
+
+        if (fwrite(pad_data, 1, entropy_read, pad_file) != (size_t)entropy_read) {
+            if (display_progress) {
+                printf("Error: Cannot write modified pad data\n");
+            }
+            error_occurred = 1;
+            break;
+        }
+
+        bytes_processed += entropy_read;
+
+        // Show progress for large pads
+        if (display_progress && bytes_processed % (64 * 1024 * 1024) == 0) { // Every 64MB
+            show_progress(bytes_processed, total_bytes, start_time);
+        }
+    }
+
+    close(device_fd);
+    fclose(pad_file);
+
+    if (error_occurred) {
+        return 1;
+    }
+
+    if (display_progress) {
+        show_progress(total_bytes, total_bytes, start_time);
+        printf("\n✓ Successfully streamed %zu bytes of hardware entropy to pad\n", bytes_processed);
+    }
+
+    return 0;
 }
 
 // Detect all available hardware RNG devices
 int detect_all_hardware_rng_devices(hardware_rng_device_t* devices, int max_devices, int* num_devices_found) {
     *num_devices_found = 0;
 
-    // For now, return empty list - full implementation would scan /dev for TrueRNG devices
-    // This is a placeholder that should be implemented when the full TRNG functionality
-    // is moved to the trng module
+    // Scan /dev directory for serial devices (ttyUSB*, ttyACM*)
+    DIR* dev_dir = opendir("/dev");
+    if (!dev_dir) {
+        return 1; // Error opening /dev
+    }
 
-    (void)devices; // Suppress unused parameter warning
-    (void)max_devices;
+    struct dirent* entry;
+    while ((entry = readdir(dev_dir)) != NULL && *num_devices_found < max_devices) {
+        // Check for serial device patterns
+        if (strncmp(entry->d_name, "ttyUSB", 6) == 0 || strncmp(entry->d_name, "ttyACM", 6) == 0) {
+            char device_path[512]; // Increased buffer size to prevent truncation
+            int ret = snprintf(device_path, sizeof(device_path), "/dev/%s", entry->d_name);
+            if (ret >= (int)sizeof(device_path)) {
+                continue; // Skip if path would be truncated
+            }
 
-    return 0; // Success but no devices found
+            // Check if this is a TrueRNG/SwiftRNG device by reading VID/PID
+            char vid[5], pid[5];
+            if (read_usb_device_info(device_path, vid, pid) == 0) {
+                hardware_rng_device_type_t device_type = 0;
+
+                // Check against known TrueRNG VID/PID combinations
+                if (strcmp(vid, TRUERNG_VID) == 0 && strcmp(pid, TRUERNG_ORIGINAL_PID) == 0) {
+                    device_type = TRUERNG_ORIGINAL;
+                } else if (strcmp(vid, TRUERNG_VID) == 0 && strcmp(pid, TRUERNG_PRO_PID) == 0) {
+                    device_type = TRUERNG_PRO;
+                } else if (strcmp(vid, TRUERNG_VID) == 0 && strcmp(pid, TRUERNG_PRO_V2_PID) == 0) {
+                    device_type = TRUERNG_PRO_V2;
+                }
+
+                if (device_type != 0) {
+                    // Found a TrueRNG/SwiftRNG device
+                    hardware_rng_device_t* device = &devices[*num_devices_found];
+
+                    strncpy(device->port_path, device_path, sizeof(device->port_path) - 1);
+                    device->device_type = device_type;
+                    strncpy(device->friendly_name, get_truerng_device_name(device_type), sizeof(device->friendly_name) - 1);
+
+                    // Assume device is working if VID/PID matches (no test needed)
+                    device->is_working = 1;
+
+                    (*num_devices_found)++;
+                }
+            }
+        }
+    }
+
+    closedir(dev_dir);
+    return 0; // Success
+}
+
+// Configure serial port for different RNG device types
+int configure_rng_serial_port(int fd, hardware_rng_device_type_t device_type) {
+    (void)device_type; // Suppress unused parameter warning - all TrueRNG devices use same config
+    struct termios tty;
+
+    if (tcgetattr(fd, &tty) != 0) {
+        return 1; // Error getting terminal attributes
+    }
+
+    // TrueRNG configuration - traditional serial settings
+    // TrueRNG devices: 115200 baud, 8N1, no flow control
+    cfsetospeed(&tty, B115200);
+    cfsetispeed(&tty, B115200);
+    tty.c_cflag = (tty.c_cflag & ~CSIZE) | CS8;     // 8-bit chars
+    tty.c_cflag |= CLOCAL | CREAD;                   // ignore modem controls, enable reading
+    tty.c_cflag &= ~(PARENB | PARODD);              // no parity
+    tty.c_cflag &= ~CSTOPB;                          // 1 stop bit
+    tty.c_cflag &= ~CRTSCTS;                         // no hardware flow control
+    tty.c_iflag &= ~(IXON | IXOFF | IXANY);          // no software flow control
+    tty.c_iflag &= ~(ICANON | ECHO | ECHOE | ISIG);  // raw mode
+    tty.c_oflag &= ~OPOST;                           // raw output
+
+    // Set timeouts for TrueRNG
+    tty.c_cc[VMIN] = 1;   // read at least 1 character
+    tty.c_cc[VTIME] = 10; // 1 second timeout
+
+    if (tcsetattr(fd, TCSANOW, &tty) != 0) {
+        return 1; // Error setting terminal attributes
+    }
+
+    // Flush any existing data
+    tcflush(fd, TCIOFLUSH);
+
+    return 0; // Success
 }
 
 // Collect entropy from a specific TrueRNG device
 int collect_truerng_entropy_from_device(const hardware_rng_device_t* device, unsigned char* entropy_buffer,
                                        size_t target_bytes, size_t* collected_bytes, int display_progress) {
-    // For now, return an error - full implementation needs to be moved from otp.c
-    (void)device; // Suppress unused parameter warning
-    (void)entropy_buffer;
-    (void)target_bytes;
-    (void)collected_bytes;
-    (void)display_progress;
+    if (!device || !entropy_buffer || !collected_bytes || target_bytes == 0) {
+        return 1; // Invalid parameters
+    }
 
-    fprintf(stderr, "Error: collect_truerng_entropy_from_device not yet implemented in modular version\n");
-    return 1; // Error
-}
+
+    // Open the TrueRNG device
+    int device_fd = open(device->port_path, O_RDONLY | O_NOCTTY);
+    if (device_fd < 0) {
+        if (display_progress) {
+            printf("Error: Cannot open RNG device %s: %s\n", device->port_path, strerror(errno));
+        }
+        return 1;
+    }
+
+    // Configure serial port for this device type
+    if (configure_rng_serial_port(device_fd, device->device_type) != 0) {
+        if (display_progress) {
+            printf("Error: Failed to configure serial port for %s\n", device->friendly_name);
+        }
+        close(device_fd);
+        return 1;
+    }
+
+    // Standard delay for TrueRNG devices
+    usleep(100000); // 100ms
+
+    if (display_progress) {
+        printf("Collecting %zu bytes from %s...\n", target_bytes, device->friendly_name);
+    }
+
+    // Read entropy data with timeout protection
+    size_t total_read = 0;
+    time_t start_time = time(NULL);
+    time_t last_progress_time = start_time;
+
+    while (total_read < target_bytes) {
+        // Check for overall timeout (5 minutes max for large collections)
+        time_t current_time = time(NULL);
+        if (difftime(current_time, start_time) > 300) { // 5 minutes timeout
+            if (display_progress) {
+                printf("Error: Collection timeout - device may be unresponsive\n");
+            }
+            close(device_fd);
+            return 1;
+        }
+
+        size_t remaining = target_bytes - total_read;
+        size_t chunk_size = (remaining > 4096) ? 4096 : remaining; // Read in 4KB chunks
+
+        ssize_t bytes_read = read(device_fd, entropy_buffer + total_read, chunk_size);
+        if (bytes_read < 0) {
+            if (errno == EINTR) {
+                continue; // Interrupted, try again
+            }
+            if (errno == EAGAIN || errno == EWOULDBLOCK) {
+                // Timeout occurred, check if we have enough data for a test
+                if (total_read > 0 && target_bytes > 1024) {
+                    // For testing purposes, we have enough data
+                    break;
+                }
+                // For small collections, this is an error
+                if (display_progress) {
+                    printf("Error: Device read timeout - no data received\n");
+                }
+                close(device_fd);
+                return 1;
+            }
+            if (display_progress) {
+                printf("Error: Failed to read from TrueRNG device: %s\n", strerror(errno));
+                printf("Device may have been disconnected.\n");
+            }
+            close(device_fd);
+            return 1;
+        }
+
+        if (bytes_read == 0) {
+            // End of data - this shouldn't happen for RNG devices
+            if (total_read == 0) {
+                if (display_progress) {
+                    printf("Error: TrueRNG device returned no data (device disconnected or misconfigured?)\n");
+                }
+                close(device_fd);
+                return 1;
+            } else {
+                // We have some data, might be enough for testing
+                break;
+            }
+        }
+
+        total_read += bytes_read;
+
+        // Show progress
+        if (display_progress && (total_read % 1024 == 0 || difftime(current_time, last_progress_time) >= 1)) {
+            show_progress(total_read, target_bytes, start_time);
+            last_progress_time = current_time;
+        }
+    }
+
+    close(device_fd);
+
+    if (display_progress) {
+        show_progress(target_bytes, target_bytes, start_time);
+        printf("\n✓ Successfully collected %zu bytes from TrueRNG device\n", total_read);
+    }
+
+    *collected_bytes = total_read;
+    return 0;
+}
+
+// Read USB device VID/PID information from sysfs
+int read_usb_device_info(const char* device_path, char* vid, char* pid) {
+    // Extract device name from path (e.g., /dev/ttyUSB0 -> ttyUSB0)
+    const char* device_name = strrchr(device_path, '/');
+    if (!device_name) device_name = device_path;
+    else device_name++; // Skip the '/'
+
+    // Construct sysfs path for USB device info
+    char sysfs_path[256];
+    snprintf(sysfs_path, sizeof(sysfs_path), "/sys/class/tty/%s/device/../idVendor", device_name);
+
+    FILE* vid_file = fopen(sysfs_path, "r");
+    if (!vid_file) {
+        return 1; // Cannot read VID
+    }
+
+    if (fscanf(vid_file, "%4s", vid) != 1) {
+        fclose(vid_file);
+        return 1; // Cannot parse VID
+    }
+    fclose(vid_file);
+
+    // Read PID
+    snprintf(sysfs_path, sizeof(sysfs_path), "/sys/class/tty/%s/device/../idProduct", device_name);
+    FILE* pid_file = fopen(sysfs_path, "r");
+    if (!pid_file) {
+        return 1; // Cannot read PID
+    }
+
+    if (fscanf(pid_file, "%4s", pid) != 1) {
+        fclose(pid_file);
+        return 1; // Cannot parse PID
+    }
+    fclose(pid_file);
+
+    return 0; // Success
+}
+
+// Get friendly name for hardware RNG device type
+const char* get_truerng_device_name(hardware_rng_device_type_t device_type) {
+    switch (device_type) {
+        case TRUERNG_ORIGINAL:
+            return "TrueRNG";
+        case TRUERNG_PRO:
+            return "TrueRNG Pro";
+        case TRUERNG_PRO_V2:
+            return "TrueRNG Pro V2";
+        default:
+            return "Unknown Hardware RNG Device";
+    }
+}
+
+// Test if a hardware RNG device is working by attempting to read from it
+int test_hardware_rng_device(const hardware_rng_device_t* device) {
+    int fd = open(device->port_path, O_RDONLY | O_NONBLOCK);
+    if (fd < 0) {
+        return 1; // Cannot open device
+    }
+
+    // Try to read a small amount of data
+    unsigned char test_buffer[16];
+    ssize_t bytes_read = read(fd, test_buffer, sizeof(test_buffer));
+
+    close(fd);
+
+    if (bytes_read <= 0) {
+        return 1; // Cannot read from device
+    }
+
+    return 0; // Device appears to be working
+}
+
+// Interactive device selection for hardware RNG
+int select_hardware_rng_device_interactive(hardware_rng_device_t* devices, int num_devices, hardware_rng_device_t* selected_device) {
+    if (num_devices == 0) {
+        printf("No hardware RNG devices found.\n");
+        return 1; // No devices available
+    }
+
+    if (num_devices == 1) {
+        // Only one device, use it automatically
+        *selected_device = devices[0];
+        printf("Using %s (%s)\n\n", devices[0].friendly_name, devices[0].port_path);
+        return 0;
+    }
+
+    // Multiple devices - let user choose
+    printf("\nAvailable Hardware RNG Devices:\n");
+    for (int i = 0; i < num_devices; i++) {
+        printf("%d. %s (%s)\n",
+               i + 1,
+               devices[i].friendly_name,
+               devices[i].port_path);
+    }
+
+    printf("\nSelect device (1-%d): ", num_devices);
+
+    char input[10];
+    if (fgets(input, sizeof(input), stdin) == NULL) {
+        return 1; // Input error
+    }
+
+    int choice = atoi(input);
+    if (choice < 1 || choice > num_devices) {
+        printf("Invalid selection.\n");
+        return 1;
+    }
+
+    *selected_device = devices[choice - 1];
+    printf("Selected: %s (%s)\n", selected_device->friendly_name, selected_device->port_path);
+    return 0;
+}

src/util.c

@@ -18,7 +18,6 @@
 #include "../include/otp.h"
 
 // Global variables for preferences
-extern char current_pads_dir[512];
 static char default_pad_path[1024] = "";
 
 void show_progress(uint64_t current, uint64_t total, time_t start_time) {
@@ -355,7 +354,7 @@ int load_preferences(void) {
         }
 
         // Find the first available pad to set as default
-        DIR* dir = opendir(current_pads_dir);
+        DIR* dir = opendir(get_current_pads_dir());
         if (dir) {
             struct dirent* entry;
             char first_pad_path[1024];
@@ -364,9 +363,10 @@ int load_preferences(void) {
             while ((entry = readdir(dir)) != NULL && !found_pad) {
                 if (strstr(entry->d_name, ".pad") && strlen(entry->d_name) == 68) {
                     // Found a pad file - construct full absolute path
-                    if (current_pads_dir[0] == '/') {
+                    const char* pads_dir = get_current_pads_dir();
+                    if (pads_dir[0] == '/') {
                         // Already absolute path
-                        int ret = snprintf(first_pad_path, sizeof(first_pad_path), "%s/%s", current_pads_dir, entry->d_name);
+                        int ret = snprintf(first_pad_path, sizeof(first_pad_path), "%s/%s", pads_dir, entry->d_name);
                         if (ret >= (int)sizeof(first_pad_path)) {
                             // Path was truncated, skip this entry
                             continue;
@@ -375,14 +375,14 @@ int load_preferences(void) {
                         // Relative path - make it absolute
                         char current_dir[512];
                         if (getcwd(current_dir, sizeof(current_dir))) {
-                            int ret = snprintf(first_pad_path, sizeof(first_pad_path), "%s/%s/%s", current_dir, current_pads_dir, entry->d_name);
+                            int ret = snprintf(first_pad_path, sizeof(first_pad_path), "%s/%s/%s", current_dir, pads_dir, entry->d_name);
                             if (ret >= (int)sizeof(first_pad_path)) {
                                 // Path was truncated, skip this entry
                                 continue;
                             }
                         } else {
                             // Fallback to relative path
-                            int ret = snprintf(first_pad_path, sizeof(first_pad_path), "%s/%s", current_pads_dir, entry->d_name);
+                            int ret = snprintf(first_pad_path, sizeof(first_pad_path), "%s/%s", pads_dir, entry->d_name);
                             if (ret >= (int)sizeof(first_pad_path)) {
                                 // Path was truncated, skip this entry
                                 continue;
@@ -641,7 +641,7 @@ void get_directory_display(const char* file_path, char* result, size_t result_si
     }
 
     // Current working directory
-    if (strcmp(dir_path, ".") == 0 || strcmp(dir_path, current_pads_dir) == 0) {
+    if (strcmp(dir_path, ".") == 0 || strcmp(dir_path, get_current_pads_dir()) == 0) {
         strncpy(result, "pads", result_size - 1);
         result[result_size - 1] = '\0';
         return;