345 lines
16 KiB
C
345 lines
16 KiB
C
#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);
|
|
|
|
// TrueRNG Device Constants (updated to match otp.c implementation)
|
|
#define TRUERNG_VID "04D8"
|
|
#define TRUERNG_PID "F5FE"
|
|
#define TRUERNGPRO_VID "16D0"
|
|
#define TRUERNGPRO_PID "0AA0"
|
|
#define TRUERNGPROV2_VID "04D8"
|
|
#define TRUERNGPROV2_PID "EBB5"
|
|
|
|
// SwiftRNG Device Constants (same VID/PID as TrueRNG devices)
|
|
#define SWIFT_RNG_VID "04D8"
|
|
#define SWIFT_RNG_PID "F5FE"
|
|
#define SWIFT_RNG_PRO_VID "16D0"
|
|
#define SWIFT_RNG_PRO_PID "0AA0"
|
|
#define SWIFT_RNG_PRO_V2_VID "04D8"
|
|
#define SWIFT_RNG_PRO_V2_PID "EBB5"
|
|
|
|
// TrueRNG/SwiftRNG Device Type enumeration
|
|
typedef enum {
|
|
TRUERNG_ORIGINAL = 1,
|
|
TRUERNG_PRO = 2,
|
|
TRUERNG_PRO_V2 = 3,
|
|
SWIFT_RNG = 4,
|
|
SWIFT_RNG_PRO = 5,
|
|
SWIFT_RNG_PRO_V2 = 6
|
|
} truerng_device_type_t;
|
|
|
|
// Hardware RNG device information structure
|
|
typedef struct {
|
|
char port_path[256]; // Device port path (e.g., /dev/ttyUSB0)
|
|
truerng_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, truerng_device_type_t* device_type); // Legacy function for backward compatibility
|
|
|
|
// TrueRNG entropy collection functions (updated to match implementation)
|
|
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(truerng_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);
|
|
|
|
// 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
|