Version v0.2.17 - Fix pad selection logic - allow flexible hex prefix matching instead of restrictive number selection

.clinerules/workspace_rules.md

@@ -0,0 +1,4 @@
+
+When building, use build.sh, not make. 
+
+Use it as follows: build.sh -m "useful comment on changes being made"

.gitignore

@@ -1,2 +1,9 @@
+otp
 pads/
 Gemini.md
+TropicOfCancer-HenryMiller.txt
+
+# Auto-generated version files
+src/version.h
+src/version.c
+VERSION

Makefile

@@ -1,14 +1,22 @@
 CC = gcc
 CFLAGS = -Wall -Wextra -std=c99
-LIBS = -lssl -lcrypto
+LIBS = 
+LIBS_STATIC = -static
 TARGET = otp
 SOURCE = otp.c
+VERSION_SOURCE = src/version.c
 
+# Default build target
 $(TARGET): $(SOURCE)
-	$(CC) $(CFLAGS) -o $(TARGET) $(SOURCE) $(LIBS)
+	$(CC) $(CFLAGS) -o $(TARGET) $(SOURCE) $(VERSION_SOURCE) $(LIBS)
+
+# Static linking target
+static: $(SOURCE)
+	$(CC) $(CFLAGS) -o $(TARGET) $(SOURCE) $(VERSION_SOURCE) $(LIBS_STATIC)
 
 clean:
 	rm -f $(TARGET) *.pad *.state
+	rm -f src/version.h src/version.c VERSION
 
 install:
 	sudo cp $(TARGET) /usr/local/bin/
@@ -16,4 +24,4 @@ install:
 uninstall:
 	sudo rm -f /usr/local/bin/$(TARGET)
 
-.PHONY: clean install uninstall
+.PHONY: clean install uninstall static

README.md

@@ -1,273 +1,283 @@
-# OTP Cipher v2.0 - Enhanced One Time Pad Implementation
+# OTP Cipher - One Time Pad Implementation
 
-A comprehensive and user-friendly One Time Pad (OTP) cryptographic system implemented in C for Linux, supporting massive pad sizes up to 10TB+ with both interactive and command-line interfaces.
-
-## New in Version 2.0 🚀
-
-- **Interactive Menu System** - User-friendly menu-driven interface
-- **Smart Size Parsing** - Supports K/KB/M/MB/G/GB/T/TB units
-- **Partial Hash Matching** - Use hash prefixes or pad numbers for selection
-- **Progress Indicators** - Real-time progress for large pad generation
-- **10TB+ Support** - Generate massive pads for external drives
-- **Enhanced Pad Management** - List, info, and usage statistics
+A secure one-time pad (OTP) cipher implementation in C with automatic versioning system.
 
 ## Features
 
-- **Cryptographically secure** random pad generation using `/dev/urandom`
-- **ASCII armor format** similar to PGP for encrypted messages
-- **Integrity verification** using SHA-256 hashing of pad files
-- **State management** to prevent pad reuse
-- **Interactive text encryption/decryption**
-- **Hash-based file naming** for content verification
-- **Read-only pad protection** prevents accidental corruption
+- **Perfect Security**: Implements true one-time pad encryption with information-theoretic security
+- **Text & File Encryption**: Supports both inline text and file encryption
+- **Multiple Output Formats**: Binary (.otp) and ASCII armored (.otp.asc) file formats
+- **Keyboard Entropy**: Optional keyboard entropy collection for enhanced randomness
+- **Short Command Flags**: Convenient single-character flags for all operations
+- **Automatic Versioning**: Built-in semantic versioning with automatic patch increment
+- **Multiple Build Options**: Standard and static linking builds
+- **Cross-Platform**: Works on Linux and other UNIX-like systems
 
-## Dependencies
+## Version Information
 
-- OpenSSL development libraries (`libssl-dev` on Ubuntu/Debian)
-- GCC compiler
+This project uses an automatic versioning system that:
+- Automatically increments the patch version on each build
+- Embeds build timestamp, git commit hash, and branch information
+- Creates git tags for version tracking
+- Generates version header files with detailed build metadata
 
