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

Version v0.3.23 - Reorganized project structure - all sources in src/, builds in build/

Browse Source
This commit is contained in:
Laan Tungir
2025-12-18 08:54:57 -04:00
parent 3ff91e7681
commit a5a1bd92c4
23 changed files with 57 additions and 369 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/crypto.c
View File

@@ -5,7 +5,7 @@
#include <stdio.h>
#include <time.h>
#include <unistd.h>
#include "../include/otp.h"
#include "otp.h"
#define PROGRESS_UPDATE_INTERVAL (64 * 1024 * 1024) // 64MB intervals

4
src/entropy.c
View File

@@ -15,8 +15,8 @@
#include <termios.h>
#include <fcntl.h>
#include <math.h>
#include "../nostr_chacha20.h"
#include "../include/otp.h"
#include "nostr_chacha20.h"
#include "otp.h"
// In-place pad entropy addition using Chacha20 or direct XOR

2
src/main.c
View File

@@ -15,7 +15,7 @@
#include <termios.h>
#include <fcntl.h>
#include <math.h>
#include "../include/otp.h"
#include "otp.h"
int main(int argc, char* argv[]) {
// Initialize terminal dimensions first

163
src/nostr_chacha20.c Normal file
View File

@@ -0,0 +1,163 @@
/*
* nostr_chacha20.c - ChaCha20 stream cipher implementation
*
* Implementation based on RFC 8439 "ChaCha20 and Poly1305 for IETF Protocols"
*
* This implementation is adapted from the RFC 8439 reference specification.
* It prioritizes correctness and clarity over performance optimization.
*/
#include "nostr_chacha20.h"
#include <string.h>
/*
* ============================================================================
* UTILITY MACROS AND FUNCTIONS
* ============================================================================
*/
/* Left rotate a 32-bit value by n bits */
#define ROTLEFT(a, b) (((a) << (b)) | ((a) >> (32 - (b))))
/* Convert 4 bytes to 32-bit little-endian */
static uint32_t bytes_to_u32_le(const uint8_t *bytes) {
return ((uint32_t)bytes[0]) |
((uint32_t)bytes[1] << 8) |
((uint32_t)bytes[2] << 16) |
((uint32_t)bytes[3] << 24);
}
/* Convert 32-bit to 4 bytes little-endian */
static void u32_to_bytes_le(uint32_t val, uint8_t *bytes) {
bytes[0] = (uint8_t)(val & 0xff);
bytes[1] = (uint8_t)((val >> 8) & 0xff);
bytes[2] = (uint8_t)((val >> 16) & 0xff);
bytes[3] = (uint8_t)((val >> 24) & 0xff);
}
/*
* ============================================================================
* CHACHA20 CORE FUNCTIONS
* ============================================================================
*/
void chacha20_quarter_round(uint32_t state[16], int a, int b, int c, int d) {
state[a] += state[b];
state[d] ^= state[a];
state[d] = ROTLEFT(state[d], 16);
state[c] += state[d];
state[b] ^= state[c];
state[b] = ROTLEFT(state[b], 12);
state[a] += state[b];
state[d] ^= state[a];
state[d] = ROTLEFT(state[d], 8);
state[c] += state[d];
state[b] ^= state[c];
state[b] = ROTLEFT(state[b], 7);
}
void chacha20_init_state(uint32_t state[16], const uint8_t key[32],
uint32_t counter, const uint8_t nonce[12]) {
/* ChaCha20 constants "expand 32-byte k" */
state[0] = 0x61707865;
state[1] = 0x3320646e;
state[2] = 0x79622d32;
state[3] = 0x6b206574;
/* Key (8 words) */
state[4] = bytes_to_u32_le(key + 0);
state[5] = bytes_to_u32_le(key + 4);
state[6] = bytes_to_u32_le(key + 8);
state[7] = bytes_to_u32_le(key + 12);
state[8] = bytes_to_u32_le(key + 16);
state[9] = bytes_to_u32_le(key + 20);
state[10] = bytes_to_u32_le(key + 24);
state[11] = bytes_to_u32_le(key + 28);
/* Counter (1 word) */
state[12] = counter;
/* Nonce (3 words) */
state[13] = bytes_to_u32_le(nonce + 0);
state[14] = bytes_to_u32_le(nonce + 4);
state[15] = bytes_to_u32_le(nonce + 8);
}
void chacha20_serialize_state(const uint32_t state[16], uint8_t output[64]) {
for (int i = 0; i < 16; i++) {
u32_to_bytes_le(state[i], output + (i * 4));
}
}
int chacha20_block(const uint8_t key[32], uint32_t counter,
const uint8_t nonce[12], uint8_t output[64]) {
uint32_t state[16];
uint32_t initial_state[16];
/* Initialize state */
chacha20_init_state(state, key, counter, nonce);
/* Save initial state for later addition */
memcpy(initial_state, state, sizeof(initial_state));
/* Perform 20 rounds (10 iterations of the 8 quarter rounds) */
for (int i = 0; i < 10; i++) {
/* Column rounds */
chacha20_quarter_round(state, 0, 4, 8, 12);
chacha20_quarter_round(state, 1, 5, 9, 13);
chacha20_quarter_round(state, 2, 6, 10, 14);
chacha20_quarter_round(state, 3, 7, 11, 15);
/* Diagonal rounds */
chacha20_quarter_round(state, 0, 5, 10, 15);
chacha20_quarter_round(state, 1, 6, 11, 12);
chacha20_quarter_round(state, 2, 7, 8, 13);
chacha20_quarter_round(state, 3, 4, 9, 14);
}
/* Add initial state back (prevents slide attacks) */
for (int i = 0; i < 16; i++) {
state[i] += initial_state[i];
}
/* Serialize to output bytes */
chacha20_serialize_state(state, output);
return 0;
}
int chacha20_encrypt(const uint8_t key[32], uint32_t counter,
const uint8_t nonce[12], const uint8_t* input,
uint8_t* output, size_t length) {
uint8_t keystream[CHACHA20_BLOCK_SIZE];
size_t offset = 0;
while (length > 0) {
/* Generate keystream block */
int ret = chacha20_block(key, counter, nonce, keystream);
if (ret != 0) {
return ret;
}
/* XOR with input to produce output */
size_t block_len = (length < CHACHA20_BLOCK_SIZE) ? length : CHACHA20_BLOCK_SIZE;
for (size_t i = 0; i < block_len; i++) {
output[offset + i] = input[offset + i] ^ keystream[i];
}
/* Move to next block */
offset += block_len;
length -= block_len;
counter++;
/* Check for counter overflow */
if (counter == 0) {
return -1; /* Counter wrapped around */
}
}
return 0;
}

115
src/nostr_chacha20.h Normal file
View File

@@ -0,0 +1,115 @@
/*
* nostr_chacha20.h - ChaCha20 stream cipher implementation
*
* Implementation based on RFC 8439 "ChaCha20 and Poly1305 for IETF Protocols"
*
* This is a small, portable implementation for NIP-44 support in the NOSTR library.
* The implementation prioritizes correctness and simplicity over performance.
*/
#ifndef NOSTR_CHACHA20_H
#define NOSTR_CHACHA20_H
#include <stdint.h>
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
/*
* ============================================================================
* CONSTANTS AND DEFINITIONS
* ============================================================================
*/
#define CHACHA20_KEY_SIZE 32 /* 256 bits */
#define CHACHA20_NONCE_SIZE 12 /* 96 bits */
#define CHACHA20_BLOCK_SIZE 64 /* 512 bits */
/*
* ============================================================================
* CORE CHACHA20 FUNCTIONS
* ============================================================================
*/
/**
* ChaCha20 quarter round operation
*
* Operates on four 32-bit words performing the core ChaCha20 quarter round:
* a += b; d ^= a; d <<<= 16;
* c += d; b ^= c; b <<<= 12;
* a += b; d ^= a; d <<<= 8;
* c += d; b ^= c; b <<<= 7;
*
* @param state[in,out] ChaCha state as 16 32-bit words
* @param a, b, c, d Indices into state array for quarter round
*/
void chacha20_quarter_round(uint32_t state[16], int a, int b, int c, int d);
/**
* ChaCha20 block function
*
* Transforms a 64-byte input block using ChaCha20 algorithm with 20 rounds.
*
* @param key[in] 32-byte key
* @param counter[in] 32-bit block counter
* @param nonce[in] 12-byte nonce
* @param output[out] 64-byte output buffer
* @return 0 on success, negative on error
*/
int chacha20_block(const uint8_t key[32], uint32_t counter,
const uint8_t nonce[12], uint8_t output[64]);
/**
* ChaCha20 encryption/decryption
*
* Encrypts or decrypts data using ChaCha20 stream cipher.
* Since ChaCha20 is a stream cipher, encryption and decryption are the same operation.
*
* @param key[in] 32-byte key
* @param counter[in] Initial 32-bit counter value
* @param nonce[in] 12-byte nonce
* @param input[in] Input data to encrypt/decrypt
* @param output[out] Output buffer (can be same as input)
* @param length[in] Length of input data in bytes
* @return 0 on success, negative on error
*/
int chacha20_encrypt(const uint8_t key[32], uint32_t counter,
const uint8_t nonce[12], const uint8_t* input,
uint8_t* output, size_t length);
/*
* ============================================================================
* UTILITY FUNCTIONS
* ============================================================================
*/
/**
* Initialize ChaCha20 state matrix
*
* Sets up the initial 16-word state matrix with constants, key, counter, and nonce.
*
* @param state[out] 16-word state array to initialize
* @param key[in] 32-byte key
* @param counter[in] 32-bit block counter
* @param nonce[in] 12-byte nonce
*/
void chacha20_init_state(uint32_t state[16], const uint8_t key[32],
uint32_t counter, const uint8_t nonce[12]);
/**
* Serialize ChaCha20 state to bytes
*
* Converts 16 32-bit words to 64 bytes in little-endian format.
*
* @param state[in] 16-word state array
* @param output[out] 64-byte output buffer
*/
void chacha20_serialize_state(const uint32_t state[16], uint8_t output[64]);
#ifdef __cplusplus
}
#endif
#endif /* NOSTR_CHACHA20_H */

