A secure, peer-to-peer file sharing application with end-to-end encryption. Share files directly between devices with military-grade encryption, built with WebSockets, React, and Electron.
- AES-256-CBC Encryption - Military-grade file encryption
- RSA-2048 Key Exchange - Secure public key cryptography
- End-to-End Encrypted - Files never exposed to hub server
- Automatic Key Rotation - Keys rotated on access revocation
- SHA-256 Verification - File integrity checking
- P2P File Transfer - Direct transfers between peers
- Resume/Pause Downloads - Never lose progress
- Chunked Transfer - Efficient large file handling
- Real-time Progress - Live download/upload tracking
- Public Chat - Group messaging
- Private Messaging - Encrypted 1-on-1 chat
- Typing Indicators - See when others are typing
- User Presence - Real-time online status
- Cross-Platform - Windows, macOS, Linux
- Modern UI - Beautiful React + TailwindCSS interface
- Drag & Drop - Easy folder selection
- Activity Logs - Track all file operations
- Audit Trail - Complete operation history
 |
 |
| 🔐 Secure Login | 📁 File Management |
 |
 |
| ⬇️ Download Manager | 💬 Real-time Chat |
┌─────────────────┐ ┌─────────────────┐
│ │ WebSocket (Control) │ │
│ Client A │◄──────────────────────────────────►│ Hub Server │
│ (Electron) │ │ (Node.js) │
│ │ │ │
└────────┬────────┘ └────────▲────────┘
│ │
│ │
│ P2P WebSocket │
│ (File Transfer Direct) │
│ │
▼ │
┌─────────────────┐ WebSocket (Control) ┌──────┴──────────┐
│ │◄──────────────────────────────────►│ │
│ Client B │ │ │
│ (Electron) │ │ │
│ │ │ │
└─────────────────┘ └─────────────────┘
- Hub Server: Central coordinator for user discovery, key exchange, and messaging
- Client App: Electron desktop application with React UI
- P2P Connection: Direct WebSocket connection for encrypted file transfers
- SQLite Database: Stores file metadata, user keys, and audit logs
- Registration: Client generates RSA key pair, sends public key to hub
- File Sharing: Owner encrypts file with AES, encrypts AES key with recipient's RSA public key
- Discovery: Hub provides download tokens and peer addresses
- Transfer: Direct P2P WebSocket transfer of encrypted file chunks
- Decryption: Recipient decrypts file using their RSA private key
┌──────────────────────────────────────────┐
│ File Content (Your Data) │
├──────────────────────────────────────────┤
│ AES-256-CBC Encryption │ ← Symmetric encryption
├──────────────────────────────────────────┤
│ RSA-2048 Key Wrapping │ ← Asymmetric encryption
├──────────────────────────────────────────┤
│ WebSocket TLS Transport │ ← Transport security
└──────────────────────────────────────────┘
✅ File Contents - AES-256-CBC with random IV
✅ Encryption Keys - RSA-2048 public key encryption
✅ Private Messages - End-to-end encrypted
✅ File Chunks - Verified with SHA-256 hashes
- Usernames (nicknames)
- File metadata (names, sizes, hashes)
- Who's sharing with whom
- Connection status
❌ File contents (encrypted)
❌ Private keys (never leave device)
❌ Decrypted messages
❌ Your local folder structure
- Node.js 18+
- npm (comes with Node.js)
- Git
# Clone repository
git clone https://github.com/ItsAbir005/DC-.git
cd dc-clone
# Install hub dependencies
cd hub
npm install
# Install client dependencies
cd ../client
npm installTerminal 1 - Hub Server:
cd hub
npm start
# Hub runs on http://localhost:8080Terminal 2 - Client App:
cd client
npm run electron:dev
# Opens Electron app with hot reloadcd client
# Build for current platform
npm run package
# Build for specific platforms
npm run package:win # Windows (.exe)
npm run package:mac # macOS (.dmg)
npm run package:linux # Linux (.AppImage, .deb)Output in client/dist/
dc-clone/
├── hub/ # Hub server
│ ├── hub.js # Main WebSocket server
│ ├── db.js # SQLite database
│ └── middleware/ # Server middleware
├── client/ # Client application
│ ├── electron/ # Electron main process
│ ├── src/ # React UI components
│ ├── controllers/ # Business logic
│ ├── middleware/ # Client middleware
│ ├── utils/ # Crypto utilities
│ └── uploaderServer.js # P2P upload server
├── docs/ # Documentation
└── README.md
- Runtime: Node.js 18+
- WebSocket: ws (WebSocket library)
- Database: SQLite (better-sqlite3)
- Auth: JWT (jsonwebtoken)
- Crypto: Node.js built-in crypto
- Framework: Electron 28
- UI: React 18 + Vite
- Styling: TailwindCSS 3
- State: React Hooks
- Crypto: Node.js crypto API
We love contributions! Here's how you can help:
- 🍴 Fork the repository
- 🔧 Create a feature branch (
git checkout -b feature/amazing-feature) - 💻 Commit your changes (
git commit -m 'Add amazing feature') - 📤 Push to branch (
git push origin feature/amazing-feature) - 🎉 Open a Pull Request
Look for issues tagged with good-first-issue - perfect for newcomers!
- Web-based client (browser version)
- File compression before encryption
- Bandwidth throttling controls
- Multi-language support
- Group file sharing
- File synchronization
- Mobile apps (React Native)
- Voice/video chat
- Blockchain-based file verification
- Distributed hub network
- IPFS integration
- Zero-knowledge proofs
- File sharing limited to 5GB per file (by design)
- P2P transfer requires both users online simultaneously
- Port 4000 must be available for uploads
- Large files may use significant memory
| File Size | Transfer Speed* | Memory Usage |
|---|---|---|
| 10 MB | ~8-12 MB/s | ~50 MB |
| 100 MB | ~15-25 MB/s | ~100 MB |
| 1 GB | ~20-30 MB/s | ~200 MB |
| 5 GB | ~25-35 MB/s | ~400 MB |
*Speeds vary based on network conditions and hardware
Is this really secure?
Yes! Files are encrypted with AES-256 (military-grade) before leaving your device. The hub server never sees your unencrypted files or private keys.
Do I need to open ports?
Port 4000 should be open for P2P uploads. Most home routers allow this by default. For strict firewalls, configure port forwarding.
Can I run my own hub?
Absolutely! The hub is just a Node.js server. Deploy to any cloud provider or run locally. See deployment docs.
What happens if hub goes down?
Active transfers continue (P2P), but you can't discover new users or request new downloads. Connect to a different hub.
Is there a file size limit?
Soft limit of 5GB per file to ensure stability. This can be increased in configuration.
This project is licensed under the MIT License - see LICENSE file for details.
MIT License - you are free to use, modify, and distribute this software.
- Inspired by DC++ and modern P2P protocols
- Built with open-source libraries (thank you!)
- Security best practices from OWASP guidelines
- UI/UX inspiration from modern messaging apps
- All contributors who make this project better
- Early testers who provided valuable feedback
- Open source community for amazing tools