otp/otp.h

#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 32768  // 32KB entropy buffer

// USB Drive constants
#define MAX_USB_DRIVES 16         // Maximum USB drives to enumerate
#define USB_LABEL_PREFIX "OTP_"   // Prefix for OTP USB drive labels
#define MAX_USB_LABEL_LENGTH 32   // Maximum length for USB volume labels

////////////////////////////////////////////////////////////////////////////////
//      TYPE DEFINITIONS
////////////////////////////////////////////////////////////////////////////////

// USB Drive Information Structure
typedef struct {
    char device_path[512];        // e.g., "/dev/sdb1"
    char device_name[64];         // e.g., "sdb1"
    char mount_path[512];         // e.g., "/media/user/OTP_ALICE"
    char volume_label[64];        // e.g., "OTP_ALICE"
    char filesystem[16];          // e.g., "ext4", "vfat"
    char bus_type[16];            // "usb", "sata", "nvme", etc.
    uint64_t total_size;          // Total drive capacity in bytes
    uint64_t available_size;      // Available space in bytes
    int is_mounted;               // 1 if currently mounted, 0 otherwise
    int is_otp_drive;            // 1 if recognized as OTP drive
    int is_removable;             // 1 if removable media, 0 if fixed
    int is_usb_device;            // 1 if connected via USB bus
    int is_system_mount;          // 1 if critical system mount
    int is_safe;                  // 1 if passed safety validation, 0 if unsafe
    int pad_count;               // Number of pads on drive
} usb_drive_info_t;

// USB Operation Result Structure
typedef struct {
    int success;                  // 1 for success, 0 for failure
    char error_message[256];      // Error description if failed
    int drives_found;             // Number of drives discovered
    int pads_transferred;         // Number of pads copied/verified
    uint64_t bytes_processed;     // Total data processed
} usb_operation_result_t;

// New simplified USB device structures for lsusb cross-referencing
typedef struct {
    char vendor_id[8];        // "1234" from lsusb
    char product_id[8];       // "5678" from lsusb
    char vendor_name[64];     // "SanDisk Corp." from lsusb
    char product_name[128];   // "Ultra Fit" from lsusb
    char bus_number[4];       // "001" from lsusb
    char device_number[4];    // "003" from lsusb
} usb_device_registry_t;

// Simplified USB status for new detection system
typedef enum {
    USB_SAFE,           // ✓ Safe USB drive detected by lsusb
    USB_TOO_LARGE,      // ⚠ Drive over 6TB safety limit
    USB_NOT_USB         // ✗ Not found in USB device registry
} usb_safety_status_t;

// New simplified drive info structure
typedef struct {
    char mount_path[512];         // "/media/user/DUAL DRIVE"
    char device_path[64];         // "/dev/sda1"
    char device_name[16];         // "sda"
    char label[64];               // "DUAL DRIVE"
    char filesystem[16];          // "vfat"
    uint64_t total_size;          // Total bytes
    uint64_t free_size;           // Free bytes
    int pad_count;                // Number of .pad files
    usb_safety_status_t status;   // USB safety status
    usb_device_registry_t *usb_device; // Pointer to USB device info (NULL if not USB)
} drive_info_v2_t;

// 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
////////////////////////////////////////////////////////////////////////////////

// USB Drive Discovery Functions
int discover_usb_drives(usb_drive_info_t** drives, int* drive_count);
int get_usb_drive_info(const char* mount_path, const char* drive_label, usb_drive_info_t* drive_info);
int get_device_from_mount(const char* mount_path, char* device_path, size_t device_path_size);
void format_size_string(uint64_t bytes, char* result, size_t result_size);

// USB Device Safety Functions
int is_device_removable_usb(const char* device_path);
int get_device_bus_type(const char* device_path, char* bus_type, size_t bus_type_size);
int is_system_critical_mount(const char* mount_path);
int validate_usb_device_safety(const usb_drive_info_t* drive);
int extract_device_name_from_path(const char* device_path, char* device_name, size_t device_name_size);

// Drive Initialization Functions
usb_operation_result_t initialize_usb_drive(const char* mount_path, const char* drive_name,
                                          int format_drive, const char* filesystem_type);
int set_volume_label(const char* mount_path, const char* new_label);

// Pad Transfer Functions
int copy_pad_to_usb(const char* pad_checksum, const char* usb_mount_path);
int copy_pad_from_usb(const char* usb_mount_path, const char* pad_checksum);
int copy_file(const char* source_path, const char* dest_path);
int list_pads_on_drive(const char* mount_path, char pad_list[][65], int max_pads);
int verify_pad_integrity_cross_drive(const char* local_pad, const char* usb_pad);

// Drive Duplication Functions
int duplicate_drive_selective(const char* source_mount, const char* dest_mount,
                            char selected_pads[][65], int pad_count);
int verify_drive_duplication(const char* source_mount, const char* dest_mount);

// USB Menu Integration Functions
int handle_usb_submenu(void);
int handle_initialize_usb(void);
int handle_copy_pad_to_usb(void);
int handle_import_pad_from_usb(void);
int handle_duplicate_usb_drive(void);
int handle_verify_usb_drive(void);
int handle_list_usb_drives(void);
usb_drive_info_t* select_usb_drive_interactive(const char* title, const char* prompt, int require_otp);

// USB CLI handler functions
int handle_list_usb_drives_cli(void);
int handle_usb_init_cli(int argc, char* argv[]);
int handle_usb_copy_cli(const char* pad_prefix, const char* usb_path);
int handle_usb_import_cli(const char* pad_checksum, const char* usb_path);
int handle_usb_verify_cli(const char* usb_path);

// New simplified USB detection system functions
int build_usb_device_registry(usb_device_registry_t **devices, int *device_count);
void free_usb_device_registry(usb_device_registry_t *devices);
usb_device_registry_t* find_usb_device_by_path(const char* device_path,
                                               usb_device_registry_t* usb_devices, int usb_count);
int detect_drive_info_v2(const char* mount_path, drive_info_v2_t* drive_info,
                         usb_device_registry_t* usb_devices, int usb_count);
void list_usb_drives_v2(void);
const char* get_usb_status_string(usb_safety_status_t status);

////////////////////////////////////////////////////////////////////////////////
//      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_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"

// TrueRNG Device Type enumeration
typedef enum {
    TRUERNG_ORIGINAL = 1,
    TRUERNG_PRO = 2,
    TRUERNG_PRO_V2 = 3
} truerng_device_type_t;

// TrueRNG entropy collection functions (updated to match implementation)
int find_truerng_port(char* port_path, size_t port_path_size, truerng_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);
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 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);

////////////////////////////////////////////////////////////////////////////////
//      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);

////////////////////////////////////////////////////////////////////////////////
//      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);

////////////////////////////////////////////////////////////////////////////////
//      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);

////////////////////////////////////////////////////////////////////////////////
//      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