🔐 EncryptX

A modern, secure file encryption tool with both web interface and command-line access.

EncryptX provides military-grade AES-256-GCM encryption for any file type, featuring automatic compression, dual encryption modes, and a beautiful cyberpunk-themed interface.

✨ Features

🔑 Dual Encryption Methods: Use a password or 256-bit encryption key.
🔐 End-to-End Security: AES-256-GCM ensures confidentiality and integrity.
🧠 Argon2id Password Hashing: Secure key derivation for passwords.
🛡️ Tamper Detection: Authenticated encryption blocks modification.
📂 Any File Type: Works for docs, media, videos, archives — anything.
📦 Automatic Compression: Files are compressed with zstd before encryption for efficient storage and transfer.
🧱 Large File Support: Optimized for files up to 1GB.
🖥️ Modern UI: Built with Next.js + Tailwind, featuring drag & drop and smooth feedback.
🧼 Memory-Safe Backend: Rust ensures sensitive data is securely handled.
🛡️ Security Hardened: Rate limiting, input validation, and security headers.
🔒 No Key Storage: Keys are never stored server-side for maximum security.

📸 Screenshots

🏠 Home Page

Modern interface with drag & drop file upload

🔐 Encryption Process

Secure file encryption with password or key-based options

Successful encryption with download ready

🔓 Decryption Process

Easy file decryption with original filename preservation

Successful decryption with original file restored

🚀 Getting Started

Prerequisites

Node.js 18+ and npm (for frontend)
Rust 1.70+ and Cargo (for backend)
Docker (optional, for containerized deployment)

Quick Start

🐳 Docker Setup (Recommended for Quick Testing)

# Clone and start with Docker (fastest way)
git clone https://github.com/Amitminer/EncryptX.git
cd EncryptX
docker compose up --build

🚀 Development Setup (Recommended for Development)

# Clone the repository
git clone https://github.com/Amitminer/EncryptX.git
cd EncryptX

# Install root dependencies
npm install

# Install frontend dependencies
cd encryptx-frontend && npm install && cd ..

# Start both backend and frontend simultaneously
npm run dev

📱 Manual Setup (Alternative)

Clone the repository

git clone https://github.com/Amitminer/EncryptX.git
cd EncryptX

Start the backend
```
cd encryptx-backend
cargo run
```

Start the frontend (in a new terminal)

cd encryptx-frontend
npm install
npm run dev

Open your browser
```
http://localhost:3000
```

Available Scripts

🐳 Docker Commands (Simplest)

# Quick start with Docker
git clone https://github.com/Amitminer/EncryptX.git
cd EncryptX
docker compose up --build

📦 NPM Scripts (Development)

The root package.json provides convenient scripts to manage both services:

# Development (runs both services with hot reload)
npm run dev

# Production build (builds both services)
npm run build

# Production start (runs both built services)
npm start

# Run tests (tests both services)
npm run test

# Individual service commands
npm run dev:backend      # Backend only
npm run dev:frontend     # Frontend only
npm run build:backend    # Build backend only
npm run build:frontend   # Build frontend only
npm run start:backend    # Start backend only
npm run start:frontend   # Start frontend only
npm run test:backend     # Test backend only
npm run test:frontend    # Test frontend only

Docker Deployment

🐳 Quick Start with Docker

# Development (default settings)
docker-compose up --build

# Production with custom environment
RUST_LOG=warn \
ALLOWED_ORIGIN=https://yourdomain.com \
NEXT_PUBLIC_BACKEND_URL=https://api.yourdomain.com \
NODE_ENV=production \
docker-compose up --build -d

# Common commands
docker-compose up -d --build    # Run in background
docker-compose logs -f          # View logs
docker-compose down             # Stop services

🔧 Individual Container Builds

# Build backend (Alpine-based, ~50MB)
docker build -t encryptx-backend ./encryptx-backend

# Build frontend (Alpine-based with pnpm, ~150MB)
docker build -t encryptx-frontend ./encryptx-frontend

