Version v0.3.30 - Update readme.md

Makefile

@@ -11,11 +11,13 @@ OBJS = $(SOURCES:.c=.o)
 $(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 $@

README.md

@@ -1,5 +1,54 @@
 # OTP Cipher - One Time Pad Implementation
 
+## Quick Start
+
+### Download Pre-Built Binaries
+
+**Latest Release:** [View all releases on Gitea](https://git.laantungir.net/laantungir/otp/releases)
+
+**For x86_64 Linux:**
+```bash
+# Download latest x86_64 binary (replace VERSION with latest from releases page)
+wget https://git.laantungir.net/laantungir/otp/releases/latest/download/otp-latest-linux-x86_64
+chmod +x otp-latest-linux-x86_64
+./otp-latest-linux-x86_64
+```
+
+**For ARM64/AArch64 (Raspberry Pi, etc.):**
+```bash
+# Download latest ARM64 binary
+wget https://git.laantungir.net/laantungir/otp/releases/latest/download/otp-latest-linux-arm64
+chmod +x otp-latest-linux-arm64
+./otp-latest-linux-arm64
+```
+
+> **Note:** If the `/latest/download/` URLs don't work with your Gitea version, visit the [releases page](https://git.laantungir.net/laantungir/otp/releases) and download the latest version manually.
+
+**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 +113,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.sh build
+# Build for current architecture (with auto-versioning)
+./build.sh "commit message"
 
-# 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
+# Build commands
+./build.sh build "commit message"  # Build x86_64 and ARM64 (if cross-compiler available)
+./build.sh clean                   # Clean build artifacts
+./build.sh install                 # Install to system
+./build.sh uninstall               # Remove from system
 ```
 
+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>
+# Decrypt message (interactive input)
+./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:
-- v0.1.0 → v0.1.1 → v0.1.2, etc.
-- Creates git tags for each version
-- Embeds detailed build information
+The `build.sh` script automatically:
+1. Increments patch version (v0.3.24 → v0.3.25)
+2. Updates `OTP_VERSION` in `src/main.h`
+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)  
+# 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 +214,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
+├── build.sh              # Build script with automatic versioning
+├── Makefile             # Traditional make build system
+├── README.md            # This file
+├── .gitignore           # Git ignore rules
 ├── src/
-│   ├── main.c       # Main application entry point and command line handling
-│   ├── ui.c         # Interactive user interface and menu system
-│   ├── state.c      # Global state management (pads directory, terminal dimensions)
-│   ├── crypto.c     # Core cryptographic operations (XOR, ChaCha20)
-│   ├── pads.c       # Pad management and file operations
-│   ├── entropy.c    # Entropy collection from various sources
-│   ├── trng.c       # Hardware RNG device detection and entropy collection
-│   └── util.c       # Utility functions and helpers
-├── pads/            # OTP pad storage directory (created at runtime)
-└── VERSION          # Plain text version (generated)
+│   ├── 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, preferences)
+│   ├── 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 collection
+│   ├── 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)
+├── files/               # Encrypted file storage (created at runtime)
+└── tests/               # Test scripts and utilities
 ```
 
 ## Architecture
@@ -197,13 +249,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 +458,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
-2. For major features, consider manually creating minor version tags
-3. Generated version files (`src/version.*`, `VERSION`) should not be committed
+1. The version will automatically increment on builds via `build.sh`
+2. Version is centralized in `src/main.h` as `OTP_VERSION`
+3. For major features, manually create minor/major version tags
+4. Build artifacts in `build/` and object files are auto-cleaned

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 src/otp.c with the current git tag
-    if [ -f "src/otp.c" ]; then
-        # Update main menu version
-        sed -i "s/OTP v[0-9]\+\.[0-9]\+\.[0-9]\+/OTP $NEW_VERSION/g" src/otp.c
-        # Update ASCII output version
-        sed -i "s/Version: v[0-9]\+\.[0-9]\+\.[0-9]\+/Version: $NEW_VERSION/g" src/otp.c
-        # Update usage/help text version
-        sed -i "s/Implementation v[0-9]\+\.[0-9]\+\.[0-9]\+/Implementation $NEW_VERSION/g" src/otp.c
-        
-        print_success "Updated version strings in src/otp.c to $NEW_VERSION"
+    # Update OTP_VERSION constant in src/main.h
+    if [ -f "src/main.h" ]; then
+        sed -i "s/#define OTP_VERSION \"v[0-9]\+\.[0-9]\+\.[0-9]\+\"/#define OTP_VERSION \"$NEW_VERSION\"/g" src/main.h
+        print_success "Updated OTP_VERSION in src/main.h to $NEW_VERSION"
     else
-        print_warning "src/otp.c not found - skipping version string updates"
+        print_warning "src/main.h not found - skipping version update"
     fi
 }
 

src/crypto.c

@@ -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/main.c

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

@@ -3,7 +3,7 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 //      OTP CIPHER - MAIN HEADER FILE
-//      One Time Pad Implementation v0.2.109
+//      One Time Pad Implementation
 //
 //      This header file contains all function prototypes and type definitions
 //      for the OTP Cipher project
@@ -22,6 +22,9 @@
 #include <string.h>
 #include <ctype.h>
 
+// Version - Updated automatically by build.sh
+#define OTP_VERSION "v0.3.29"
+
 // Constants
 #define MAX_INPUT_SIZE 4096
 #define MAX_LINE_LENGTH 1024

src/ui.c

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