laantungir/otp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 30 Wiki Activity

build.sh created

Browse Source
This commit is contained in:
Laan Tungir
2025-08-10 08:21:41 -04:00
parent 9edfa5f379
commit 4b822962bb
6 changed files with 410 additions and 245 deletions
Download Patch File Download Diff File Expand all files Collapse all files

396
README.md
View File

@@ -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 <pad_hash_or_prefix>
# Decrypt message (interactive input)
./otp decrypt <pad_hash_or_prefix>
# 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 <size> # Generate new pad
./otp encrypt <pad_hash_prefix> # Encrypt text
./otp decrypt <pad_hash_prefix> # 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
- `<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)
```
### 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