@iota-big3/sdk-security/dist/security-manager.d.ts

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

/**
 * @iota-big3/sdk-security - Clean Security Manager
 * Main security management system
 */
import { EventEmitter } from 'events';
import { ForensicCase, ForensicEvidence, ForensicReport, ReportType as ForensicReportType } from './forensics/types';
import { Evidence, Incident, ReportType } from './incident-response/types';
import type { SecurityConfig, SecurityEvent, SecurityHealthResult, SecurityMetrics, SecurityScanResult } from './types';
import type { SecurityManagerOptions } from './types/integration.types';
export declare class SecurityManager extends EventEmitter {
    readonly isEnabled: boolean;
    private config;
    private events;
    private scanResults;
    private metrics;
    private isInitialized;
    private integrations;
    private database?;
    private eventBus?;
    private enhancedScanner?;
    private secretsManager?;
    private incidentManager?;
    private incidentDetector?;
    private forensicsManager?;
    constructor(options: SecurityConfig | SecurityManagerOptions);
    private mergeWithCoreConfig;
    private setupEventListeners;
    initialize(): Promise<void>;
    private createDatabaseTables;
    private registerGatewayRoutes;
    private registerGatewayMiddleware;
    authenticate(credentials: {
        username: string;
        password: string;
        mfaToken?: string;
    }): Promise<{
        success: boolean;
        userId?: string;
        sessionId?: string;
        reason?: string;
    }>;
    private validateSession;
    checkRateLimit(userId: string, resource: string): Promise<{
        allowed: boolean;
        remaining: number;
    }>;
    private createUserSecurityDefaults;
    private queryAuditLogs;
    getConfig(): SecurityConfig;
    shutdown(): Promise<void>;
    isReady(): boolean;
    checkAccess(params: {
        subject: {
            id: string;
            username?: string;
        };
        resource: string;
        action: string;
        context?: unknown;
    }): Promise<{
        allowed: boolean;
        reason?: string;
    }>;
    recordEvent(event: SecurityEvent): Promise<void>;
    runScan(scanType: SecurityScanResult['scanType'], target: string): Promise<SecurityScanResult>;
    getMetrics(): SecurityMetrics;
    getHealth(): Promise<SecurityHealthResult>;
    healthCheck(): Promise<SecurityHealthResult>;
    private generateId;
    private generateSessionId;
    /**
     * Perform enhanced security scan with SIEM integration
     */
    performEnhancedScan(target: string, scanType?: string): Promise<any>;
    /**
     * Get current security posture from enhanced scanner
     */
    getSecurityPosture(): Promise<any>;
    /**
     * Filter request through WAF
     */
    filterRequest(request: any): Promise<{
        allowed: boolean;
        rule?: any;
    }>;
    /**
     * Update DDoS metrics
     */
    updateDDoSMetrics(metrics: any): void;
    /**
     * Get secret value
     */
    getSecret(name: string): Promise<any>;
    /**
     * Set secret value
     */
    setSecret(name: string, value: any, options?: any): Promise<void>;
    /**
     * Rotate secret
     */
    rotateSecret(name: string): Promise<void>;
    /**
     * Create dynamic database credentials
     */
    createDynamicDatabaseCredentials(database: string, role?: string): Promise<any>;
    /**
     * Generate certificate
     */
    generateCertificate(commonName: string, options?: any): Promise<any>;
    /**
     * Encrypt data using transit encryption
     */
    encryptData(plaintext: string | Buffer): Promise<string>;
    /**
     * Decrypt data
     */
    decryptData(ciphertext: string): Promise<string | Buffer>;
    /**
     * Create security incident
     */
    createSecurityIncident(incidentData: Partial<Incident>): Promise<Incident>;
    /**
     * Get incident by ID
     */
    getIncident(id: string): Promise<Incident>;
    /**
     * List active incidents
     */
    listActiveIncidents(): Promise<Incident[]>;
    /**
     * Execute incident response playbook
     */
    executePlaybook(incidentId: string, playbookId: string): Promise<void>;
    /**
     * Add evidence to incident
     */
    addIncidentEvidence(incidentId: string, evidence: Evidence): Promise<void>;
    /**
     * Generate incident report
     */
    generateIncidentReport(incidentId: string, type?: ReportType): Promise<any>;
    /**
     * Integrate security event processing with incident detection
     */
    private processSecurityEventForIncidents;
    /**
     * Map security event type to incident type
     */
    private mapEventTypeToIncidentType;
    /**
     * Create forensic case
     */
    createForensicCase(caseData: Partial<ForensicCase>): Promise<ForensicCase>;
    /**
     * Add forensic evidence
     */
    addForensicEvidence(caseId: string, evidenceData: Partial<ForensicEvidence>): Promise<ForensicEvidence>;
    /**
     * Analyze forensic evidence
     */
    analyzeForensicEvidence(evidenceId: string): Promise<any>;
    /**
     * Generate forensic report
     */
    generateForensicReport(caseId: string, type?: ForensicReportType): Promise<ForensicReport>;
    /**
     * Capture memory dump for forensics
     */
    captureMemoryDump(targetSystem?: string): Promise<ForensicEvidence>;
    /**
     * Capture network traffic for forensics
     */
    captureNetworkTraffic(duration?: number, filter?: string): Promise<ForensicEvidence>;
    /**
     * Quick forensic triage
     */
    performForensicTriage(targetPath: string): Promise<any>;
    /**
     * Map forensic finding type to incident type
     */
    private mapForensicFindingToIncidentType;
    /**
     * Map forensic severity to incident severity
     */
    private mapForensicSeverityToIncidentSeverity;
}
//# sourceMappingURL=security-manager.d.ts.map