@averox/cryptosphare/dist/crypto/KeyManager.js

Real-time SDK for end-to-end encrypted messaging, key monitoring, and secure A/V streaming

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.KeyManager = void 0;
const events_1 = require("events");
const crypto_1 = require("crypto");
const logger_1 = require("../config/logger");
class KeyManager extends events_1.EventEmitter {
    constructor() {
        super();
        this.keys = new Map();
        this.metadata = new Map();
        this.forwardSecrecyEnabled = false;
        this.quantumResistantEnabled = false;
        this.logger = new logger_1.Logger({
            minLevel: logger_1.LogLevel.INFO,
            timestamps: true,
            showLevel: true,
        });
    }
    enableForwardSecrecy() {
        this.forwardSecrecyEnabled = true;
        this.logger.info('Forward secrecy enabled for key management');
    }
    enableQuantumResistance() {
        this.quantumResistantEnabled = true;
        this.logger.info('Quantum-resistant algorithms enabled');
    }
    generateKey(type) {
        let keyLength = 32;
        if (this.quantumResistantEnabled) {
            keyLength = 64;
        }
        const key = (0, crypto_1.randomBytes)(keyLength).toString('hex');
        const now = new Date();
        this.keys.set(type, key);
        this.metadata.set(type, {
            createdAt: now,
            lastRotated: now,
            compromised: false,
            usageCount: 0,
        });
        if (this.forwardSecrecyEnabled) {
            this.scheduleKeyRotation(type);
        }
        this.emit('keyGenerated', { type, timestamp: now });
        this.logger.info(`Generated new key for type: ${type}, length: ${keyLength * 8} bits`);
        return key;
    }
    getKey(type) {
        const key = this.keys.get(type);
        if (key) {
            const metadata = this.metadata.get(type);
            if (metadata) {
                metadata.usageCount++;
                this.metadata.set(type, metadata);
                if (this.forwardSecrecyEnabled && metadata.usageCount > 1000) {
                    this.rotateKey(type);
                }
            }
        }
        return key;
    }
    getKeyMetadata(type) {
        return this.metadata.get(type);
    }
    rotateKey(type) {
        const oldKey = this.keys.get(type);
        const newKey = this.generateKey(type);
        this.emit('keyRotated', {
            type: 'rotated',
            status: 'active',
            timestamp: new Date(),
            metadata: {
                oldKey,
                newKey,
                type,
            },
        });
    }
    scheduleKeyRotation(type) {
        const rotationInterval = this.quantumResistantEnabled
            ? 6 * 60 * 60 * 1000
            : 24 * 60 * 60 * 1000;
        setTimeout(() => {
            this.rotateKey(type);
            this.scheduleKeyRotation(type);
        }, rotationInterval);
    }
    markKeyAsCompromised(type) {
        const metadata = this.metadata.get(type);
        if (metadata) {
            metadata.compromised = true;
            this.metadata.set(type, metadata);
            this.emit('keyCompromised', { type, timestamp: new Date() });
            this.logger.warn(`Key marked as compromised for type: ${type}`);
            this.rotateKey(type);
        }
    }
    onKeyGenerated(callback) {
        this.on('keyGenerated', callback);
    }
    onKeyRotated(callback) {
        this.on('keyRotated', callback);
    }
    onKeyCompromised(callback) {
        this.on('keyCompromised', callback);
    }
}
exports.KeyManager = KeyManager;