laantungir/otp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 30 Wiki Activity

Reupload

Browse Source
This commit is contained in:
Laan Tungir
2025-10-09 10:45:04 -04:00
parent 9d91ec912a
commit 33b34bf5a5
27 changed files with 1552 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

307
src/pads.c
View File

@@ -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;
}