-### Install dependencies on Ubuntu/Debian:
-```bash
-sudo apt update
-sudo apt install libssl-dev build-essential
-```
+Current version can be viewed with: `./otp --help` or by running the interactive mode.
 
 ## Building
 
+### Prerequisites
+
+- GCC compiler
+- Git (for version tracking)
+- Make
+
+**Note: OpenSSL is no longer required! This implementation is now completely self-contained.**
+
+### Build Commands
+
+Use the included build script for automatic versioning:
+
 ```bash
-make
+# Standard build (default)
+./build.sh build
+
+# Static linking build
+./build.sh static
+
+# Clean build artifacts
+./build.sh clean
+
+# Generate version files only
+./build.sh version
+
+# Install to system
+./build.sh install
+
+# Remove from system
+./build.sh uninstall
+
+# Show usage
+./build.sh help
 ```
 
-This will create the `otp` executable.
+### Traditional Make
 
-## Usage Modes
+You can also use make directly (without automatic versioning):
 
-### Interactive Mode (Recommended)
+```bash
+make            # Standard build
+make static     # Static linking
+make clean      # Clean artifacts
+make install    # Install to /usr/local/bin/
+make uninstall  # Remove from system
+```
 
-Simply run the program without arguments:
+## Usage
 
+### Interactive Mode
 ```bash
 ./otp
 ```
 
-This launches a menu-driven interface:
-```
-=== OTP Cipher Interactive Mode ===
-Version: OTP-CIPHER 2.0
-
-=== Main Menu ===
-1. Generate new pad
-2. Encrypt message
-3. Decrypt message
-4. List available pads
-5. Show pad information
-6. Exit
-```
-
 ### Command Line Mode
-
-For automation and scripting:
-
 ```bash
-./otp generate <size>              # Generate new pad
-./otp encrypt <pad_hash_prefix>    # Encrypt text
-./otp decrypt <pad_hash_prefix>    # Decrypt message
-./otp list                         # List available pads
-```
-
-## Smart Size Parsing
-
-The system intelligently parses size specifications:
-
-```bash
-./otp generate 1024        # 1024 bytes
-./otp generate 5MB         # 5 megabytes
-./otp generate 2GB         # 2 gigabytes  
-./otp generate 10TB        # 10 terabytes
-./otp generate 1.5GB       # 1.5 gigabytes (decimal supported)
-```
-
-**Supported units:** K, KB, M, MB, G, GB, T, TB (case insensitive)
-
-## Pad Selection
-
-Multiple convenient ways to select pads:
-
-1. **Full hash**: `./otp encrypt a1b2c3d4e5f6789012345678901234567890abcdef...`
-2. **Hash prefix**: `./otp encrypt a1b2c3d4`
-3. **Pad number**: `./otp encrypt 1` (from list output)
-
-## Example Workflows
-
-### Basic Usage
-```bash
-# Generate a 1GB pad
+# Generate a new pad
 ./otp generate 1GB
-Generated pad: a1b2c3d4e5f6789...123456.pad (1.00 GB)
-Pad hash: a1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456
+
+# Encrypt text (interactive input)
+./otp encrypt <pad_hash_or_prefix>
+
+# Decrypt message (interactive input)  
+./otp decrypt <pad_hash_or_prefix>
 
 # List available pads
 ./otp list
-Available pads:
-No.  Hash (first 16 chars) Size         Used
----  -------------------  ----------   ----------
-1    a1b2c3d4e5f67890     1.00GB       0.0MB
-
-# Encrypt using hash prefix
-./otp encrypt a1b2
-Enter text to encrypt: Secret message
------BEGIN OTP MESSAGE-----
-Version: OTP-CIPHER 2.0
-Pad-Hash: a1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456
-Pad-Offset: 0
-
-U2VjcmV0IG1lc3NhZ2U=
------END OTP MESSAGE-----
 ```
 
