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

Version v0.2.107 - Update comments

Browse Source
This commit is contained in:
Laan Tungir
2025-08-31 11:25:03 -04:00
parent 4a651da067
commit 0c4ef55a98
1 changed files with 233 additions and 187 deletions
Download Patch File Download Diff File Expand all files Collapse all files

410
otp.c
View File

@@ -467,7 +467,7 @@ int interactive_mode(void) {
void show_main_menu(void) {
printf("\n=========================== Main Menu - OTP v0.2.105 ===========================\n\n");
printf("\n=========================== Main Menu - OTP v0.2.106 ===========================\n\n");
printf(" \033[4mT\033[0mext encrypt\n"); //TEXT ENCRYPT
printf(" \033[4mF\033[0mile encrypt\n"); //FILE ENCRYPT
@@ -1249,6 +1249,17 @@ int add_entropy_to_pad(const char* pad_chksum, const unsigned char* entropy_data
return 0;
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// ENCRYPT AND DECRYPT
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
int encrypt_text(const char* pad_identifier, const char* input_text) {
char* pad_chksum = find_pad_by_prefix(pad_identifier);
if (!pad_chksum) {
@@ -1926,190 +1937,14 @@ int write_state_offset(const char* pad_chksum, uint64_t offset) {
return 0;
}
int calculate_checksum(const char* filename, char* checksum_hex) {
FILE* file = fopen(filename, "rb");
if (!file) {
return 1;
}
unsigned char checksum[32];
unsigned char buffer[64 * 1024]; // 64KB buffer for large files
size_t bytes_read;
// Initialize checksum
memset(checksum, 0, 32);
size_t total_bytes = 0;
// Calculate XOR checksum of entire file
while ((bytes_read = fread(buffer, 1, sizeof(buffer), file)) > 0) {
// Process this chunk with XOR checksum
for (size_t i = 0; i < bytes_read; i++) {
unsigned char bucket = (total_bytes + i) % 32;
checksum[bucket] ^= buffer[i] ^ (((total_bytes + i) >> 8) & 0xFF) ^
(((total_bytes + i) >> 16) & 0xFF) ^ (((total_bytes + i) >> 24) & 0xFF);
}
total_bytes += bytes_read;
}
fclose(file);
// Now encrypt the checksum with the first 32 bytes of the pad
fseek(file = fopen(filename, "rb"), 0, SEEK_SET);
unsigned char pad_key[32];
if (fread(pad_key, 1, 32, file) != 32) {
fclose(file);
return 1;
}
fclose(file);
// XOR encrypt the checksum with pad data to create unique identifier
unsigned char encrypted_checksum[32];
for (int i = 0; i < 32; i++) {
encrypted_checksum[i] = checksum[i] ^ pad_key[i];
}
// Convert to hex string (64 characters)
for (int i = 0; i < 32; i++) {
sprintf(checksum_hex + (i * 2), "%02x", encrypted_checksum[i]);
}
checksum_hex[64] = '\0';
return 0;
}
// Keyboard entropy functions
int setup_raw_terminal(struct termios* original_termios) {
struct termios new_termios;
if (tcgetattr(STDIN_FILENO, original_termios) != 0) {
return 1;
}
new_termios = *original_termios;
new_termios.c_lflag &= ~(ICANON | ECHO);
new_termios.c_cc[VMIN] = 0;
new_termios.c_cc[VTIME] = 0;
if (tcsetattr(STDIN_FILENO, TCSANOW, &new_termios) != 0) {
return 1;
}
// Set stdin to non-blocking
int flags = fcntl(STDIN_FILENO, F_GETFL);
if (fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK) == -1) {
tcsetattr(STDIN_FILENO, TCSANOW, original_termios);
return 1;
}
return 0;
}
void restore_terminal(struct termios* original_termios) {
tcsetattr(STDIN_FILENO, TCSANOW, original_termios);
// Reset stdin to blocking
int flags = fcntl(STDIN_FILENO, F_GETFL);
fcntl(STDIN_FILENO, F_SETFL, flags & ~O_NONBLOCK);
}
// Enhanced entropy collection with visual feedback
int collect_entropy_with_feedback(unsigned char* entropy_buffer, size_t target_bytes,
size_t* collected_bytes, int allow_early_exit) {
struct termios original_termios;
entropy_collection_state_t state = {0};
// Initialize state
state.target_bytes = target_bytes;
state.auto_complete_enabled = allow_early_exit;
state.collection_start_time = get_precise_time();
// Setup raw terminal
if (setup_raw_terminal(&original_termios) != 0) {
printf("Error: Cannot setup terminal for entropy collection\n");
return 1;
}
// Clear screen area for display
printf("\n\n\n\n\n\n");
unsigned char entropy_block[16];
struct timespec timestamp;
uint32_t sequence_counter = 0;
char key;
unsigned char seen_keys[256] = {0};
*collected_bytes = 0;
while (state.collected_bytes < target_bytes) {
// Update display
state.quality_score = calculate_overall_quality(&state);
display_entropy_progress(&state);
// Non-blocking read
if (read(STDIN_FILENO, &key, 1) == 1) {
// Handle ESC key for early exit
if (key == 27 && allow_early_exit && state.collected_bytes >= 1024) {
break; // Early exit allowed
}
// Record keypress timing
double current_time = get_precise_time();
state.last_keypress_time = current_time;
// Update key histogram
state.key_histogram[(unsigned char)key]++;
// Get high precision timestamp
clock_gettime(CLOCK_MONOTONIC, &timestamp);
// Create enhanced entropy block: [key][timestamp][sequence][quality_bits]
entropy_block[0] = key;
memcpy(&entropy_block[1], &timestamp.tv_sec, 8);
memcpy(&entropy_block[9], &timestamp.tv_nsec, 4);
memcpy(&entropy_block[13], &sequence_counter, 2);
entropy_block[15] = (unsigned char)(current_time * 1000) & 0xFF; // Sub-millisecond timing
// Add to entropy buffer
if (state.collected_bytes + 16 <= MAX_ENTROPY_BUFFER) {
memcpy(entropy_buffer + state.collected_bytes, entropy_block, 16);
state.collected_bytes += 16;
}
sequence_counter++;
// Track unique keys
if (!seen_keys[(unsigned char)key]) {
seen_keys[(unsigned char)key] = 1;
state.unique_keys++;
}
} else {
// No key available, just sleep and wait for keystrokes
usleep(10000); // 10ms delay - wait for keystrokes, don't add timing entropy
}
// Auto-complete at target if enabled
if (state.collected_bytes >= target_bytes) {
break;
}
}
// Final display update
state.quality_score = calculate_overall_quality(&state);
display_entropy_progress(&state);
// Summary
double collection_time = get_precise_time() - state.collection_start_time;
printf("\n\n✓ Entropy collection complete!\n");
printf(" Collected: %zu bytes in %.1f seconds\n", state.collected_bytes, collection_time);
printf(" Quality: %d%% (Excellent: 80%%+, Good: 60%%+)\n", state.quality_score);
printf(" Unique keys: %zu\n", state.unique_keys);
// Restore terminal
restore_terminal(&original_termios);
*collected_bytes = state.collected_bytes;
return 0;
}
// Directory management functions
@@ -2599,7 +2434,14 @@ unsigned char* custom_base64_decode(const char* input, int* output_length) {
return decoded;
}
// Enhanced entropy system implementation
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// ADD ENTROPY
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
double get_precise_time(void) {
struct timespec ts;
@@ -2797,7 +2639,6 @@ int derive_chacha20_params(const unsigned char* entropy_data, size_t entropy_siz
return 0; // Success
}
// Enhanced entropy system helper functions
// Check if a pad is unused (0% usage)
int is_pad_unused(const char* pad_chksum) {
@@ -2888,6 +2729,143 @@ int update_pad_checksum_after_entropy(const char* old_chksum, char* new_chksum)
return 0; // Success
}
// Enhanced entropy collection with visual feedback
int collect_entropy_with_feedback(unsigned char* entropy_buffer, size_t target_bytes,
size_t* collected_bytes, int allow_early_exit) {
struct termios original_termios;
entropy_collection_state_t state = {0};
// Initialize state
state.target_bytes = target_bytes;
state.auto_complete_enabled = allow_early_exit;
state.collection_start_time = get_precise_time();
// Setup raw terminal
if (setup_raw_terminal(&original_termios) != 0) {
printf("Error: Cannot setup terminal for entropy collection\n");
return 1;
}
// Clear screen area for display
printf("\n\n\n\n\n\n");
unsigned char entropy_block[16];
struct timespec timestamp;
uint32_t sequence_counter = 0;
char key;
unsigned char seen_keys[256] = {0};
*collected_bytes = 0;
while (state.collected_bytes < target_bytes) {
// Update display
state.quality_score = calculate_overall_quality(&state);
display_entropy_progress(&state);
// Non-blocking read
if (read(STDIN_FILENO, &key, 1) == 1) {
// Handle ESC key for early exit
if (key == 27 && allow_early_exit && state.collected_bytes >= 1024) {
break; // Early exit allowed
}
// Record keypress timing
double current_time = get_precise_time();
state.last_keypress_time = current_time;
// Update key histogram
state.key_histogram[(unsigned char)key]++;
// Get high precision timestamp
clock_gettime(CLOCK_MONOTONIC, &timestamp);
// Create enhanced entropy block: [key][timestamp][sequence][quality_bits]
entropy_block[0] = key;
memcpy(&entropy_block[1], &timestamp.tv_sec, 8);
memcpy(&entropy_block[9], &timestamp.tv_nsec, 4);
memcpy(&entropy_block[13], &sequence_counter, 2);
entropy_block[15] = (unsigned char)(current_time * 1000) & 0xFF; // Sub-millisecond timing
// Add to entropy buffer
if (state.collected_bytes + 16 <= MAX_ENTROPY_BUFFER) {
memcpy(entropy_buffer + state.collected_bytes, entropy_block, 16);
state.collected_bytes += 16;
}
sequence_counter++;
// Track unique keys
if (!seen_keys[(unsigned char)key]) {
seen_keys[(unsigned char)key] = 1;
state.unique_keys++;
}
} else {
// No key available, just sleep and wait for keystrokes
usleep(10000); // 10ms delay - wait for keystrokes, don't add timing entropy
}
// Auto-complete at target if enabled
if (state.collected_bytes >= target_bytes) {
break;
}
}
// Final display update
state.quality_score = calculate_overall_quality(&state);
display_entropy_progress(&state);
// Summary
double collection_time = get_precise_time() - state.collection_start_time;
printf("\n\n✓ Entropy collection complete!\n");
printf(" Collected: %zu bytes in %.1f seconds\n", state.collected_bytes, collection_time);
printf(" Quality: %d%% (Excellent: 80%%+, Good: 60%%+)\n", state.quality_score);
printf(" Unique keys: %zu\n", state.unique_keys);
// Restore terminal
restore_terminal(&original_termios);
*collected_bytes = state.collected_bytes;
return 0;
}
// Keyboard entropy functions
int setup_raw_terminal(struct termios* original_termios) {
struct termios new_termios;
if (tcgetattr(STDIN_FILENO, original_termios) != 0) {
return 1;
}
new_termios = *original_termios;
new_termios.c_lflag &= ~(ICANON | ECHO);
new_termios.c_cc[VMIN] = 0;
new_termios.c_cc[VTIME] = 0;
if (tcsetattr(STDIN_FILENO, TCSANOW, &new_termios) != 0) {
return 1;
}
// Set stdin to non-blocking
int flags = fcntl(STDIN_FILENO, F_GETFL);
if (fcntl(STDIN_FILENO, F_SETFL, flags | O_NONBLOCK) == -1) {
tcsetattr(STDIN_FILENO, TCSANOW, original_termios);
return 1;
}
return 0;
}
void restore_terminal(struct termios* original_termios) {
tcsetattr(STDIN_FILENO, TCSANOW, original_termios);
// Reset stdin to blocking
int flags = fcntl(STDIN_FILENO, F_GETFL);
fcntl(STDIN_FILENO, F_SETFL, flags & ~O_NONBLOCK);
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// UNIVERSAL CORE FUNCTIONS FOR CODE CONSOLIDATION
@@ -3058,7 +3036,7 @@ int generate_ascii_armor(const char* chksum, uint64_t offset, const unsigned cha
strcpy(*ascii_output, "-----BEGIN OTP MESSAGE-----\n");
char temp_line[256];
snprintf(temp_line, sizeof(temp_line), "Version: v0.2.105\n");
snprintf(temp_line, sizeof(temp_line), "Version: v0.2.106\n");
strcat(*ascii_output, temp_line);
snprintf(temp_line, sizeof(temp_line), "Pad-ChkSum: %s\n", chksum);
@@ -3522,7 +3500,12 @@ int get_filename_with_default(const char* prompt, const char* default_path, char
return 0;
}
// Editor and file manager implementations
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// EDITOR AND FILE MANAGER
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
char* get_preferred_editor(void) {
// Check EDITOR environment variable first
@@ -3797,6 +3780,69 @@ int handle_file_encrypt(void) {
}
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// PADS
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
int calculate_checksum(const char* filename, char* checksum_hex) {
FILE* file = fopen(filename, "rb");
if (!file) {
return 1;
}
unsigned char checksum[32];
unsigned char buffer[64 * 1024]; // 64KB buffer for large files
size_t bytes_read;
// Initialize checksum
memset(checksum, 0, 32);
size_t total_bytes = 0;
// Calculate XOR checksum of entire file
while ((bytes_read = fread(buffer, 1, sizeof(buffer), file)) > 0) {
// Process this chunk with XOR checksum
for (size_t i = 0; i < bytes_read; i++) {
unsigned char bucket = (total_bytes + i) % 32;
checksum[bucket] ^= buffer[i] ^ (((total_bytes + i) >> 8) & 0xFF) ^
(((total_bytes + i) >> 16) & 0xFF) ^ (((total_bytes + i) >> 24) & 0xFF);
}
total_bytes += bytes_read;
}
fclose(file);
// Now encrypt the checksum with the first 32 bytes of the pad
fseek(file = fopen(filename, "rb"), 0, SEEK_SET);
unsigned char pad_key[32];
if (fread(pad_key, 1, 32, file) != 32) {
fclose(file);
return 1;
}
fclose(file);
// XOR encrypt the checksum with pad data to create unique identifier
unsigned char encrypted_checksum[32];
for (int i = 0; i < 32; i++) {
encrypted_checksum[i] = checksum[i] ^ pad_key[i];
}
// Convert to hex string (64 characters)
for (int i = 0; i < 32; i++) {
sprintf(checksum_hex + (i * 2), "%02x", encrypted_checksum[i]);
}
checksum_hex[64] = '\0';
return 0;
}
// Unified pad selection function - extracts the best UI from handle_pads_menu()
char* select_pad_interactive(const char* title, const char* prompt, pad_filter_type_t filter_type, int allow_cancel) {
// Get list of pads from current directory
@@ -4540,7 +4586,7 @@ int handle_add_entropy_to_pad(const char* pad_chksum) {
}
void print_usage(const char* program_name) {
printf("OTP Cipher - One Time Pad Implementation v0.2.105\n");
printf("OTP Cipher - One Time Pad Implementation v0.2.106\n");
printf("Built for testing entropy system\n");
printf("Usage:\n");
printf(" %s - Interactive mode\n", program_name);