cryptoflow

CryptoFlow

A powerful, zero-dependency cryptographic library for Node.js, providing military-grade encryption and comprehensive cryptographic operations with TypeScript support.

🌟 Features

• ✨ Zero external dependencies
• 🔒 Military-grade encryption (AES-256-GCM)
• 🔑 RSA public-key cryptography
• 📝 Digital signatures
• 🤝 Secure key exchange (ECDH/DH)
• 🔐 Password generation & key derivation
• #️⃣ Multiple hashing algorithms
• 📦 Full TypeScript support

📦 Installation

npm install cryptoflow

🚀 Quick Start

import { CryptoFlow } from 'cryptoflow';

// Symmetric Encryption
const key = CryptoFlow.generateKey();
const encrypted = CryptoFlow.encrypt("sensitive data", key);
const decrypted = CryptoFlow.decrypt(encrypted, key);

// Generate Strong Password
const password = CryptoFlow.generatePassword(16, {
    numbers: true,
    symbols: true,
    uppercase: true,
    lowercase: true
});

📚 API Reference

Symmetric Encryption

// Generate encryption key
const key = CryptoFlow.generateKey();

// Encrypt data
const encrypted = CryptoFlow.encrypt("sensitive data", key);

// Decrypt data
const decrypted = CryptoFlow.decrypt(encrypted, key);

RSA Encryption

// Generate RSA key pair
const keyPair = CryptoFlow.generateRSAKeyPair();

// Encrypt with public key
const encrypted = CryptoFlow.rsaEncrypt("secret message", keyPair.publicKey);

// Decrypt with private key
const decrypted = CryptoFlow.rsaDecrypt(encrypted, keyPair.privateKey);

Digital Signatures

// Sign data
const signature = CryptoFlow.digitalSign(data, privateKey);

// Verify signature
const isValid = CryptoFlow.verifySignature(data, signature, publicKey);

Key Exchange

// ECDH Key Exchange
const alice = CryptoFlow.createECDHKeyExchange();
const bob = CryptoFlow.createECDHKeyExchange();

// Compute shared secret
const aliceShared = alice.computeSecret(bob.publicKey);
const bobShared = bob.computeSecret(alice.publicKey);
// aliceShared equals bobShared

Password Management

// Generate secure password
const password = CryptoFlow.generatePassword(16, {
    numbers: true,
    symbols: true,
    uppercase: true,
    lowercase: true
});

// Derive key from password
const derivedKey = await CryptoFlow.deriveKey("user-password");

Hashing

// Single hash
const hash = CryptoFlow.hash("data");

// Multiple hash algorithms
const multiHash = CryptoFlow.multiHash("data", ["sha256", "sha512"]);

🔒 Security Features

• Uses cryptographically secure random generation
• Implements constant-time comparison to prevent timing attacks
• Follows cryptographic best practices
• Proper error handling for security-related issues

🎯 Use Cases

• Secure Data Storage

  • Encrypt sensitive data before storing in databases
  • Protect configuration files
  • Secure file storage systems

• User Authentication

  • Password hashing
  • Token generation
  • Session management

• Secure Communication

  • End-to-end encryption
  • Secure message exchange
  • API authentication

• Digital Signatures

  • Document signing
  • Transaction verification
  • Software updates

⚙️ TypeScript Support

CryptoFlow is written in TypeScript and includes comprehensive type definitions:

interface PasswordOptions {
    numbers?: boolean;
    symbols?: boolean;
    uppercase?: boolean;
    lowercase?: boolean;
}

interface RSAKeyPair {
    publicKey: string;
    privateKey: string;
}

interface KeyDerivationResult {
    key: Buffer;
    salt: Buffer;
}

🛡️ Best Practices

• Key Management

  • Securely store encryption keys
  • Use key derivation for password-based keys
  • Rotate keys periodically

• Error Handling

  try {
      const encrypted = CryptoFlow.encrypt(data, key);
  } catch (error) {
      if (error instanceof CryptoFlowException) {
          console.error('Encryption failed:', error.message);
      }
  }
  

• Secure Configuration

  • Use appropriate key sizes
  • Choose strong algorithms
  • Implement proper key storage

📋 Requirements

• Node.js 14.0.0 or higher
• TypeScript 4.0.0 or higher (for TypeScript users)

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

📝 License

This project is licensed under the MIT License - see the LICENSE file for details.