@iota-big3/sdk-security/dist/quantum-safe/post-quantum-crypto.d.ts

Advanced security features including zero trust, quantum-safe crypto, and ML threat detection

/**
 * Post-Quantum Cryptography Implementation
 * NIST-approved quantum-resistant algorithms
 */
import * as crypto from 'crypto';
export interface PostQuantumConfig {
    algorithm: 'kyber' | 'dilithium' | 'falcon' | 'sphincs+';
    securityLevel: 1 | 3 | 5;
    hybridMode?: boolean;
    keyRotationInterval?: number;
}
export interface QuantumSafeKeyPair {
    publicKey: Buffer;
    privateKey: Buffer;
    algorithm: string;
    securityLevel: number;
    createdAt: Date;
    expiresAt?: Date;
}
export interface EncryptedData {
    ciphertext: Buffer;
    encapsulatedKey: Buffer;
    algorithm: string;
    nonce?: Buffer;
    tag?: Buffer;
}
export interface Signature {
    signature: Buffer;
    algorithm: string;
    publicKey: Buffer;
}
/**
 * Abstract base class for post-quantum algorithms
 */
export declare abstract class PostQuantumAlgorithm {
    protected config: PostQuantumConfig;
    constructor(_config: PostQuantumConfig);
    abstract generateKeyPair(): Promise<QuantumSafeKeyPair>;
    abstract encrypt(_publicKey: Buffer, plaintext: Buffer): Promise<EncryptedData>;
    abstract decrypt(_privateKey: Buffer, encryptedData: EncryptedData): Promise<Buffer>;
    abstract sign(_privateKey: Buffer, message: Buffer): Promise<Signature>;
    abstract verify(_publicKey: Buffer, message: Buffer, signature: Buffer): Promise<boolean>;
}
/**
 * CRYSTALS-Kyber implementation (Key Encapsulation)
 * NIST selected for encryption
 */
export declare class KyberAlgorithm extends PostQuantumAlgorithm {
    private readonly keyLengths;
    generateKeyPair(): Promise<QuantumSafeKeyPair>;
    encrypt(_publicKey: Buffer, plaintext: Buffer): Promise<EncryptedData>;
    decrypt(_privateKey: Buffer, encryptedData: EncryptedData): Promise<Buffer>;
    sign(_privateKey: Buffer, message: Buffer): Promise<Signature>;
    verify(_publicKey: Buffer, message: Buffer, signature: Buffer): Promise<boolean>;
    private decapsulate;
}
/**
 * CRYSTALS-Dilithium implementation (Digital Signatures)
 * NIST selected for signatures
 */
export declare class DilithiumAlgorithm extends PostQuantumAlgorithm {
    private readonly parameters;
    generateKeyPair(): Promise<QuantumSafeKeyPair>;
    encrypt(_publicKey: Buffer, plaintext: Buffer): Promise<EncryptedData>;
    decrypt(_privateKey: Buffer, encryptedData: EncryptedData): Promise<Buffer>;
    sign(_privateKey: Buffer, message: Buffer): Promise<Signature>;
    verify(_publicKey: Buffer, message: Buffer, signature: Buffer): Promise<boolean>;
}
/**
 * Hybrid Cryptography - Combines classical and post-quantum
 */
export declare class HybridCrypto {
    private config;
    private classical;
    private postQuantum;
    constructor(config: PostQuantumConfig, classicalAlgorithm?: 'rsa' | 'ecdsa');
    /**
     * Generate hybrid key pairs
     */
    generateKeyPairs(): Promise<{
        classical: crypto.KeyPairKeyObjectResult;
        postQuantum: QuantumSafeKeyPair;
    }>;
    /**
     * Hybrid encryption - uses both algorithms
     */
    encrypt(classicalPublicKey: crypto.KeyObject, quantumPublicKey: Buffer, plaintext: Buffer): Promise<{
        classical: Buffer;
        quantum: EncryptedData;
    }>;
    /**
     * Hybrid signatures - signs with both algorithms
     */
    sign(classicalPrivateKey: crypto.KeyObject, quantumPrivateKey: Buffer, message: Buffer): Promise<{
        classical: Buffer;
        quantum: Signature;
    }>;
}
/**
 * Quantum Random Number Generator
 */
export declare class QuantumRandomGenerator {
    private entropy;
    /**
     * Get quantum random bytes
     * In production, would interface with QRNG hardware
     */
    getRandomBytes(_length: number): Promise<Buffer>;
    private getQuantumEntropy;
}
/**
 * Key migration utilities
 */
export declare class KeyMigration {
    /**
     * Migrate from classical to post-quantum keys
     */
    static migrateKeys(classicalKey: crypto.KeyObject, algorithm: PostQuantumConfig): Promise<{
        postQuantum: QuantumSafeKeyPair;
        migration: {
            started: Date;
            completed: Date;
            algorithm: string;
        };
    }>;
    /**
     * Create migration report
     */
    static createMigrationReport(totalKeys: number, migratedKeys: number, algorithm: string): MigrationReport;
}
export interface MigrationReport {
    totalKeys: number;
    migratedKeys: number;
    percentComplete: number;
    algorithm: string;
    estimatedCompletionTime: Date;
    recommendations: string[];
}
//# sourceMappingURL=post-quantum-crypto.d.ts.map