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

Version v0.3.35 - Convert to decimal units (1000-based) to match system tools, add posix_fallocate for guaranteed space allocation, use f_bavail for accurate space reporting, add drive info to Pad Management header

Browse Source
This commit is contained in:
Laan Tungir
2025-12-20 10:02:15 -04:00
parent cf52274c2c
commit b969590625
7 changed files with 74 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
README.md
View File

@@ -58,14 +58,14 @@ One-time pads can be trivially encrypted and decrypted using pencil and paper, m
### Download Pre-Built Binaries ### Download Pre-Built Binaries
**[Download Current Linux x86](https://git.laantungir.net/laantungir/otp/releases/download/v0.3.33/otp-v0.3.33-linux-x86_64)** **[Download Current Linux x86](https://git.laantungir.net/laantungir/otp/releases/download/v0.3.34/otp-v0.3.34-linux-x86_64)**
**[Download Current Raspberry Pi 64](https://git.laantungir.net/laantungir/otp/releases/download/v0.3.33/otp-v0.3.33-linux-arm64)** **[Download Current Raspberry Pi 64](https://git.laantungir.net/laantungir/otp/releases/download/v0.3.34/otp-v0.3.34-linux-arm64)**
After downloading: After downloading:
```bash ```bash
# Rename for convenience, then make executable # Rename for convenience, then make executable
mv otp-v0.3.33-linux-x86_64 otp mv otp-v0.3.34-linux-x86_64 otp
chmod +x otp chmod +x otp
# Run it # Run it

8
src/entropy.c
View File

@@ -82,7 +82,7 @@ int add_entropy_direct_xor(const char* pad_chksum, const unsigned char* entropy_
if (display_progress) { if (display_progress) {
printf("Adding entropy to pad using direct XOR...\n"); printf("Adding entropy to pad using direct XOR...\n");
printf("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1024.0*1024.0*1024.0), pad_size); printf("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1000.0*1000.0*1000.0), pad_size);
printf("Entropy size: %zu bytes\n", entropy_size); printf("Entropy size: %zu bytes\n", entropy_size);
} }
@@ -212,7 +212,7 @@ int add_entropy_chacha20(const char* pad_chksum, const unsigned char* entropy_da
if (display_progress) { if (display_progress) {
printf("Adding entropy to pad using Chacha20...\n"); printf("Adding entropy to pad using Chacha20...\n");
printf("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1024.0*1024.0*1024.0), pad_size); printf("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1000.0*1000.0*1000.0), pad_size);
} }
// Process pad in chunks // Process pad in chunks
@@ -593,8 +593,8 @@ int add_file_entropy_streaming(const char* pad_chksum, const char* file_path, si
if (display_progress) { if (display_progress) {
printf("Adding entropy to pad using streaming direct XOR...\n"); printf("Adding entropy to pad using streaming direct XOR...\n");
printf("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1024.0*1024.0*1024.0), pad_size); printf("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1000.0*1000.0*1000.0), pad_size);
printf("Entropy file: %.2f GB (%zu bytes)\n", (double)file_size / (1024.0*1024.0*1024.0), file_size); printf("Entropy file: %.2f GB (%zu bytes)\n", (double)file_size / (1000.0*1000.0*1000.0), file_size);
} }
// Process in chunks // Process in chunks

2
src/main.h
View File

@@ -23,7 +23,7 @@
#include <ctype.h> #include <ctype.h>
// Version - Updated automatically by build.sh // Version - Updated automatically by build.sh
#define OTP_VERSION "v0.3.33" #define OTP_VERSION "v0.3.34"
// Constants // Constants
#define MAX_INPUT_SIZE 4096 #define MAX_INPUT_SIZE 4096

99
src/pads.c
View File

@@ -43,9 +43,9 @@ int show_pad_info(const char* chksum) {
printf("ChkSum: %s\n", chksum); printf("ChkSum: %s\n", chksum);
printf("File: %s\n", pad_filename); printf("File: %s\n", pad_filename);
double size_gb = (double)st.st_size / (1024.0 * 1024.0 * 1024.0); double size_gb = (double)st.st_size / (1000.0 * 1000.0 * 1000.0);
double used_gb = (double)used_bytes / (1024.0 * 1024.0 * 1024.0); double used_gb = (double)used_bytes / (1000.0 * 1000.0 * 1000.0);
double remaining_gb = (double)(st.st_size - used_bytes) / (1024.0 * 1024.0 * 1024.0); double remaining_gb = (double)(st.st_size - used_bytes) / (1000.0 * 1000.0 * 1000.0);
printf("Total size: %.2f GB (%lu bytes)\n", size_gb, st.st_size); printf("Total size: %.2f GB (%lu bytes)\n", size_gb, st.st_size);
printf("Used: %.2f GB (%lu bytes)\n", used_gb, used_bytes); printf("Used: %.2f GB (%lu bytes)\n", used_gb, used_bytes);
@@ -92,8 +92,8 @@ int generate_pad(uint64_t size_bytes, int display_progress) {
// Use f_bavail (available to non-root users) for accurate space reporting // Use f_bavail (available to non-root users) for accurate space reporting
// This accounts for filesystem reserved space (e.g., 5% on ext4) // This accounts for filesystem reserved space (e.g., 5% on ext4)
uint64_t available_bytes = stat.f_bavail * stat.f_frsize; uint64_t available_bytes = stat.f_bavail * stat.f_frsize;
double available_gb = (double)available_bytes / (1024.0 * 1024.0 * 1024.0); double available_gb = (double)available_bytes / (1000.0 * 1000.0 * 1000.0);
double required_gb = (double)size_bytes / (1024.0 * 1024.0 * 1024.0); double required_gb = (double)size_bytes / (1000.0 * 1000.0 * 1000.0);
if (available_bytes < size_bytes) { if (available_bytes < size_bytes) {
printf("\n⚠ WARNING: Insufficient disk space!\n"); printf("\n⚠ WARNING: Insufficient disk space!\n");
@@ -138,7 +138,7 @@ int generate_pad(uint64_t size_bytes, int display_progress) {
// Preallocate full file size using posix_fallocate for guaranteed space reservation // Preallocate full file size using posix_fallocate for guaranteed space reservation
// This actually allocates disk blocks (unlike ftruncate which creates sparse files) // This actually allocates disk blocks (unlike ftruncate which creates sparse files)
int fd = fileno(pad_file); int fd = fileno(pad_file);
double size_gb = (double)size_bytes / (1024.0 * 1024.0 * 1024.0); double size_gb = (double)size_bytes / (1000.0 * 1000.0 * 1000.0);
if (display_progress) { if (display_progress) {
printf("Allocating %.2f GB on disk...\n", size_gb); printf("Allocating %.2f GB on disk...\n", size_gb);
@@ -265,7 +265,7 @@ int generate_pad(uint64_t size_bytes, int display_progress) {
} }
if (display_progress) { if (display_progress) {
double final_size_gb = (double)size_bytes / (1024.0 * 1024.0 * 1024.0); double final_size_gb = (double)size_bytes / (1000.0 * 1000.0 * 1000.0);
printf("Generated pad: %s (%.2f GB)\n", pad_path, final_size_gb); printf("Generated pad: %s (%.2f GB)\n", pad_path, final_size_gb);
} }
printf("Pad checksum: %s\n", chksum_hex); printf("Pad checksum: %s\n", chksum_hex);
@@ -434,25 +434,25 @@ char* select_pad_interactive(const char* title, const char* prompt, pad_filter_t
} }
// Format total size // Format total size
if (st.st_size < 1024) { if (st.st_size < 1000) {
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%luB", st.st_size); snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%luB", st.st_size);
} else if (st.st_size < 1024 * 1024) { } else if (st.st_size < 1000 * 1000) {
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fKB", (double)st.st_size / 1024.0); snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fKB", (double)st.st_size / 1000.0);
} else if (st.st_size < 1024 * 1024 * 1024) { } else if (st.st_size < 1000 * 1000 * 1000) {
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fMB", (double)st.st_size / (1024.0 * 1024.0)); snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fMB", (double)st.st_size / (1000.0 * 1000.0));
} else { } else {
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.2fGB", (double)st.st_size / (1024.0 * 1024.0 * 1024.0)); snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.2fGB", (double)st.st_size / (1000.0 * 1000.0 * 1000.0));
} }
// Format used size // Format used size
if (used_bytes < 1024) { if (used_bytes < 1000) {
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%luB", used_bytes); snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%luB", used_bytes);
} else if (used_bytes < 1024 * 1024) { } else if (used_bytes < 1000 * 1000) {
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fKB", (double)used_bytes / 1024.0); snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fKB", (double)used_bytes / 1000.0);
} else if (used_bytes < 1024 * 1024 * 1024) { } else if (used_bytes < 1000 * 1000 * 1000) {
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fMB", (double)used_bytes / (1024.0 * 1024.0)); snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fMB", (double)used_bytes / (1000.0 * 1000.0));
} else { } else {
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.2fGB", (double)used_bytes / (1024.0 * 1024.0 * 1024.0)); snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.2fGB", (double)used_bytes / (1000.0 * 1000.0 * 1000.0));
} }
// Calculate percentage // Calculate percentage
@@ -634,6 +634,27 @@ int handle_pads_menu(void) {
// Get list of pads from current directory // Get list of pads from current directory
const char* pads_dir = get_current_pads_dir(); const char* pads_dir = get_current_pads_dir();
// Display directory and space information
printf("Pads Directory: %s\n", pads_dir);
// Get filesystem space information
struct statvfs vfs_stat;
if (statvfs(pads_dir, &vfs_stat) == 0) {
uint64_t total_bytes = vfs_stat.f_blocks * vfs_stat.f_frsize;
uint64_t available_bytes = vfs_stat.f_bavail * vfs_stat.f_frsize;
uint64_t used_bytes = total_bytes - (vfs_stat.f_bfree * vfs_stat.f_frsize);
double total_gb = (double)total_bytes / (1000.0 * 1000.0 * 1000.0);
double available_gb = (double)available_bytes / (1000.0 * 1000.0 * 1000.0);
double used_gb = (double)used_bytes / (1000.0 * 1000.0 * 1000.0);
double used_percent = (double)used_bytes / total_bytes * 100.0;
printf("Drive Space: %.2f GB total, %.2f GB used (%.1f%%), %.2f GB available\n",
total_gb, used_gb, used_percent, available_gb);
}
printf("\n");
DIR* dir = opendir(pads_dir); DIR* dir = opendir(pads_dir);
if (!dir) { if (!dir) {
printf("Error: Cannot open pads directory %s\n", pads_dir); printf("Error: Cannot open pads directory %s\n", pads_dir);
@@ -669,25 +690,25 @@ int handle_pads_menu(void) {
read_state_offset(pads[pad_count].chksum, &used_bytes); read_state_offset(pads[pad_count].chksum, &used_bytes);
// Format total size // Format total size
if (st.st_size < 1024) { if (st.st_size < 1000) {
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%luB", st.st_size); snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%luB", st.st_size);
} else if (st.st_size < 1024 * 1024) { } else if (st.st_size < 1000 * 1000) {
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fKB", (double)st.st_size / 1024.0); snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fKB", (double)st.st_size / 1000.0);
} else if (st.st_size < 1024 * 1024 * 1024) { } else if (st.st_size < 1000 * 1000 * 1000) {
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fMB", (double)st.st_size / (1024.0 * 1024.0)); snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.1fMB", (double)st.st_size / (1000.0 * 1000.0));
} else { } else {
snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.2fGB", (double)st.st_size / (1024.0 * 1024.0 * 1024.0)); snprintf(pads[pad_count].size_str, sizeof(pads[pad_count].size_str), "%.2fGB", (double)st.st_size / (1000.0 * 1000.0 * 1000.0));
} }
// Format used size // Format used size
if (used_bytes < 1024) { if (used_bytes < 1000) {
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%luB", used_bytes); snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%luB", used_bytes);
} else if (used_bytes < 1024 * 1024) { } else if (used_bytes < 1000 * 1000) {
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fKB", (double)used_bytes / 1024.0); snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fKB", (double)used_bytes / 1000.0);
} else if (used_bytes < 1024 * 1024 * 1024) { } else if (used_bytes < 1000 * 1000 * 1000) {
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fMB", (double)used_bytes / (1024.0 * 1024.0)); snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.1fMB", (double)used_bytes / (1000.0 * 1000.0));
} else { } else {
snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.2fGB", (double)used_bytes / (1024.0 * 1024.0 * 1024.0)); snprintf(pads[pad_count].used_str, sizeof(pads[pad_count].used_str), "%.2fGB", (double)used_bytes / (1000.0 * 1000.0 * 1000.0));
} }
// Calculate percentage // Calculate percentage
@@ -999,9 +1020,9 @@ int handle_verify_pad(const char* chksum) {
printf("ChkSum: %s\n", chksum); printf("ChkSum: %s\n", chksum);
printf("File: %s\n", pad_filename); printf("File: %s\n", pad_filename);
double size_gb = (double)st.st_size / (1024.0 * 1024.0 * 1024.0); double size_gb = (double)st.st_size / (1000.0 * 1000.0 * 1000.0);
double used_gb = (double)used_bytes / (1024.0 * 1024.0 * 1024.0); double used_gb = (double)used_bytes / (1000.0 * 1000.0 * 1000.0);
double remaining_gb = (double)(st.st_size - used_bytes) / (1024.0 * 1024.0 * 1024.0); double remaining_gb = (double)(st.st_size - used_bytes) / (1000.0 * 1000.0 * 1000.0);
printf("Total size: %.2f GB (%lu bytes)\n", size_gb, st.st_size); printf("Total size: %.2f GB (%lu bytes)\n", size_gb, st.st_size);
printf("Used: %.2f GB (%lu bytes)\n", used_gb, used_bytes); printf("Used: %.2f GB (%lu bytes)\n", used_gb, used_bytes);
@@ -1067,7 +1088,7 @@ int handle_delete_pad(const char* chksum) {
uint64_t used_bytes; uint64_t used_bytes;
read_state_offset(chksum, &used_bytes); read_state_offset(chksum, &used_bytes);
double size_gb = (double)st.st_size / (1024.0 * 1024.0 * 1024.0); double size_gb = (double)st.st_size / (1000.0 * 1000.0 * 1000.0);
printf("\nPad to delete:\n"); printf("\nPad to delete:\n");
printf("Checksum: %s\n", chksum); printf("Checksum: %s\n", chksum);
printf("Size: %.2f GB\n", size_gb); printf("Size: %.2f GB\n", size_gb);
@@ -1255,7 +1276,7 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
target_bytes = (size_t)pad_stat.st_size; target_bytes = (size_t)pad_stat.st_size;
printf("\nHardware RNG 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", printf("Pad size: %.2f GB (%zu bytes)\n",
(double)target_bytes / (1024.0 * 1024.0 * 1024.0), target_bytes); (double)target_bytes / (1000.0 * 1000.0 * 1000.0), target_bytes);
} else if (entropy_source == ENTROPY_SOURCE_FILE) { } else if (entropy_source == ENTROPY_SOURCE_FILE) {
// Special handling for file entropy - ask for file path first // Special handling for file entropy - ask for file path first
char file_path[512]; char file_path[512];
@@ -1277,7 +1298,7 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
printf("\nFile vs Pad Size Analysis:\n"); printf("\nFile vs Pad Size Analysis:\n");
printf(" Entropy file: %zu bytes\n", file_size); printf(" Entropy file: %zu bytes\n", file_size);
printf(" Target pad: %.2f GB (%lu bytes)\n", printf(" Target pad: %.2f GB (%lu bytes)\n",
(double)pad_size / (1024.0 * 1024.0 * 1024.0), pad_size); (double)pad_size / (1000.0 * 1000.0 * 1000.0), pad_size);
// Smart method selection based on file size vs pad size // Smart method selection based on file size vs pad size
if (file_size >= pad_size) { if (file_size >= pad_size) {
@@ -1461,10 +1482,10 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
printf("✓ Device test successful!\n"); printf("✓ Device test successful!\n");
printf(" Test collected: %zu bytes in %.1f seconds\n", test_collected, test_time); 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(" Speed: %.1f KB/s (%.1f MB/s)\n", bytes_per_second / 1000.0, bytes_per_second / (1000.0 * 1000.0));
printf("\nPad enhancement estimate:\n"); printf("\nPad enhancement estimate:\n");
printf(" Pad size: %.2f GB (%zu bytes)\n", (double)target_bytes / (1024.0 * 1024.0 * 1024.0), target_bytes); printf(" Pad size: %.2f GB (%zu bytes)\n", (double)target_bytes / (1000.0 * 1000.0 * 1000.0), target_bytes);
if (estimated_hours >= 1.0) { if (estimated_hours >= 1.0) {
printf(" Estimated time: %.1f hours\n", estimated_hours); printf(" Estimated time: %.1f hours\n", estimated_hours);

2
src/trng.c
View File

@@ -153,7 +153,7 @@ int collect_truerng_entropy_streaming_from_device(const hardware_rng_device_t* d
if (display_progress) { if (display_progress) {
printf("Streaming entropy from %s to pad...\n", device->friendly_name); 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("Pad size: %.2f GB (%lu bytes)\n", (double)pad_size / (1000.0*1000.0*1000.0), pad_size);
printf("Enhancing entire pad with hardware entropy\n"); printf("Enhancing entire pad with hardware entropy\n");
} }

2
src/ui.c
View File

@@ -152,7 +152,7 @@ int handle_generate_menu(void) {
return 1; return 1;
} }
double size_gb = (double)size / (1024.0 * 1024.0 * 1024.0); double size_gb = (double)size / (1000.0 * 1000.0 * 1000.0);
printf("Generating %.2f GB pad...\n", size_gb); printf("Generating %.2f GB pad...\n", size_gb);
printf("Note: Use 'Add entropy' in Pads menu to enhance randomness after creation.\n"); printf("Note: Use 'Add entropy' in Pads menu to enhance randomness after creation.\n");

8
src/util.c
View File

@@ -519,13 +519,13 @@ uint64_t parse_size_string(const char* size_str) {
} }
if (strcmp(unit, "K") == 0 || strcmp(unit, "KB") == 0) { if (strcmp(unit, "K") == 0 || strcmp(unit, "KB") == 0) {
multiplier = 1024ULL; multiplier = 1000ULL;
} else if (strcmp(unit, "M") == 0 || strcmp(unit, "MB") == 0) { } else if (strcmp(unit, "M") == 0 || strcmp(unit, "MB") == 0) {
multiplier = 1024ULL * 1024ULL; multiplier = 1000ULL * 1000ULL;
} else if (strcmp(unit, "G") == 0 || strcmp(unit, "GB") == 0) { } else if (strcmp(unit, "G") == 0 || strcmp(unit, "GB") == 0) {
multiplier = 1024ULL * 1024ULL * 1024ULL; multiplier = 1000ULL * 1000ULL * 1000ULL;
} else if (strcmp(unit, "T") == 0 || strcmp(unit, "TB") == 0) { } else if (strcmp(unit, "T") == 0 || strcmp(unit, "TB") == 0) {
multiplier = 1024ULL * 1024ULL * 1024ULL * 1024ULL; multiplier = 1000ULL * 1000ULL * 1000ULL * 1000ULL;
} else { } else {
return 0; // Invalid unit return 0; // Invalid unit
} }