-### Large Scale Usage
+## Version System Details
+
+### Automatic Version Increment
+Every build automatically increments the patch version:
+- v0.1.0 → v0.1.1 → v0.1.2, etc.
+- Creates git tags for each version
+- Embeds detailed build information
+
+### Manual Version Control
+For major/minor releases, create tags manually:
 ```bash
-# Generate a 5TB pad for external drive
-./otp generate 5TB
-Progress: 100.0% (85.2 MB/s, ETA: 0s)
-Generated pad: f9e8d7c6b5a4932...654321.pad (5.00 TB)
+# Feature release (minor bump)
+git tag v0.2.0    # Next build: v0.2.1
 
-# Use pad number for quick selection
-./otp encrypt 1
-Enter text to encrypt: Classified information
+# Breaking change (major bump)  
+git tag v1.0.0    # Next build: v1.0.1
 ```
 
-### Interactive Mode Workflow
-```bash
-./otp
-# Select option 1 to generate
-# Enter size: 10GB
-# Select option 2 to encrypt
-# Choose pad from list
-# Enter your message
-```
+### 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 generates:
+- `src/version.h` - Version constants and macros
+- `src/version.c` - Version API functions  
+- `VERSION` - Plain text version number
+
+These files are excluded from git (.gitignore) and regenerated on each build.
 
 ## Security Features
 
-### Perfect Forward Secrecy
-Each message uses a unique portion of the pad that is never reused, ensuring perfect forward secrecy.
-
-### Content-Based Integrity
-- **SHA-256 file naming**: Pad files named by their hash ensure content verification
-- **Integrity checking**: Embedded hashes detect pad corruption/tampering
-- **Read-only protection**: Pad files automatically set to read-only after creation
-
-### ASCII Armor Format
-Messages use a PGP-like ASCII armor format:
-```
------BEGIN OTP MESSAGE-----
-Version: OTP-CIPHER 2.0
-Pad-Hash: a1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456
-Pad-Offset: 0
-
-U2VjcmV0IG1lc3NhZ2U=
------END OTP MESSAGE-----
-```
-
-### State Management
-- **Automatic tracking**: Prevents pad reuse through state files
-- **Portable state**: State stored separately from immutable pad data
-- **Usage statistics**: Track pad consumption and remaining capacity
+- Uses `/dev/urandom` for cryptographically secure random number generation
+- Optional keyboard entropy mixing using simple XOR operations
+- Custom 256-bit XOR checksum for pad identification (encrypted with pad data)
+- Read-only pad files to prevent accidental modification
+- State tracking to prevent pad reuse
+- **Zero external crypto dependencies** - completely self-contained implementation
 
 ## File Structure
 
-**Source Files:**
-- `otp.c` - Complete implementation (850+ lines)
-- `Makefile` - Build configuration
-- `README.md` - This documentation
-
-**Generated Files:**
-- `otp` - Compiled executable
-- `<hash>.pad` - Pad files (read-only, hash-named)
-- `<hash>.state` - State files (writable, tracks usage)
-
-## Advanced Features
-
-### Progress Indicators
-For large pads, see real-time generation progress:
 ```
-Generating pad...
-Progress: 45.2% (78.5 MB/s, ETA: 125s)
+otp/
+├── build.sh          # Build script with automatic versioning
+├── Makefile         # Traditional make build system  
+├── otp.c            # Main source code
+├── README.md        # This file
+├── .gitignore       # Git ignore rules
+├── src/             # Generated version files (auto-created)
+│   ├── version.h    # Version header (generated)
+│   └── version.c    # Version implementation (generated)
+├── pads/            # OTP pad storage directory (created at runtime)
+└── VERSION          # Plain text version (generated)
 ```
 
