Version v0.3.31 - Update readme.md

.gitignore

@@ -1,9 +1,26 @@
-otp
+# Build artifacts
+build/
+*.o
+src/*.o
+
+# Runtime directories
 pads/
 files/
+
+# Personal files
 Gemini.md
 TropicOfCancer-HenryMiller.txt
 .gitea_token
 true_rng/
 Trash/
-# Auto-generated files (none currently)
+
+# Test binaries
+debug
+test_swiftrng
+test_swiftrng_debug
+test_swiftrng_detailed
+test_truerng
+
+# Temporary files
+*.pad
+*.state

HARDWARE_RNG_STATUS.md

@@ -1,46 +0,0 @@
-
-# Hardware RNG Implementation Status
-
-## Overview
-
-The OTP cipher application now includes comprehensive hardware Random Number Generator (RNG) device support with automatic detection, device identification, and graceful handling of different device types.
-
-## Supported Devices
-
-### ✅ Fully Supported (TrueRNG Family)
-- **TrueRNG Original** (VID: 04d8, PID: f5fe)
-- **TrueRNG Pro** (VID: 04d8, PID: 0aa0)  
-- **TrueRNG Pro V2** (VID: 04d8, PID: ebb5)
-
-These devices work via serial port communication and are fully integrated into the entropy collection system.
-
-### ⚠️ Detected but Not Supported (SwiftRNG Family)
-- **SwiftRNG** (VID: 1fc9, PID: 8111)
-
-SwiftRNG devices are detected and identified but cannot be used via serial port communication. They require the official SwiftRNG API with libusb-1.0 integration.
-
-## Implementation Features
-
-### Device Detection
-- **Automatic scanning** of `/dev/ttyUSB*` and `/dev/ttyACM*` devices
-- **VID/PID identification** via sysfs to distinguish device types
-- **Multi-device support** with interactive selection menus
-- **Real-time status indicators** showing device availability
-
-### Device Communication
-- **Optimized serial port configuration** for each device type
-- **Timeout protection** to prevent hanging on unresponsive devices
-- **Error handling** with clear diagnostic messages
-- **Progress tracking** with speed estimation for large entropy collections
-
-### Integration Points
-- **Pad enhancement** via entropy addition to existing pads
-- **Interactive menus** for device selection when multiple devices are present
-- **Command-line support** for automated workflows
-- **Graceful fallback** to other entropy sources when no hardware RNG is available
-
-## Technical Implementation
-
-### Core Functions
-- `detect_all_hardware_rng_devices()` - Scans and identifies all connected devices
-- `collect_truerng_entropy_from_device()` - Collects entropy from TrueRNG devices

Makefile

@@ -1,29 +1,34 @@
 CC = gcc
-CFLAGS = -Wall -Wextra -std=c99 -Iinclude
+CFLAGS = -Wall -Wextra -std=c99 -Isrc
 LIBS = -lm
 LIBS_STATIC = -static -lm
-TARGET = otp
+ARCH = $(shell uname -m)
-SOURCES = $(wildcard src/*.c) nostr_chacha20.c otp.c
+TARGET = build/otp-$(ARCH)
+SOURCES = $(wildcard src/*.c)
 OBJS = $(SOURCES:.c=.o)
 
 # Default build target
 $(TARGET): $(OBJS)
+	@mkdir -p build
 	$(CC) $(CFLAGS) -o $(TARGET) $(OBJS) $(LIBS)
+	@rm -f $(OBJS)
 
 # Static linking target
 static: $(OBJS)
+	@mkdir -p build
 	$(CC) $(CFLAGS) -o $(TARGET) $(OBJS) $(LIBS_STATIC)
+	@rm -f $(OBJS)
 
 %.o: %.c
 	$(CC) $(CFLAGS) -c $< -o $@
 
 clean:
-	rm -f $(TARGET) $(OBJS) *.pad *.state
+	rm -f $(OBJS) src/*.o build/otp-* *.pad *.state
 
 install:
-	sudo cp $(TARGET) /usr/local/bin/
+	sudo cp $(TARGET) /usr/local/bin/otp
 
 uninstall:
-	sudo rm -f /usr/local/bin/$(TARGET)
+	sudo rm -f /usr/local/bin/otp
 
 .PHONY: clean install uninstall static

README.md

@@ -1,5 +1,47 @@
 # OTP Cipher - One Time Pad Implementation
 
+## Quick Start
+
+### Download Pre-Built Binaries
+
+**[📥 Download Latest Release](https://git.laantungir.net/laantungir/otp/releases)**
+
+Visit the releases page and download the appropriate binary for your system:
+- `otp-vX.X.X-linux-x86_64` for Intel/AMD 64-bit systems
+- `otp-vX.X.X-linux-arm64` for Raspberry Pi and ARM 64-bit systems
+
+After downloading:
+```bash
+# Make executable and run
+chmod +x otp-v*-linux-x86_64
+./otp-v*-linux-x86_64
+```
+
+**Or use the local build:**
+```bash
+# After building from source
+./build/otp-x86_64    # x86_64 systems
+./build/otp-arm64     # ARM64 systems
+```
+
+### First Steps
+
+1. **Generate your first pad:**
+   ```bash
+   ./build/otp-x86_64 generate 1GB
+   ```
+
+2. **Encrypt a message:**
+   ```bash
+   ./build/otp-x86_64 encrypt
+   # Follow the interactive prompts
+   ```
+
+3. **Decrypt a message:**
+   ```bash
+   ./build/otp-x86_64 decrypt
+   # Paste the encrypted message
+   ```
 
 ## Introduction
 
@@ -64,99 +106,98 @@ One-time pads can be trivially encrypted and decrypted using pencil and paper, m
 - GCC compiler
 - Git (for version tracking)
 - Make
-
+- Optional: ARM64 cross-compiler (`gcc-aarch64-linux-gnu`) for cross-compilation
-
 
 ### Build Commands
 
-Use the included build script for automatic versioning:
+Use the included build script for automatic versioning and cross-compilation:
 
 ```bash
-# Standard build (default)
+# Build for current architecture (with auto-versioning)
-./build.sh build
+./build.sh "commit message"
 
-# Static linking build
+# Build commands
-./build.sh static
+./build.sh build "commit message"  # Build x86_64 and ARM64 (if cross-compiler available)
-
+./build.sh clean                   # Clean build artifacts
-# Clean build artifacts
+./build.sh install                 # Install to system
-./build.sh clean
+./build.sh uninstall               # Remove from system
-
-# Generate version files only
-./build.sh version
-
-# Install to system
-./build.sh install
-
-# Remove from system
-./build.sh uninstall
-
-# Show usage
-./build.sh help
 ```
 
+The build script automatically:
+- Increments patch version (v0.3.24 → v0.3.25)
+- Creates git commit and tag
+- Builds for x86_64 and ARM64 (if cross-compiler available)
+- Outputs to `build/otp-x86_64` and `build/otp-arm64`
+- Uploads binaries to Gitea releases (if `~/.gitea_token` exists)
+
 ### Traditional Make
 
 You can also use make directly (without automatic versioning):
 
 ```bash
-make            # Standard build
+make            # Build for current architecture
 make static     # Static linking
 make clean      # Clean artifacts
-make install    # Install to /usr/local/bin/
+make install    # Install to /usr/local/bin/otp
 make uninstall  # Remove from system
 ```
 
+Output: `build/otp-$(ARCH)` (e.g., `build/otp-x86_64`)
+
 ## Usage
 
 ### Interactive Mode
 ```bash
-./otp
+./build/otp-x86_64
+# or
+./build/otp-arm64  # On ARM systems
 ```
 
 ### Command Line Mode
 ```bash
 # Generate a new pad
-./otp generate 1GB
+./build/otp-x86_64 generate 1GB
 
 # Encrypt text (interactive input)
-./otp encrypt <pad_hash_or_prefix>
+./build/otp-x86_64 encrypt <pad_hash_or_prefix>
 
 # Decrypt message (interactive input)
-./otp decrypt <pad_hash_or_prefix>
+./build/otp-x86_64 decrypt <pad_hash_or_prefix>
 
 # List available pads
-./otp list
+./build/otp-x86_64 list
 ```
 
-## Version System Details
+## Version System
+
+### Centralized Version Management
+Version is defined in a single location: `src/main.h`
+```c
+#define OTP_VERSION "v0.3.24"
+```
+
+All code references this constant, ensuring consistency across:
+- Main menu display
+- ASCII armor output
+- Help/usage text
 
 ### Automatic Version Increment
-Every build automatically increments the patch version:
+The `build.sh` script automatically:
-- v0.1.0 → v0.1.1 → v0.1.2, etc.
+1. Increments patch version (v0.3.24 → v0.3.25)
-- Creates git tags for each version
+2. Updates `OTP_VERSION` in `src/main.h`
-- Embeds detailed build information
+3. Creates git commit and tag
+4. Pushes to remote repository
 
 ### Manual Version Control
 For major/minor releases, create tags manually:
 ```bash
 # Feature release (minor bump)
-git tag v0.2.0    # Next build: v0.2.1
+git tag v0.4.0    # Next build: v0.4.1
 
 # Breaking change (major bump)
 git tag v1.0.0    # Next build: v1.0.1
 ```
 
-### Version Information Available
-- Version number (major.minor.patch)
-- Git commit hash and branch
-- Build date and time
-- Full version display with metadata
-
-### Generated Files
-The build system automatically manages Git versioning by incrementing tags.
-
-These files are excluded from git (.gitignore) and regenerated on each build.
-
 ## Security Features
 
 - Uses `/dev/urandom` for cryptographically secure random number generation
@@ -166,28 +207,32 @@ These files are excluded from git (.gitignore) and regenerated on each build.
 - State tracking to prevent pad reuse
 - **Zero external crypto dependencies** - completely self-contained implementation
 
-## File Structure
+## Project Structure
 
 ```
 otp/
 ├── build.sh              # Build script with automatic versioning
 ├── Makefile             # Traditional make build system
-├── otp.c            # Legacy compatibility and global definitions
 ├── README.md            # This file
 ├── .gitignore           # Git ignore rules
-├── include/
-│   └── otp.h        # Public API header with all function prototypes
 ├── src/
-│   ├── main.c       # Main application entry point and command line handling
+│   ├── main.h           # Main header with all prototypes and OTP_VERSION
+│   ├── main.c           # Application entry point and command line handling
 │   ├── ui.c             # Interactive user interface and menu system
-│   ├── state.c      # Global state management (pads directory, terminal dimensions)
+│   ├── state.c          # Global state management (pads directory, preferences)
-│   ├── crypto.c     # Core cryptographic operations (XOR, ChaCha20)
+│   ├── crypto.c         # Core cryptographic operations (XOR, base64)
 │   ├── pads.c           # Pad management and file operations
 │   ├── entropy.c        # Entropy collection from various sources
-│   ├── trng.c       # Hardware RNG device detection and entropy collection
+│   ├── trng.c           # Hardware RNG device detection and collection
-│   └── util.c       # Utility functions and helpers
+│   ├── util.c           # Utility functions and helpers
+│   ├── nostr_chacha20.c # ChaCha20 implementation for entropy expansion
+│   └── nostr_chacha20.h # ChaCha20 header
+├── build/
+│   ├── otp-x86_64       # Native x86_64 binary (created by build)
+│   └── otp-arm64        # ARM64 binary (created by cross-compilation)
 ├── pads/                # OTP pad storage directory (created at runtime)
-└── VERSION          # Plain text version (generated)
+├── files/               # Encrypted file storage (created at runtime)
+└── tests/               # Test scripts and utilities
 ```
 
 ## Architecture
@@ -197,13 +242,14 @@ The OTP cipher uses a modular architecture with clean separation of concerns:
 - **main.c**: Application entry point, command line parsing, and mode selection
 - **ui.c**: Interactive user interface, menus, and terminal management
 - **state.c**: Global state management (pads directory, terminal dimensions, preferences)
-- **crypto.c**: Core cryptographic operations (XOR encryption, ChaCha20 entropy mixing)
+- **crypto.c**: Core cryptographic operations (XOR encryption, base64 encoding)
 - **pads.c**: Pad file management, checksums, and state tracking
-- **entropy.c**: Entropy collection from keyboard, dice, and other sources
+- **entropy.c**: Entropy collection from keyboard, dice, files, and hardware RNG
 - **trng.c**: Hardware RNG device detection and entropy collection from USB devices
 - **util.c**: Utility functions, file operations, and helper routines
+- **nostr_chacha20.c**: ChaCha20 stream cipher for entropy expansion
 
-All modules share a common header (`include/otp.h`) that defines the public API and data structures.
+All modules share a common header (`src/main.h`) that defines the public API, data structures, and version constant.
 
 ## Hardware RNG Device Support
 
@@ -405,9 +451,22 @@ No.  ChkSum (first 16 chars) Size         Used         % Used
 
 This project includes automatic versioning system based on the Generic Automatic Version Increment System.
 
+## State Files
+
+Pad state files (`.state`) use a human-readable text format:
+```
+offset=1234567890
+```
+
+This tracks how many bytes of each pad have been used. The format is:
+- **Human-readable**: Can inspect with `cat checksum.state`
+- **Backward compatible**: Automatically reads old binary format
+- **Easy to debug**: Can manually edit if needed
+
 ## Contributing
 
 When contributing:
-1. The version will automatically increment on builds
+1. The version will automatically increment on builds via `build.sh`
-2. For major features, consider manually creating minor version tags
+2. Version is centralized in `src/main.h` as `OTP_VERSION`
-3. Generated version files (`src/version.*`, `VERSION`) should not be committed
+3. For major features, manually create minor/major version tags
+4. Build artifacts in `build/` and object files are auto-cleaned

TODO.md

@@ -1,3 +0,0 @@
-# TODO
-
-## The pad menu in interactive encrypt mode gives numbers instead of checksum selection

build.sh

@@ -146,20 +146,14 @@ increment_version() {
 update_source_version() {
     local NEW_VERSION="$1"
     
-    print_status "Updating version strings in source code..."
+    print_status "Updating version constant in source code..."
     
-    # Replace hardcoded version strings in otp.c with the current git tag
+    # Update OTP_VERSION constant in src/main.h
-    if [ -f "otp.c" ]; then
+    if [ -f "src/main.h" ]; then
-        # Update main menu version
+        sed -i "s/#define OTP_VERSION \"v[0-9]\+\.[0-9]\+\.[0-9]\+\"/#define OTP_VERSION \"$NEW_VERSION\"/g" src/main.h
-        sed -i "s/OTP v[0-9]\+\.[0-9]\+\.[0-9]\+/OTP $NEW_VERSION/g" otp.c
+        print_success "Updated OTP_VERSION in src/main.h to $NEW_VERSION"
-        # Update ASCII output version
-        sed -i "s/Version: v[0-9]\+\.[0-9]\+\.[0-9]\+/Version: $NEW_VERSION/g" otp.c
-        # Update usage/help text version
-        sed -i "s/Implementation v[0-9]\+\.[0-9]\+\.[0-9]\+/Implementation $NEW_VERSION/g" otp.c
-        
-        print_success "Updated version strings in otp.c to $NEW_VERSION"
     else
-        print_warning "otp.c not found - skipping version string updates"
+        print_warning "src/main.h not found - skipping version update"
     fi
 }
 
@@ -235,16 +229,16 @@ create_gitea_release() {
     if echo "$response" | grep -q '"id"'; then
         print_success "Created release $version"
         
-        # Upload binaries with descriptive names
+        # Upload binaries with descriptive names from build directory
-        upload_release_asset "$api_url" "$token" "$version" "otp-x86_64" "otp-${version}-linux-x86_64"
+        upload_release_asset "$api_url" "$token" "$version" "build/otp-x86_64" "otp-${version}-linux-x86_64"
-        upload_release_asset "$api_url" "$token" "$version" "otp-arm64" "otp-${version}-linux-arm64"
+        upload_release_asset "$api_url" "$token" "$version" "build/otp-arm64" "otp-${version}-linux-arm64"
     else
         print_warning "Release may already exist or creation failed"
         print_status "Response: $response"
         
         # Try to upload to existing release anyway
-        upload_release_asset "$api_url" "$token" "$version" "otp-x86_64" "otp-${version}-linux-x86_64"
+        upload_release_asset "$api_url" "$token" "$version" "build/otp-x86_64" "otp-${version}-linux-x86_64"
-        upload_release_asset "$api_url" "$token" "$version" "otp-arm64" "otp-${version}-linux-arm64"
+        upload_release_asset "$api_url" "$token" "$version" "build/otp-arm64" "otp-${version}-linux-arm64"
     fi
 }
 
@@ -259,9 +253,8 @@ build_project() {
         
         # Build x86_64 only
         print_status "Building OTP project for x86_64..."
-        make CC=gcc
+        make CC=gcc ARCH=x86_64
         if [ $? -eq 0 ]; then
-            mv otp otp-x86_64
             print_success "x86_64 build completed successfully"
         else
             print_error "x86_64 build failed"
@@ -270,10 +263,8 @@ build_project() {
     else
         # Build both architectures
         print_status "Building OTP project for x86_64..."
-        make clean
+        make CC=gcc ARCH=x86_64
-        make CC=gcc
         if [ $? -eq 0 ]; then
-            mv otp otp-x86_64
             print_success "x86_64 build completed successfully"
         else
             print_error "x86_64 build failed"
@@ -281,10 +272,10 @@ build_project() {
         fi
         
         print_status "Building OTP project for ARM64/AArch64..."
-        make clean
+        # Clean only object files, not the x86_64 binary
-        make CC=aarch64-linux-gnu-gcc
+        rm -f src/*.o
+        make CC=aarch64-linux-gnu-gcc ARCH=arm64
         if [ $? -eq 0 ]; then
-            mv otp otp-arm64
             print_success "ARM64/AArch64 build completed successfully"
         else
             print_error "ARM64/AArch64 build failed"
@@ -292,6 +283,10 @@ build_project() {
         fi
     fi
     
+    # Clean up object files after successful build
+    print_status "Cleaning up object files..."
+    rm -f src/*.o
+    
     # Create Gitea release with binaries
     if [ -f "$HOME/.gitea_token" ]; then
         create_gitea_release "$NEW_VERSION"
@@ -306,8 +301,8 @@ build_project() {
 clean_project() {
     print_status "Cleaning build artifacts..."
     make clean
-    # Remove cross-compiled binaries
+    # Remove build directory
-    rm -f otp-x86_64 otp-arm64
+    rm -rf build
     print_success "Clean completed"
 }
 
@@ -362,8 +357,8 @@ case "$COMMAND" in
         echo "  uninstall - Remove from system"
         echo ""
         echo "Build Output:"
-        echo "  otp-x86_64  - Native x86_64 binary"
+        echo "  build/otp-x86_64  - Native x86_64 binary"
-        echo "  otp-arm64   - ARM64/AArch64 binary for Raspberry Pi (if cross-compiler available)"
+        echo "  build/otp-arm64   - ARM64/AArch64 binary for Raspberry Pi (if cross-compiler available)"
         echo ""
         echo "Gitea Integration:"
         echo "  - Automatically creates releases with binaries if ~/.gitea_token exists"

debug.c

@@ -1 +0,0 @@
-int main() { printf("Testing direct filename: %d\n", strncmp("97d9d82b5414a9439102f3811fb90ab1d6368a00d33229a18b306476f9d04f82.pad", "97", 2)); return 0; }

manual_test.sh

@@ -1,22 +0,0 @@
-#!/bin/bash
-
-echo "Manual OTP Test"
-echo "==============="
-
-# Generate a test pad
-echo "Generating test pad..."
-./otp generate demo 1
-echo
-
-# Create a test message file for encryption
-echo "Creating test message..."
-echo "This is a secret message for testing OTP encryption!" > test_message.txt
-
-# Test encryption interactively
-echo "Testing encryption (will prompt for input):"
-echo "Please enter: This is a secret message for testing OTP encryption!"
-./otp encrypt demo
-
-echo
-echo "Files created:"
-ls -la demo.*

otp

@@ -0,0 +1 @@
+./build/otp-x86_64

otp.c

@@ -1,35 +0,0 @@
-#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;

otp.h

@@ -1,329 +0,0 @@
-#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
-
-////////////////////////////////////////////////////////////////////////////////
-//      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);
-
-////////////////////////////////////////////////////////////////////////////////
-//      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

src/crypto.c

@@ -5,7 +5,7 @@
 #include <stdio.h>
 #include <time.h>
 #include <unistd.h>
-#include "../include/otp.h"
+#include "main.h"
 
 #define PROGRESS_UPDATE_INTERVAL (64 * 1024 * 1024)  // 64MB intervals
 
@@ -198,7 +198,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.3.16\n");
+    snprintf(temp_line, sizeof(temp_line), "Version: %s\n", OTP_VERSION);
     strcat(*ascii_output, temp_line);
     
     snprintf(temp_line, sizeof(temp_line), "Pad-ChkSum: %s\n", chksum);

src/entropy.c

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

src/main.c

@@ -15,7 +15,7 @@
 #include <termios.h>
 #include <fcntl.h>
 #include <math.h>
-#include "../include/otp.h"
+#include "main.h"
 
 int main(int argc, char* argv[]) {
     // Initialize terminal dimensions first
@@ -241,7 +241,7 @@ int command_line_mode(int argc, char* argv[]) {
 }
 
 void print_usage(const char* program_name) {
-    printf("OTP Cipher - One Time Pad Implementation v0.3.16\n");
+    printf("OTP Cipher - One Time Pad Implementation %s\n", OTP_VERSION);
     printf("Built for testing entropy system\n");
     printf("Usage:\n");
     printf("  %s                                         - Interactive mode\n", program_name);

src/main.h

@@ -1,12 +1,12 @@
-#ifndef OTP_H
+#ifndef MAIN_H
-#define OTP_H
+#define MAIN_H
 
 ////////////////////////////////////////////////////////////////////////////////
-//      OTP CIPHER - FUNCTION PROTOTYPES HEADER
+//      OTP CIPHER - MAIN HEADER FILE
-//      One Time Pad Implementation v0.2.109
+//      One Time Pad Implementation
 //
-//      This header file contains all function prototypes extracted from otp.c
+//      This header file contains all function prototypes and type definitions
-//      Organized by functional categories for better maintainability
+//      for the OTP Cipher project
 ////////////////////////////////////////////////////////////////////////////////
 
 #include <stdio.h>
@@ -22,6 +22,9 @@
 #include <string.h>
 #include <ctype.h>
 
+// Version - Updated automatically by build.sh
+#define OTP_VERSION "v0.3.30"
+
 // Constants
 #define MAX_INPUT_SIZE 4096
 #define MAX_LINE_LENGTH 1024
@@ -335,4 +338,4 @@ char* select_pad_interactive(const char* title, const char* prompt, pad_filter_t
 // Help and usage display
 void print_usage(const char* program_name);
 
-#endif // OTP_H
+#endif // MAIN_H

src/pads.c

@@ -16,7 +16,7 @@
 #include <fcntl.h>
 #include <math.h>
 #include <errno.h>
-#include "../include/otp.h"
+#include "main.h"
 
 
 // Extracted pad management functions from otp.c
@@ -89,7 +89,10 @@ int generate_pad(uint64_t size_bytes, int display_progress) {
     const char* pads_dir = get_current_pads_dir();
     struct statvfs stat;
     if (statvfs(pads_dir, &stat) == 0) {
-        uint64_t available_bytes = stat.f_bavail * stat.f_frsize;
+        // Use f_bfree (total free blocks) instead of f_bavail (available to non-root)
+        // This gives the actual free space on the filesystem, which is more accurate
+        // for removable media and user-owned directories
+        uint64_t available_bytes = stat.f_bfree * stat.f_frsize;
         double available_gb = (double)available_bytes / (1024.0 * 1024.0 * 1024.0);
         double required_gb = (double)size_bytes / (1024.0 * 1024.0 * 1024.0);
         
@@ -233,7 +236,25 @@ int read_state_offset(const char* pad_chksum, uint64_t* offset) {
     const char* pads_dir = get_current_pads_dir();
     snprintf(state_filename, sizeof(state_filename), "%s/%s.state", pads_dir, pad_chksum);
 
-    FILE* state_file = fopen(state_filename, "rb");
+    FILE* state_file = fopen(state_filename, "r");
+    if (!state_file) {
+        *offset = 0;
+        return 0;
+    }
+
+    // Try to read as text format first (new format)
+    char line[128];
+    if (fgets(line, sizeof(line), state_file)) {
+        // Check if it's text format (starts with "offset=")
+        if (strncmp(line, "offset=", 7) == 0) {
+            *offset = strtoull(line + 7, NULL, 10);
+            fclose(state_file);
+            return 0;
+        }
+        
+        // Not text format, try binary format (legacy)
+        fclose(state_file);
+        state_file = fopen(state_filename, "rb");
         if (!state_file) {
             *offset = 0;
             return 0;
@@ -244,8 +265,12 @@ int read_state_offset(const char* pad_chksum, uint64_t* offset) {
             *offset = 0;
             return 0;
         }
+        fclose(state_file);
+        return 0;
+    }
 
     fclose(state_file);
+    *offset = 0;
     return 0;
 }
 
@@ -254,12 +279,13 @@ int write_state_offset(const char* pad_chksum, uint64_t offset) {
     const char* pads_dir = get_current_pads_dir();
     snprintf(state_filename, sizeof(state_filename), "%s/%s.state", pads_dir, pad_chksum);
 
-    FILE* state_file = fopen(state_filename, "wb");
+    FILE* state_file = fopen(state_filename, "w");
     if (!state_file) {
         return 1;
     }
 
-    if (fwrite(&offset, sizeof(uint64_t), 1, state_file) != 1) {
+    // Write in text format for human readability
+    if (fprintf(state_file, "offset=%lu\n", offset) < 0) {
         fclose(state_file);
         return 1;
     }

src/state.c

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

src/trng.c

@@ -16,8 +16,8 @@
 #include <fcntl.h>
 #include <math.h>
 #include <errno.h>
-#include "../nostr_chacha20.h"
+#include "nostr_chacha20.h"
-#include "../include/otp.h"
+#include "main.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) {

src/ui.c

@@ -15,7 +15,7 @@
 #include <termios.h>
 #include <fcntl.h>
 #include <math.h>
-#include "../include/otp.h"
+#include "main.h"
 
 // Initialize terminal dimensions
 void init_terminal_dimensions(void) {
@@ -120,7 +120,9 @@ int interactive_mode(void) {
 
 void show_main_menu(void) {
     printf("\n");
-    print_centered_header("Main Menu - OTP v0.3.16", 0);
+    char header[64];
+    snprintf(header, sizeof(header), "Main Menu - OTP %s", OTP_VERSION);
+    print_centered_header(header, 0);
     printf("\n");
 
     printf(" \033[4mT\033[0mext encrypt\n");    //TEXT ENCRYPT

src/util.c

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