35
src/otp.c Normal file
View File

@@ -0,0 +1,35 @@
#define _POSIX_C_SOURCE 200809L
#define _DEFAULT_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <sys/ioctl.h>
#include <dirent.h>
#include <time.h>
#include <ctype.h>
#include <termios.h>
#include <fcntl.h>
#include <math.h>
#include "nostr_chacha20.h"
#include "otp.h"
#define MAX_INPUT_SIZE 4096
#define MAX_LINE_LENGTH 1024
#define MAX_HASH_LENGTH 65
#define PROGRESS_UPDATE_INTERVAL (64 * 1024 * 1024) // 64MB intervals
#define DEFAULT_PADS_DIR "pads"
#define FILES_DIR "files"
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// GLOBAL VARIABLES
///////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
char current_pads_dir[512] = DEFAULT_PADS_DIR;

338
src/otp.h Normal file
View File

@@ -0,0 +1,338 @@
#ifndef OTP_H
#define OTP_H
////////////////////////////////////////////////////////////////////////////////
// OTP CIPHER - FUNCTION PROTOTYPES HEADER
// One Time Pad Implementation v0.2.109
//
// This header file contains all function prototypes extracted from otp.c
// Organized by functional categories for better maintainability
////////////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <termios.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <time.h>
#include <dirent.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <ctype.h>
// Constants
#define MAX_INPUT_SIZE 4096
#define MAX_LINE_LENGTH 1024
#define MAX_HASH_LENGTH 65
#define PROGRESS_UPDATE_INTERVAL (64 * 1024 * 1024) // 64MB intervals
#define DEFAULT_PADS_DIR "pads"
#define FILES_DIR "files"
#define MAX_ENTROPY_BUFFER (4 * 1024 * 1024) // 4MB entropy buffer for large operations
// Global variables - now managed through state module
//////////////////////////////////////////////////////////////////////////////
// STATE MANAGEMENT FUNCTIONS
//////////////////////////////////////////////////////////////////////////////
// State getters and setters
const char* get_current_pads_dir(void);
void set_current_pads_dir(const char* dir);
int get_interactive_mode(void);
void set_interactive_mode(int mode);
int get_terminal_width(void);
int get_terminal_height(void);
void set_terminal_dimensions(int width, int height);
////////////////////////////////////////////////////////////////////////////////
// TYPE DEFINITIONS
////////////////////////////////////////////////////////////////////////////////
// Decrypt operation modes for universal decrypt function
typedef enum {
DECRYPT_MODE_INTERACTIVE, // Interactive text decryption with prompts
DECRYPT_MODE_SILENT, // Silent text decryption (no prompts/labels)
DECRYPT_MODE_FILE_TO_TEXT, // File to text output with prompts
DECRYPT_MODE_FILE_TO_FILE // File to file output (binary)
} decrypt_mode_t;
// Pad filter types for selection functions
typedef enum {
PAD_FILTER_ALL, // Show all pads
PAD_FILTER_UNUSED_ONLY // Show only unused pads (0% usage)
} pad_filter_type_t;
// Enhanced entropy system state structure
typedef struct {
size_t target_bytes; // Target entropy to collect
size_t collected_bytes; // Bytes collected so far
size_t unique_keys; // Number of unique keys pressed
double collection_start_time; // Start timestamp
double last_keypress_time; // Last keypress timestamp
unsigned char quality_score; // Entropy quality (0-100)
int auto_complete_enabled; // Allow auto-complete at minimum
unsigned char key_histogram[256]; // Track key frequency
} entropy_collection_state_t;
////////////////////////////////////////////////////////////////////////////////
// CORE APPLICATION FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
// Main application entry points
int main(int argc, char* argv[]);
int interactive_mode(void);
int command_line_mode(int argc, char* argv[]);
int pipe_mode(int argc, char* argv[], const char* piped_text);
////////////////////////////////////////////////////////////////////////////////
// INPUT/OUTPUT DETECTION FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
// Stdin detection functions
int has_stdin_data(void);
char* read_stdin_text(void);
////////////////////////////////////////////////////////////////////////////////
// PREFERENCES MANAGEMENT FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
// Configuration and preferences handling
int load_preferences(void);
int save_preferences(void);
char* get_preference(const char* key);
int set_preference(const char* key, const char* value);
char* get_default_pad_path(void);
int set_default_pad_path(const char* pad_path);
////////////////////////////////////////////////////////////////////////////////
// HARDWARE DETECTION FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
// OTP thumb drive detection function
int detect_otp_thumb_drive(char* otp_drive_path, size_t path_size);
////////////////////////////////////////////////////////////////////////////////
// USB DRIVE MANAGEMENT FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// EXTERNAL TOOL INTEGRATION FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
// Editor and file manager functions
char* get_preferred_editor(void);
char* get_preferred_file_manager(void);
int launch_text_editor(const char* initial_content, char* result_buffer, size_t buffer_size);
int launch_file_manager(const char* start_directory, char* selected_file, size_t buffer_size);
////////////////////////////////////////////////////////////////////////////////
// CORE CRYPTOGRAPHIC OPERATIONS
////////////////////////////////////////////////////////////////////////////////
// Primary encryption/decryption functions
int generate_pad(uint64_t size_bytes, int show_progress);
int encrypt_text(const char* pad_identifier, const char* input_text);
int decrypt_text(const char* pad_identifier, const char* encrypted_message);
int encrypt_file(const char* pad_identifier, const char* input_file, const char* output_file, int ascii_armor);
int decrypt_file(const char* input_file, const char* output_file);
int decrypt_binary_file(FILE* input_fp, const char* output_file);
int decrypt_ascii_file(const char* input_file, const char* output_file);
////////////////////////////////////////////////////////////////////////////////
// ENHANCED ENTROPY SYSTEM FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
// Entropy source types
typedef enum {
ENTROPY_SOURCE_KEYBOARD = 1,
ENTROPY_SOURCE_DICE = 2,
ENTROPY_SOURCE_TRUERNG = 3,
ENTROPY_SOURCE_FILE = 4
} entropy_source_t;
// Terminal control for entropy collection
int setup_raw_terminal(struct termios* original_termios);
void restore_terminal(struct termios* original_termios);
// Entropy collection and feedback
int collect_entropy_with_feedback(unsigned char* entropy_buffer, size_t target_bytes,
size_t* collected_bytes, int allow_early_exit);
void display_entropy_progress(const entropy_collection_state_t* state);
void draw_progress_bar(double percentage, int width);
void draw_quality_bar(double quality, int width, const char* label);
// Hardware RNG Device Constants (lowercase to match sysfs output)
#define TRUERNG_VID "04d8"
#define TRUERNG_ORIGINAL_PID "f5fe"
#define TRUERNG_PRO_PID "0aa0"
#define TRUERNG_PRO_V2_PID "ebb5"
// Hardware RNG Device Type enumeration
typedef enum {
TRUERNG_ORIGINAL = 1,
TRUERNG_PRO = 2,
TRUERNG_PRO_V2 = 3
} hardware_rng_device_type_t;
// Hardware RNG device information structure
typedef struct {
char port_path[256]; // Device port path (e.g., /dev/ttyUSB0)
hardware_rng_device_type_t device_type; // Device type identifier
char friendly_name[64]; // Human-readable device name
int is_working; // 1 if device passes basic test, 0 otherwise
} hardware_rng_device_t;
// Hardware RNG device detection and selection functions
int detect_all_hardware_rng_devices(hardware_rng_device_t* devices, int max_devices, int* num_devices_found);
int test_hardware_rng_device(const hardware_rng_device_t* device);
int select_hardware_rng_device_interactive(hardware_rng_device_t* devices, int num_devices, hardware_rng_device_t* selected_device);
int find_truerng_port(char* port_path, size_t port_path_size, hardware_rng_device_type_t* device_type); // Legacy function for backward compatibility
// TrueRNG entropy collection functions (updated to match implementation)
int configure_rng_serial_port(int fd, hardware_rng_device_type_t device_type);
int setup_truerng_serial_port(const char* port_path);
int collect_truerng_entropy(unsigned char* entropy_buffer, size_t target_bytes, size_t* collected_bytes, int display_progress);
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);
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);
const char* get_truerng_device_name(hardware_rng_device_type_t device_type);
int read_usb_device_info(const char* port_name, char* vid, char* pid);
// Dice entropy collection functions (updated to match implementation)
int collect_dice_entropy(unsigned char* entropy_buffer, size_t target_bytes, size_t* collected_bytes, int display_progress);
// File entropy collection functions
int get_file_entropy_info(char* file_path, size_t max_path_len, size_t* file_size, int display_progress);
int collect_file_entropy(unsigned char* entropy_buffer, size_t target_bytes, size_t* collected_bytes, int display_progress);
int add_file_entropy_streaming(const char* pad_chksum, const char* file_path, size_t file_size, int display_progress);
// Unified entropy collection interface (updated to match implementation)
int collect_entropy_by_source(entropy_source_t source, unsigned char* entropy_buffer, size_t target_bytes, size_t* collected_bytes, int display_progress);
// Entropy quality calculation
double calculate_timing_quality(const entropy_collection_state_t* state);
double calculate_variety_quality(const entropy_collection_state_t* state);
unsigned char calculate_overall_quality(const entropy_collection_state_t* state);
double get_precise_time(void);
// Entropy processing and application
int derive_chacha20_params(const unsigned char* entropy_data, size_t entropy_size,
unsigned char key[32], unsigned char nonce[12]);
int add_entropy_to_pad(const char* pad_chksum, const unsigned char* entropy_data,
size_t entropy_size, int show_progress);
int add_entropy_direct_xor(const char* pad_chksum, const unsigned char* entropy_data,
size_t entropy_size, uint64_t pad_size, int display_progress);
int add_entropy_chacha20(const char* pad_chksum, const unsigned char* entropy_data,
size_t entropy_size, uint64_t pad_size, int display_progress);
int handle_add_entropy_to_pad(const char* pad_chksum);
// Enhanced entropy system helper functions
int update_pad_checksum_after_entropy(const char* old_chksum, char* new_chksum);
int rename_pad_files_safely(const char* old_chksum, const char* new_chksum);
int is_pad_unused(const char* pad_chksum);
////////////////////////////////////////////////////////////////////////////////
// DIRECTORY MANAGEMENT FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
// Directory handling and path management
int ensure_pads_directory(void);
void get_pad_path(const char* chksum, char* pad_path, char* state_path);
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);
////////////////////////////////////////////////////////////////////////////////
// UTILITY FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
// General utility and helper functions
uint64_t parse_size_string(const char* size_str);
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);
////////////////////////////////////////////////////////////////////////////////
// FILE OPERATIONS
////////////////////////////////////////////////////////////////////////////////
// File state and checksum operations
int read_state_offset(const char* pad_chksum, uint64_t* offset);
int write_state_offset(const char* pad_chksum, uint64_t offset);
int calculate_checksum(const char* filename, char* checksum_hex);
int calculate_checksum_with_progress(const char* filename, char* checksum_hex, int display_progress, uint64_t file_size);
////////////////////////////////////////////////////////////////////////////////
// UNIVERSAL CORE FUNCTIONS FOR CODE CONSOLIDATION
////////////////////////////////////////////////////////////////////////////////
// Consolidated cryptographic operations
int universal_xor_operation(const unsigned char* data, size_t data_len,
const unsigned char* pad_data, unsigned char* result);
int parse_ascii_message(const char* message, char* chksum, uint64_t* offset, char* base64_data);
int load_pad_data(const char* pad_chksum, uint64_t offset, size_t length, unsigned char** pad_data);
int generate_ascii_armor(const char* chksum, uint64_t offset, const unsigned char* encrypted_data,
size_t data_length, char** ascii_output);
int validate_pad_integrity(const char* pad_path, const char* expected_chksum);
// Universal decrypt function - consolidates all decrypt operations
int universal_decrypt(const char* input_data, const char* output_target, decrypt_mode_t mode);
////////////////////////////////////////////////////////////////////////////////
// BASE64 ENCODING FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
// Custom base64 implementation
char* custom_base64_encode(const unsigned char* input, int length);
unsigned char* custom_base64_decode(const char* input, int* output_length);
////////////////////////////////////////////////////////////////////////////////
// TERMINAL UI FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
// Terminal dimension and UI functions
void init_terminal_dimensions(void);
void print_centered_header(const char* text, int pause_before_clear);
////////////////////////////////////////////////////////////////////////////////
// MENU SYSTEM FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
// Interactive menu interface functions
void show_main_menu(void);
int handle_generate_menu(void);
int handle_encrypt_menu(void);
int handle_decrypt_menu(void);
int handle_pads_menu(void);
int handle_text_encrypt(void);
int handle_file_encrypt(void);
int handle_verify_pad(const char* pad_chksum);
int handle_delete_pad(const char* pad_chksum);
////////////////////////////////////////////////////////////////////////////////
// ENHANCED INPUT FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
// Advanced input handling
int get_filename_with_default(const char* prompt, const char* default_path, char* result, size_t result_size);
////////////////////////////////////////////////////////////////////////////////
// PAD SELECTION FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
// Unified pad selection interface
char* select_pad_interactive(const char* title, const char* prompt, pad_filter_type_t filter_type, int allow_cancel);
////////////////////////////////////////////////////////////////////////////////
// USAGE AND HELP FUNCTIONS
////////////////////////////////////////////////////////////////////////////////
// Help and usage display
void print_usage(const char* program_name);
#endif // OTP_H