-### Pad Information
-Detailed statistics for each pad:
+## File Formats
+
+### .otp File Format (Binary)
+
+Binary encrypted files use a structured header format:
+
+```
+Offset | Size | Field               | Description
+-------|------|-------------------|----------------------------------
+0      | 4    | Magic             | "OTP\0" - File type identifier
+4      | 2    | Version           | Format version (currently 1)
+6      | 32   | Pad Checksum      | Binary pad checksum (32 bytes)
+38     | 8    | Pad Offset        | Offset in pad file (uint64_t)
+46     | 2    | Filename Length   | Original filename length (uint16_t)
+48     | var  | Original Filename | Original filename string
+var    | 4    | File Mode         | Original file permissions (uint32_t)
+var    | 8    | File Size         | Original file size (uint64_t)
+var    | var  | Encrypted Data    | XOR-encrypted file contents
+```
+
+### .otp.asc File Format (ASCII Armored)
+
+ASCII armored files use the same format as encrypted text messages:
+
+```
+-----BEGIN OTP MESSAGE-----
+Version: v0.2.15
+Pad-ChkSum: <64-character-hex-checksum>
+Pad-Offset: <decimal-offset-value>
+
+<base64-encoded-encrypted-data>
+-----END OTP MESSAGE-----
+```
+
+**Note:** ASCII armored files lose original filename and permission metadata.
+
+## Usage Examples
+
+### Short Command Flags
 ```bash
-./otp list
-No.  Hash (first 16 chars) Size         Used
----  -------------------  ----------   ----------
-1    a1b2c3d4e5f67890     5.00TB       2.1GB
-2    f9e8d7c6b5a49321     1.00GB       0.5GB
+# Quick commands using short flags
+./otp -g 1GB                    # Generate 1GB pad
+./otp -l                        # List available pads
+./otp -e 1a2b "Hello world"     # Encrypt text inline
+./otp -d "-----BEGIN OTP..."    # Decrypt message inline
+
+# File operations
+./otp -f document.pdf 1a2b                # Encrypt file (binary)
+./otp -f document.pdf 1a2b -a             # Encrypt file (ASCII)
+./otp -f document.pdf 1a2b -o secret.otp  # Custom output name
 ```
 
-### Multiple Pad Management
-- List all available pads
-- Show detailed information per pad
-- Track usage across multiple pads
-- Quick selection by number or prefix
-
-## Performance
-
-### Size Limits
-- **Theoretical maximum**: 18 exabytes (uint64_t limit)
-- **Practical maximum**: Limited by available disk space
-- **Tested up to**: 10TB+ on modern systems
-- **Generation speed**: ~80-120 MB/s (system dependent)
-
-### Memory Efficiency
-- **Streaming operation**: Constant memory usage regardless of pad size
-- **64KB buffers**: Efficient I/O without excessive memory consumption
-- **Large file support**: Handles multi-terabyte pads efficiently
-
-## Security Notes
-
-⚠️ **Critical Security Requirements:**
-
-1. **Never reuse pad data** - Automatic prevention through state tracking
-2. **Secure pad distribution** - Use secure channels for pad sharing
-3. **Physical security** - Protect pad files like encryption keys
-4. **Verify integrity** - Always check pad hash verification during decryption
-5. **Secure systems** - Generate pads on trusted systems with good entropy
-
-## Installation
-
-### Local Installation
+### Text Encryption
 ```bash
-make install          # Install to /usr/local/bin
-make uninstall        # Remove from system
+# Interactive text encryption
+./otp encrypt 1a2b3c
+Enter text to encrypt: This is my secret message
+# Outputs ASCII armored message
+
+# Inline text encryption
+./otp -e 1a2b3c "This is my secret message"
+# Outputs ASCII armored message immediately
 ```
 
-### Clean Up
+### File Encryption
 ```bash
-make clean           # Remove compiled files and generated pads
+# Binary format (preserves metadata)
+./otp -f sensitive.doc a1b2c3
+
+# ASCII armored format (text-safe)
+./otp -f sensitive.doc a1b2c3 -a
+
+# Custom output filename
+./otp -f sensitive.doc a1b2c3 -o encrypted_document.otp
 ```
 
-## Technical Specifications
+### Decryption
+```bash
+# Auto-detect format and pad from message/file
+./otp -d encrypted.otp.asc
+./otp -d "-----BEGIN OTP MESSAGE-----..."
 
-- **Entropy source**: `/dev/urandom` (cryptographically secure)
-- **Hash algorithm**: SHA-256 for integrity verification
-- **Encoding**: Base64 for ciphertext representation
-- **File format**: ASCII armor with embedded metadata
-- **Architecture**: Single C file, ~850 lines
-- **Dependencies**: OpenSSL libcrypto
-- **Platform**: Linux (easily portable)
+# Interactive mode
+./otp decrypt
+# Prompts for encrypted message input
+```
 