# Run individually
docker run -p 8080:8080 encryptx-backend
docker run -p 3000:3000 encryptx-frontend

🏗️ Architecture

System Overview

[User/Browser] → [Next.js Frontend] → [Rust Backend API] → [Crypto Engine]
                        ↓                    ↓
[CLI User] ────────────────────────→ [Rust CLI] → [Crypto Engine]
                                           ↓
                                    [Encrypted .xd Files]

Key Components

Crypto Engine - Core AES-256-GCM encryption with Argon2id key derivation
Web API Server - Actix Web REST endpoints for file upload/download
CLI Interface - Command-line tool for direct file encryption/decryption
Frontend UI - Next.js application with drag-and-drop file handling

📖 Usage

Web Interface

Encryption:
- Drag & drop files or click to browse
- Enter a password (optional) or let the system generate a secure key
- Click "Encrypt & Download" to get your .xd file
Decryption:
- Upload your .xd file
- Enter the password or key used for encryption
- Download your original file

Command Line Interface

📦 Pre-built Binaries (Coming Soon)

Pre-built binaries will be available in future releases. For now, please build from source.

🛠️ Build from Source

# Navigate to backend directory
cd encryptx-backend

# Encrypt with password
cargo run encrypt --file secret.txt --password mysecretpassword

# Encrypt with auto-generated key (key will be printed - save it!)
cargo run encrypt --file document.pdf

# Encrypt with custom key
cargo run encrypt --file data.zip --key YOUR_BASE64_KEY

# Specify output file and force overwrite
cargo run encrypt --file input.txt --password secret --output encrypted.xd --force

# Decrypt with password
cargo run decrypt --file secret.xd --password mysecretpassword

# Decrypt with key
cargo run decrypt --file document.xd --key YOUR_BASE64_KEY

# Specify output file and force overwrite
cargo run decrypt --file encrypted.xd --password secret --output decrypted.txt --force

🔧 API Reference

Endpoints

Method	Endpoint	Description
`POST`	`/encrypt`	Encrypt a file
`POST`	`/decrypt`	Decrypt a file
`GET`	`/health`	Health check

Headers

Header	Description	Required
`x-password`	Password for encryption/decryption	Optional*
`x-enc-key`	Base64 encryption key	Optional*
`x-orig-filename`	Original filename	Recommended

*Either x-password or x-enc-key must be provided for decryption

🛠️ Development

Project Structure

EncryptX/
├── encryptx-backend/           # Rust backend (API + CLI)
│   ├── src/
│   │   ├── crypto/            # Core encryption/decryption logic
│   │   ├── cli/               # Command-line interface module
│   │   ├── service/           # Business logic layer
│   │   ├── validation/        # Input validation and security
│   │   ├── middleware/        # Security headers and CORS
│   │   ├── constants/         # Configuration constants
│   │   ├── main.rs            # Web server entry point
│   │   └── lib.rs             # Public API for library usage
│   ├── tests/                 # Integration tests
│   ├── Cargo.toml             # Rust dependencies and metadata
│   ├── Dockerfile             # Backend containerization
│   └── README.md              # Backend-specific documentation
├── encryptx-frontend/          # Next.js frontend
│   ├── src/app/               # Next.js 13+ app directory structure
│   │   ├── components/        # React components
│   │   ├── utils/             # Utility functions
│   │   └── types/             # TypeScript type definitions
│   ├── package.json           # Node.js dependencies
│   ├── Dockerfile             # Frontend containerization
│   └── README.md              # Frontend-specific documentation
├── docker-compose.yml         # Multi-service deployment configuration
├── .github/workflows/         # CI/CD automation
├── SECURITY.md                # Security policy and guidelines
└── README.md                  # This file

Environment Variables

Backend (.env)

ALLOWED_ORIGIN=http://localhost:3000
RUST_LOG=info

Frontend (.env)

NEXT_PUBLIC_BACKEND_URL=http://localhost:8080

Running Tests

# Run all tests (both backend and frontend)
npm run test