2
src/pads.c
View File

@@ -16,7 +16,7 @@
#include <fcntl.h>
#include <math.h>
#include <errno.h>
#include "../include/otp.h"
#include "otp.h"
// Extracted pad management functions from otp.c

2
src/state.c
View File

@@ -1,6 +1,6 @@
#include <string.h>
#include <stdlib.h>
#include "../include/otp.h"
#include "otp.h"
// Global state variables
static char current_pads_dir[512] = DEFAULT_PADS_DIR;

4
src/trng.c
View File

@@ -16,8 +16,8 @@
#include <fcntl.h>
#include <math.h>
#include <errno.h>
#include "../nostr_chacha20.h"
#include "../include/otp.h"
#include "nostr_chacha20.h"
#include "otp.h"
// Basic TrueRNG entropy collection function
int collect_truerng_entropy(unsigned char* entropy_buffer, size_t target_bytes, size_t* collected_bytes, int display_progress) {

2
src/ui.c
View File

@@ -15,7 +15,7 @@
#include <termios.h>
#include <fcntl.h>
#include <math.h>
#include "../include/otp.h"
#include "otp.h"
// Initialize terminal dimensions
void init_terminal_dimensions(void) {

2
src/util.c
View File

@@ -15,7 +15,7 @@
#include <termios.h>
#include <fcntl.h>
#include <math.h>
#include "../include/otp.h"
#include "otp.h"
// Global variables for preferences
static char default_pad_path[1024] = "";