-## Theory
+### Build and Version Tracking
+```bash
+$ ./build.sh build
+[INFO] Incrementing version...
+[INFO] Current version: v0.2.14
+[INFO] New version: v0.2.15
+[SUCCESS] Created new version tag: v0.2.15
+[SUCCESS] Build completed successfully
 
-A One Time Pad is theoretically unbreakable when implemented correctly with:
-- **Perfect randomness**: Cryptographically secure entropy
-- **Key length**: Equal to or greater than message length  
-- **Single use**: Each pad portion used exactly once
-- **Secure distribution**: Pads shared through secure channels
+$ ./otp --help
+OTP Cipher - One Time Pad Implementation v0.2.15
+Built on 2025-08-10 at 14:07:58 from commit ae0afcf on branch master
+```
 
-This implementation satisfies all requirements for perfect cryptographic security while providing modern usability features for practical deployment.
+### Advanced Features
+```bash
+# Generate pad with keyboard entropy
+./otp generate 5GB
+# Follow prompts for keyboard entropy collection
 
-## Version History
+# Check pad usage
+./otp -l
+Available pads:
+No.  ChkSum (first 16 chars) Size         Used         % Used
+---  -------------------   ----------   ----------   ------
+1    97d9d82b5414a943      1.00GB       156B         0.0%
+2    0c8e19fde996e683      1000B        248B         24.8%
 
-- **v2.0**: Interactive mode, smart parsing, 10TB+ support, enhanced UX
-- **v1.0**: Basic command-line implementation with hash-based naming
+# Show detailed pad information
+./otp
+# Select "S" for show pad info, enter checksum or prefix
+```
+
+## License
+
+This project includes automatic versioning system based on the Generic Automatic Version Increment System.
+
+## Contributing
+
+When contributing:
+1. The version will automatically increment on builds
+2. For major features, consider manually creating minor version tags
+3. Generated version files (`src/version.*`, `VERSION`) should not be committed

build.sh

