From 4b822962bb486fc94661b3e488f0756cd8512453 Mon Sep 17 00:00:00 2001 From: Laan Tungir Date: Sun, 10 Aug 2025 08:21:41 -0400 Subject: [PATCH] build.sh created --- .gitignore | 5 + Makefile | 12 +- README.md | 396 ++++++++++++++++++++++------------------------------- build.sh | 227 ++++++++++++++++++++++++++++++ otp | Bin 44832 -> 44976 bytes otp.c | 15 +- 6 files changed, 410 insertions(+), 245 deletions(-) create mode 100755 build.sh diff --git a/.gitignore b/.gitignore index d0b9488..6f01cd6 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,7 @@ pads/ Gemini.md + +# Auto-generated version files +src/version.h +src/version.c +VERSION diff --git a/Makefile b/Makefile index 62ad320..464b285 100644 --- a/Makefile +++ b/Makefile @@ -1,14 +1,22 @@ CC = gcc CFLAGS = -Wall -Wextra -std=c99 LIBS = -lssl -lcrypto +LIBS_STATIC = -static -lssl -lcrypto -ldl -lpthread 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 diff --git a/README.md b/README.md index 817f1cb..7e64982 100644 --- a/README.md +++ b/README.md @@ -1,59 +1,164 @@ -# 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 +- **Keyboard Entropy**: Optional keyboard entropy collection for enhanced randomness +- **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 +- OpenSSL development libraries (`libssl-dev` on Ubuntu/Debian) +- Git (for version tracking) +- Make + +### 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: +### Command Line Mode +```bash +# Generate a new pad +./otp generate 1GB + +# Encrypt text (interactive input) +./otp encrypt + +# Decrypt message (interactive input) +./otp decrypt + +# List available pads +./otp list ``` -=== OTP Cipher Interactive Mode === -Version: OTP-CIPHER 2.0 + +## 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 +# Feature release (minor bump) +git tag v0.2.0 # Next build: v0.2.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 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 + +- Uses `/dev/urandom` for cryptographically secure random number generation +- Optional keyboard entropy mixing using HKDF (Hash-based Key Derivation Function) +- SHA-256 pad integrity verification +- Read-only pad files to prevent accidental modification +- State tracking to prevent pad reuse + +## File Structure + +``` +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) +``` + +## Examples + +### Build and Version Tracking +```bash +$ ./build.sh build +[INFO] Incrementing version... +[INFO] Current version: v0.1.4 +[INFO] New version: v0.1.5 +[SUCCESS] Created new version tag: v0.1.5 +[SUCCESS] Build completed successfully + +$ ./otp +=== OTP Cipher v0.1.5 === === Main Menu === 1. Generate new pad @@ -62,212 +167,33 @@ Version: OTP-CIPHER 2.0 4. List available pads 5. Show pad information 6. Exit + +$ ./otp --help +OTP Cipher - One Time Pad Implementation v0.1.5 +Built on 2025-08-10 at 08:17:47 from commit 9edfa5f on branch master +Usage: + ./otp - Interactive mode + ... ``` -### Command Line Mode - -For automation and scripting: - +### Version History ```bash -./otp generate # Generate new pad -./otp encrypt # Encrypt text -./otp decrypt # Decrypt message -./otp list # List available pads +$ git tag --list +v0.1.0 +v0.1.1 +v0.1.2 +v0.1.3 +v0.1.4 +v0.1.5 ``` -## Smart Size Parsing +## License -The system intelligently parses size specifications: +This project includes automatic versioning system based on the Generic Automatic Version Increment System. -```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) -``` +## Contributing -**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 -./otp generate 1GB -Generated pad: a1b2c3d4e5f6789...123456.pad (1.00 GB) -Pad hash: a1b2c3d4e5f6789012345678901234567890abcdef1234567890abcdef123456 - -# 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 -```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) - -# Use pad number for quick selection -./otp encrypt 1 -Enter text to encrypt: Classified information -``` - -### 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 -``` - -## 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 - -## File Structure - -**Source Files:** -- `otp.c` - Complete implementation (850+ lines) -- `Makefile` - Build configuration -- `README.md` - This documentation - -**Generated Files:** -- `otp` - Compiled executable -- `.pad` - Pad files (read-only, hash-named) -- `.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) -``` - -### Pad Information -Detailed statistics for each pad: -```bash -./otp list -No. Hash (first 16 chars) Size Used ---- ------------------- ---------- ---------- -1 a1b2c3d4e5f67890 5.00TB 2.1GB -2 f9e8d7c6b5a49321 1.00GB 0.5GB -``` - -### 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 -```bash -make install # Install to /usr/local/bin -make uninstall # Remove from system -``` - -### Clean Up -```bash -make clean # Remove compiled files and generated pads -``` - -## Technical Specifications - -- **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) - -## Theory - -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 - -This implementation satisfies all requirements for perfect cryptographic security while providing modern usability features for practical deployment. - -## Version History - -- **v2.0**: Interactive mode, smart parsing, 10TB+ support, enhanced UX -- **v1.0**: Basic command-line implementation with hash-based naming +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 diff --git a/build.sh b/build.sh new file mode 100755 index 0000000..e2c5b4d --- /dev/null +++ b/build.sh @@ -0,0 +1,227 @@ +#!/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"; } + +# 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" + + # Create new git tag + if git tag "$NEW_VERSION" 2>/dev/null; then + print_success "Created new version tag: $NEW_VERSION" + 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 {build|static|clean|install|uninstall|version}" + 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" + exit 1 + ;; +esac diff --git a/otp b/otp index c1a42a62cba0b461b5f3d1f0d8dc304b6571455d..fda1b7f516e99c8e785b48f663f88e7c657d1549 100755 GIT binary patch delta 12752 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 delta 12648 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 DUl@S% diff --git a/otp.c b/otp.c index b19c645..7d9fb70 100644 --- a/otp.c +++ b/otp.c @@ -1,4 +1,5 @@ #define _POSIX_C_SOURCE 200809L +#define _DEFAULT_SOURCE #include #include @@ -17,11 +18,11 @@ #include #include #include +#include "src/version.h" #define MAX_INPUT_SIZE 4096 #define MAX_LINE_LENGTH 1024 #define MAX_HASH_LENGTH 65 -#define VERSION_STRING "OTP-CIPHER 2.0" #define PROGRESS_UPDATE_INTERVAL (64 * 1024 * 1024) // 64MB intervals #define PADS_DIR "pads" #define MAX_ENTROPY_BUFFER 32768 // 32KB entropy buffer @@ -81,8 +82,7 @@ int main(int argc, char* argv[]) { } int interactive_mode(void) { - printf("=== OTP Cipher Interactive Mode ===\n"); - printf("Version: %s\n\n", VERSION_STRING); + printf("=== OTP Cipher %s ===\n\n", get_version()); while (1) { show_main_menu(); @@ -364,7 +364,7 @@ int list_available_pads(void) { hash[64] = '\0'; // Get pad file size - char full_path[MAX_HASH_LENGTH + 20]; + char full_path[300]; // Increased buffer size to accommodate longer paths snprintf(full_path, sizeof(full_path), "%s/%s", PADS_DIR, entry->d_name); struct stat st; if (stat(full_path, &st) == 0) { @@ -639,7 +639,6 @@ int generate_pad_with_entropy(uint64_t size_bytes, int display_progress, int use unsigned char urandom_buffer[64 * 1024]; // 64KB buffer unsigned char output_buffer[64 * 1024]; uint64_t bytes_written = 0; - time_t start_time = time(NULL); if (display_progress) { printf("Generating pad...\n"); @@ -803,7 +802,6 @@ int encrypt_text(const char* pad_identifier) { return 1; } - char pad_filename[MAX_HASH_LENGTH + 10]; char input_text[MAX_INPUT_SIZE]; char hash_hex[MAX_HASH_LENGTH]; uint64_t current_offset; @@ -913,7 +911,7 @@ int encrypt_text(const char* pad_identifier) { // Output in ASCII armor format printf("\n-----BEGIN OTP MESSAGE-----\n"); - printf("Version: %s\n", VERSION_STRING); + printf("Version: %s\n", get_version()); printf("Pad-Hash: %s\n", hash_hex); printf("Pad-Offset: %lu\n", current_offset); printf("\n"); @@ -1334,7 +1332,8 @@ unsigned char* base64_decode(const char* input, int* output_length) { } void print_usage(const char* program_name) { - printf("OTP Cipher - One Time Pad Implementation v2.0\n"); + printf("OTP Cipher - One Time Pad Implementation %s\n", get_version()); + printf("%s\n", get_build_info()); printf("Usage:\n"); printf(" %s - Interactive mode\n", program_name); printf(" %s generate - Generate new pad\n", program_name);