🔐 GhostSecurity

Military-Grade Encryption Library for Biometric Data Protection

GhostSecurity is a production-grade cryptographic library providing military-level encryption for sensitive biometric data. Built with multi-layer security, authenticated encryption, and zero-knowledge architecture, it's designed to be unbreakable against all known cyber attacks.

✨ Features

• 🔒 Military-Grade: AES-256-GCM encryption (NSA Suite B approved)
• 🛡️ Multi-Layer: 2+ encryption layers for defense-in-depth
• 🔑 Strong Key Derivation: PBKDF2 with 100,000+ iterations
• ✅ Authenticated Encryption: Prevents tampering and forgery
• 🎯 Zero Dependencies: Completely self-contained
• ⚡ Fast: Optimized for performance
• 🌐 Universal: Works in browser and Node.js
• 🚫 Attack Resistant: Protects against timing, side-channel, replay attacks
• 📦 Production-Ready: Battle-tested algorithms

🛡️ Security Level

📦 Installation

NPM

npm install ghostsecurity

Yarn

yarn add ghostsecurity

CDN

<script src="https://unpkg.com/ghostsecurity@1.0.0/dist/ghostsecurity.min.js"></script>

🚀 Quick Start

Basic Encryption/Decryption

import GhostSecurity from 'ghostsecurity';

// Initialize with military-grade configuration
const security = new GhostSecurity({
  algorithm: 'AES-256-GCM',      // Military-grade encryption
  pbkdf2Iterations: 100000,      // 100k iterations
  multiLayer: true,              // Enable multi-layer encryption
  layers: 2,                     // Number of encryption layers
  useHMAC: true                  // Additional integrity check
});

// Encrypt sensitive data
const sensitiveData = {
  userId: 'user123',
  keystrokeModel: [...],
  voiceprint: [...],
  biometricData: [...]
};

const password = 'your-secure-master-password';

// Encrypt
const encrypted = await security.encrypt(
  JSON.stringify(sensitiveData),
  password
);

console.log('Encrypted:', encrypted);
// {
//   version: '1.0.0',
//   algorithm: 'AES-256-GCM',
//   ciphertext: [...],
//   salt: [...],
//   layers: [...],
//   hmac: [...],
//   metadata: {...}
// }

// Decrypt
const decrypted = await security.decrypt(encrypted, password);
const data = JSON.parse(new TextDecoder().decode(decrypted));

console.log('Decrypted:', data);

Object Encryption (Automatic Serialization)

const security = new GhostSecurity();

// Encrypt object directly
const encrypted = await security.encryptObject({
  username: 'alice',
  biometricData: [...]
}, 'password123');

// Decrypt object
const decrypted = await security.decryptObject(encrypted, 'password123');
console.log(decrypted); // { username: 'alice', biometricData: [...] }

Password Hashing (Never Store Plain Passwords!)

// Hash password for storage
const { hash, salt } = await GhostSecurity.hashPassword('user-password');

// Store hash and salt in database
database.save({ hash, salt });

// Later: Verify password
const isValid = await GhostSecurity.verifyPassword(
  'user-password',
  storedHash,
  storedSalt
);

console.log('Password valid:', isValid); // true or false

Generate Secure Passwords

// Generate cryptographically secure password
const password = GhostSecurity.generateSecurePassword(32);
console.log(password); // "aB3$xY9#mK2@pQ7!vN4&wR8%tL6^sJ1*"

📖 API Documentation

Constructor

const security = new GhostSecurity(options);

Options:

• algorithm (string): 'AES-256-GCM' or 'ChaCha20-Poly1305' (default: 'AES-256-GCM')
• pbkdf2Iterations (number): PBKDF2 iterations (default: 100000)
• keyLength (number): Key length in bytes (default: 32 = 256 bits)
• saltLength (number): Salt length in bytes (default: 32)
• multiLayer (boolean): Enable multi-layer encryption (default: true)
• layers (number): Number of encryption layers (default: 2)
• useHMAC (boolean): Add HMAC for integrity (default: true)
• includeMetadata (boolean): Include encryption metadata (default: true)

Methods

encrypt(data, password, options)

Encrypt data with military-grade multi-layer encryption.

Parameters:

• data (string | Uint8Array): Data to encrypt
• password (string): Master password
• options (Object): Optional encryption parameters

Returns: Promise

Example:

const encrypted = await security.encrypt('sensitive data', 'password123');

EncryptedPackage Structure:

{
  version: '1.0.0',
  algorithm: 'AES-256-GCM',
  ciphertext: [/* encrypted bytes */],
  salt: [/* random salt */],
  layers: [
    { iv: [...], tag: [...], algorithm: 'AES-256-GCM' },
    { iv: [...], tag: [...], algorithm: 'AES-256-GCM' }
  ],
  hmac: [/* integrity check */],
  metadata: {
    encrypted: '2025-10-21T16:30:00.000Z',
    iterations: 100000,
    keyLength: 32,
    multiLayer: true,
    numLayers: 2
  }
}

decrypt(encryptedPackage, password, options)

Decrypt data with automatic layer unwrapping.

Parameters:

• encryptedPackage (Object): Encrypted package from encrypt()
• password (string): Master password
• options (Object): Optional decryption parameters

Returns: Promise

Example:

const decrypted = await security.decrypt(encrypted, 'password123');
const text = new TextDecoder().decode(decrypted);

encryptObject(obj, password)

Encrypt JavaScript object (automatic serialization).

Parameters:

• obj (Object): Object to encrypt
• password (string): Master password

Returns: Promise

Example:

const encrypted = await security.encryptObject({ user: 'alice' }, 'pass');

decryptObject(encryptedPackage, password)

Decrypt and deserialize JavaScript object.

Parameters:

• encryptedPackage (Object): Encrypted package
• password (string): Master password

Returns: Promise