@@ -0,0 +1,293 @@
+#!/bin/bash
+set -e
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m'
+
+print_status() { echo -e "${BLUE}[INFO]${NC} $1"; }
+print_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; }
+print_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; }
+print_error() { echo -e "${RED}[ERROR]${NC} $1"; }
+
+# Global variable for commit message
+COMMIT_MESSAGE=""
+
+# Parse command line arguments for -m flag
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        -m|--message)
+            COMMIT_MESSAGE="$2"
+            shift 2
+            ;;
+        *)
+            # Keep other arguments for main logic
+            break
+            ;;
+    esac
+done
+
+# Function to automatically increment version
+increment_version() {
+    print_status "Incrementing version..."
+    
+    # Check if we're in a git repository
+    if ! git rev-parse --git-dir > /dev/null 2>&1; then
+        print_warning "Not in a git repository - skipping version increment"
+        return 0
+    fi
+    
+    # Get the highest version tag (not chronologically latest)
+    LATEST_TAG=$(git tag -l 'v*.*.*' | sort -V | tail -n 1 || echo "v0.1.0")
+    if [[ -z "$LATEST_TAG" ]]; then
+        LATEST_TAG="v0.1.0"
+    fi
+    
+    # Extract version components (remove 'v' prefix)
+    VERSION=${LATEST_TAG#v}
+    
+    # Parse major.minor.patch using regex
+    if [[ $VERSION =~ ^([0-9]+)\.([0-9]+)\.([0-9]+)$ ]]; then
+        MAJOR=${BASH_REMATCH[1]}
+        MINOR=${BASH_REMATCH[2]}
+        PATCH=${BASH_REMATCH[3]}
+    else
+        print_error "Invalid version format in tag: $LATEST_TAG"
+        print_error "Expected format: v0.1.0"
+        return 1
+    fi
+    
+    # Increment patch version
+    NEW_PATCH=$((PATCH + 1))
+    NEW_VERSION="v${MAJOR}.${MINOR}.${NEW_PATCH}"
+    
+    print_status "Current version: $LATEST_TAG"
+    print_status "New version: $NEW_VERSION"
+    
+    # Stage all changes
+    if git add . 2>/dev/null; then
+        print_success "Staged all changes"
+    else
+        print_warning "Failed to stage changes (maybe not a git repository)"
+    fi
+    
+    # Handle commit message - use global variable if set, otherwise prompt
+    if [[ -z "$COMMIT_MESSAGE" ]]; then
+        echo ""
+        print_status "Please enter a meaningful commit message for version $NEW_VERSION:"
+        echo -n "> "
+        read -r COMMIT_MESSAGE
+    fi
+    
+    # Check if user provided a message
+    if [[ -z "$COMMIT_MESSAGE" ]]; then
+        print_warning "No commit message provided. Using default message."
+        COMMIT_MESSAGE="Automatic version increment"
+    fi
+    
+    # Commit changes with user-provided message
+    if git commit -m "Version $NEW_VERSION - $COMMIT_MESSAGE" 2>/dev/null; then
+        print_success "Committed changes for version $NEW_VERSION"
+    else
+        print_warning "Failed to commit changes (maybe no changes to commit or not a git repository)"
+    fi
+    
+    # Create new git tag
+    if git tag "$NEW_VERSION" 2>/dev/null; then
+        print_success "Created new version tag: $NEW_VERSION"
+        
+        # Push changes and tags to remote repository
+        if git push ssh://ubuntu@laantungir.net:/home/ubuntu/git_repos/otp 2>/dev/null; then
+            print_success "Pushed changes to remote repository"
+        else
+            print_warning "Failed to push changes to remote repository"
+        fi
+        
+        if git push ssh://ubuntu@laantungir.net:/home/ubuntu/git_repos/otp --tags 2>/dev/null; then
+            print_success "Pushed tags to remote repository"
+        else
+            print_warning "Failed to push tags to remote repository"
+        fi
+    else
+        print_warning "Tag $NEW_VERSION already exists - using existing version"
+        NEW_VERSION=$LATEST_TAG
+        # Re-extract version components for existing tag
+        VERSION=${NEW_VERSION#v}
+        if [[ $VERSION =~ ^([0-9]+)\.([0-9]+)\.([0-9]+)$ ]]; then
+            MAJOR=${BASH_REMATCH[1]}
+            MINOR=${BASH_REMATCH[2]}
+            NEW_PATCH=${BASH_REMATCH[3]}
+        fi
+    fi
+    
+    # Update VERSION file for compatibility
+    echo "${NEW_VERSION#v}" > VERSION
+    print_success "Updated VERSION file to ${NEW_VERSION#v}"
+    
+    # Generate version.h header file
+    mkdir -p src
+    cat > src/version.h << EOF
+/*
+ * Auto-Generated Version Header
+ * DO NOT EDIT THIS FILE MANUALLY - Generated by build script
+ */
+
+#ifndef VERSION_H
+#define VERSION_H
+
+#define VERSION_MAJOR ${MAJOR}
+#define VERSION_MINOR ${MINOR}
+#define VERSION_PATCH ${NEW_PATCH}
+#define VERSION_STRING "${MAJOR}.${MINOR}.${NEW_PATCH}"
+#define VERSION_TAG "${NEW_VERSION}"
+
+/* Build information */
+#define BUILD_DATE "$(date +%Y-%m-%d)"
+#define BUILD_TIME "$(date +%H:%M:%S)"
+#define BUILD_TIMESTAMP "$(date '+%Y-%m-%d %H:%M:%S')"
+
+/* Git information */
+#define GIT_HASH "$(git rev-parse --short HEAD 2>/dev/null || echo 'unknown')"
+#define GIT_BRANCH "$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo 'unknown')"
+
+/* Display versions */
+#define VERSION_DISPLAY "${NEW_VERSION}"
+#define VERSION_FULL_DISPLAY "${NEW_VERSION} ($(date '+%Y-%m-%d %H:%M:%S'), $(git rev-parse --short HEAD 2>/dev/null || echo 'unknown'))"
+
+/* Version API functions */
+const char* get_version(void);
+const char* get_version_full(void);
+const char* get_build_info(void);
+
+#endif /* VERSION_H */
+EOF
+
+    # Generate version.c implementation file
+    cat > src/version.c << EOF
+/*
+ * Auto-Generated Version Implementation
+ * DO NOT EDIT THIS FILE MANUALLY - Generated by build script
+ */
+
+#include "version.h"
+
+const char* get_version(void) {
+    return VERSION_TAG;
+}
+
+const char* get_version_full(void) {
+    return VERSION_FULL_DISPLAY;
+}
+
+const char* get_build_info(void) {
+    return "Built on " BUILD_DATE " at " BUILD_TIME " from commit " GIT_HASH " on branch " GIT_BRANCH;
+}
+EOF
+
+    print_success "Generated version header files"
+}
+
+# Build functions
+build_project() {
+    print_status "Cleaning previous build..."
+    make clean
+    increment_version
+    print_status "Building OTP project..."
+    make
+    if [ $? -eq 0 ]; then
+        print_success "Build completed successfully"
+    else
+        print_error "Build failed"
+        return 1
+    fi
+}
+
+build_static() {
+    print_status "Cleaning previous build..."
+    make clean
+    increment_version
+    print_status "Building OTP project with static linking..."
+    make static
+    if [ $? -eq 0 ]; then
+        print_success "Static build completed successfully"
+    else
+        print_error "Static build failed"
+        return 1
+    fi
+}
+
+clean_project() {
+    print_status "Cleaning build artifacts..."
+    make clean
+    rm -f VERSION src/version.h src/version.c
+    print_success "Clean completed"
+}
+
+install_project() {
+    print_status "Installing OTP project..."
+    make install
+    if [ $? -eq 0 ]; then
+        print_success "Installation completed"
+    else
+        print_error "Installation failed"
+        return 1
+    fi
+}
+
+uninstall_project() {
+    print_status "Uninstalling OTP project..."
+    make uninstall
+    if [ $? -eq 0 ]; then
+        print_success "Uninstallation completed"
+    else
+        print_error "Uninstallation failed"
+        return 1
+    fi
+}
+
+# Main script logic
+case "${1:-build}" in
+    build)
+        build_project
+        ;;
+    static)
+        build_static
+        ;;
+    clean)
+        clean_project
+        ;;
+    install)
+        install_project
+        ;;
+    uninstall)
+        uninstall_project
+        ;;
+    version)
+        increment_version
+        print_status "Version information generated"
+        ;;
+    *)
+        echo "OTP Cipher Build Script"
+        echo "Usage: $0 [-m \"commit message\"] {build|static|clean|install|uninstall|version}"
+        echo ""
+        echo "Options:"
+        echo "  -m, --message \"text\"  - Specify commit message (skips interactive prompt)"
+        echo ""
+        echo "Commands:"
+        echo "  build     - Build project with automatic version increment (default)"
+        echo "  static    - Build with static linking"
+        echo "  clean     - Clean build artifacts and generated files"
+        echo "  install   - Install to system (requires build first)"
+        echo "  uninstall - Remove from system"
+        echo "  version   - Generate version files only"
+        echo ""
+        echo "Examples:"
+        echo "  $0 build"
+        echo "  $0 -m \"Fixed checksum parsing bug\" build"
+        echo "  $0 --message \"Added new feature\" static"
+        exit 1
+        ;;
+esac

debug.c

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

test.txt

@@ -0,0 +1 @@
+This is a test file for OTP encryption.

test_ascii

@@ -0,0 +1 @@
+This is a test file for OTP encryption.

test_ascii.otp.asc

@@ -0,0 +1,7 @@
+-----BEGIN OTP MESSAGE-----
+Version: v0.2.15
+Pad-ChkSum: 0c8e19fde996e683fdbd348d1052eec168ffe6f67a88bb1278d0d02e9341b87b
+Pad-Offset: 210
+
+mMIm7iVtUO6NbXbskMxtydI/A16UXEQUGTcIya/8Dja6PB3EC0MLdw==
+-----END OTP MESSAGE-----