# Or run individually:
npm run test:backend     # Rust tests with cargo
npm run test:frontend    # Frontend tests with npm

# Manual testing:
cd encryptx-backend
cargo test
cargo clippy --all-targets --all-features -- -D warnings

cd encryptx-frontend
npm test

🔒 Security

Security is our top priority. EncryptX implements:

AES-256-GCM authenticated encryption
Argon2id password-based key derivation (64MB memory, GPU-resistant)
Rate limiting (10 requests/minute per IP)
Input validation and sanitization
Security headers (CSP, HSTS, X-Frame-Options, etc.)
Memory-safe key handling with automatic cleanup

⚠️ Important: Keys are never stored server-side. If you lose your password or key, your data cannot be recovered.

For detailed security information, see SECURITY.md.

🚀 Deployment

Production Environment

Environment Setup

# Backend
export ALLOWED_ORIGIN=https://yourdomain.com
export RUST_LOG=warn

# Frontend
export NEXT_PUBLIC_BACKEND_URL=https://api.yourdomain.com

Build for Production

# Backend
cd encryptx-backend
cargo build --release

# Frontend
cd encryptx-frontend
npm run build

Deploy with Docker

docker-compose -f docker-compose.prod.yml up -d

Hosting Platforms

Component	Recommended Platforms
Backend	Railway, Fly.io, DigitalOcean
Frontend	Vercel, Netlify, Cloudflare Pages
Database	Not required (stateless)

🧪 Technology Stack

Backend

Technology	Purpose
Rust	Memory-safe systems programming
Actix Web	High-performance async web framework
AES-GCM	Authenticated encryption
Argon2id	Password-based key derivation
zstd	Fast compression algorithm

Frontend

Technology	Purpose
Next.js 15	React framework with SSR
TypeScript	Type-safe JavaScript
Tailwind CSS	Utility-first CSS framework
React Dropzone	File upload interface

DevOps

Technology	Purpose
Docker	Containerization
GitHub Actions	CI/CD pipeline
BetterUptime	Monitoring

🤝 Contributing

We welcome contributions! Please see our Contributing Guidelines for details.

Development Workflow

Fork the repository
Create a feature branch (git checkout -b feature/amazing-feature)
Make your changes
Run tests (cargo test and npm test)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Code Style

Rust: Follow rustfmt and clippy recommendations
TypeScript: Follow Prettier and ESLint configurations
Commits: Use conventional commit messages

📊 Performance

Encryption Speed: ~100MB/s on modern hardware
Compression Ratio: 20-60% size reduction (varies by file type)
Memory Usage: <64MB per encryption operation
File Size Limit: 1GB maximum
Concurrent Users: Scales with available system resources

🐛 Troubleshooting

Common Issues

Backend won't start

# Check Rust installation
rustc --version
cargo --version

# Update dependencies
cargo update

Frontend build fails

# Clear cache and reinstall
rm -rf node_modules package-lock.json
npm install

CORS errors

# Check environment variables
echo $ALLOWED_ORIGIN
echo $NEXT_PUBLIC_BACKEND_URL

Getting Help

📖 Check our Documentation
🐛 Report bugs in Issues
💬 Join discussions in Discussions
🔒 Security issues: See SECURITY.md

📄 License

🙏 Acknowledgments

Rust Community for excellent cryptographic libraries
Next.js Team for the amazing React framework

Made with ❤️ by AmitxD

⭐ Star this repo • 🐛 Report Bug • ✨ Request Feature

Name		Name	Last commit message	Last commit date
Latest commit History 36 Commits
.github/workflows		.github/workflows
assets		assets
encryptx-backend		encryptx-backend
encryptx-frontend		encryptx-frontend
.dockerignore		.dockerignore
.gitignore		.gitignore
LICENSE		LICENSE
README.md		README.md
SECURITY.md		SECURITY.md
docker-compose.yml		docker-compose.yml
package.json		package.json

License

Amitminer/EncryptX

Folders and files

Latest commit

History

Repository files navigation