@codai/memorai-core/dist/ai/AdvancedMemorySecurityManager.d.ts

Simplified advanced memory engine - no tiers, just powerful semantic search with persistence

/**
 * Advanced Memory Security Manager
 * Zero-trust security architecture with quantum-resistant encryption and comprehensive audit trails
 */
import { MemoryMetadata } from '../types/index.js';
export interface SecurityConfig {
    zeroTrustEnabled: boolean;
    encryptionAlgorithm: 'aes-256-gcm' | 'chacha20-poly1305' | 'quantum-resistant';
    keyRotationInterval: number;
    auditLogging: boolean;
    threatDetection: boolean;
    dataClassification: boolean;
    complianceMode: ComplianceStandard[];
    accessControlModel: 'rbac' | 'abac' | 'pbac';
    biometricAuth: boolean;
    quantumSafety: boolean;
}
export interface EncryptionMetadata {
    algorithm: string;
    keyId: string;
    iv: string;
    authTag?: string;
    timestamp: Date;
}
export type ComplianceStandard = 'GDPR' | 'HIPAA' | 'SOC2' | 'ISO27001' | 'FedRAMP' | 'PCI-DSS';
export interface SecurityContext {
    userId: string;
    agentId: string;
    sessionId: string;
    accessLevel: SecurityLevel;
    permissions: Permission[];
    riskScore: number;
    geoLocation?: {
        country: string;
        region: string;
        ip: string;
    };
    deviceFingerprint: string;
    authenticationMethods: AuthMethod[];
    timestamp: Date;
}
export type SecurityLevel = 'public' | 'internal' | 'confidential' | 'restricted' | 'top-secret';
export type Permission = 'read' | 'write' | 'delete' | 'share' | 'export' | 'admin';
export type AuthMethod = 'password' | 'mfa' | 'biometric' | 'certificate' | 'zero-knowledge';
export interface MemoryClassification {
    level: SecurityLevel;
    categories: string[];
    retentionPeriod: number;
    encryptionRequired: boolean;
    auditRequired: boolean;
    geographicRestrictions: string[];
    accessLog: boolean;
}
export interface SecurityAuditEvent {
    id: string;
    timestamp: Date;
    eventType: AuditEventType;
    userId: string;
    agentId: string;
    memoryId?: string;
    action: string;
    result: 'success' | 'failure' | 'blocked';
    riskScore: number;
    metadata: {
        ip: string;
        userAgent: string;
        location?: string;
        details: Record<string, unknown>;
    };
    compliance: {
        gdprCompliant: boolean;
        dataSubject?: string;
        legalBasis?: string;
        retention?: number;
    };
}
export type AuditEventType = 'memory_access' | 'memory_creation' | 'memory_modification' | 'memory_deletion' | 'memory_sharing' | 'authentication' | 'authorization' | 'security_violation' | 'compliance_check';
export interface ThreatDetectionRule {
    id: string;
    name: string;
    description: string;
    severity: 'low' | 'medium' | 'high' | 'critical';
    condition: (events: SecurityAuditEvent[]) => boolean;
    action: ThreatResponseAction;
    enabled: boolean;
}
export type ThreatResponseAction = 'log_only' | 'alert_admin' | 'block_user' | 'rate_limit' | 'require_auth' | 'escalate_security';
export declare class AdvancedMemorySecurityManager {
    private config;
    private auditEvents;
    private threatDetectionRules;
    private encryptionKeys;
    private accessTokens;
    private readonly MASTER_KEY_ID;
    private readonly QUANTUM_ALGORITHM;
    constructor(config?: Partial<SecurityConfig>);
    /**
     * Initialize security infrastructure
     */
    private initializeSecurityInfrastructure;
    /**
     * Authenticate and authorize memory access
     */
    authenticateAndAuthorize(userId: string, agentId: string, memoryId: string, action: Permission, context?: Partial<SecurityContext>): Promise<{
        authorized: boolean;
        securityContext: SecurityContext;
        restrictions: string[];
        auditEventId: string;
    }>;
    /**
     * Encrypt memory data with advanced encryption
     */
    encryptMemory(memory: MemoryMetadata, securityContext: SecurityContext): Promise<{
        encryptedData: string;
        encryptionMetadata: EncryptionMetadata;
    }>;
    /**
     * Decrypt memory data
     */
    decryptMemory(encryptedData: string, encryptionMetadata: EncryptionMetadata, _securityContext: SecurityContext): Promise<MemoryMetadata>;
    /**
     * Perform zero-trust verification
     */
    private performZeroTrustVerification;
    /**
     * Make access control decision based on configured model
     */
    private makeAccessControlDecision;
    /**
     * Calculate risk score for access attempt
     */
    private calculateRiskScore;
    /**
     * Classify memory data for security purposes
     */
    private classifyMemoryData;
    /**
     * Audit memory access event
     */
    private auditMemoryAccess;
    /**
     * Generate compliance metadata for audit events
     */
    private generateComplianceMetadata;
    private encryptWithAES256GCM;
    private decryptWithAES256GCM;
    private encryptWithChaCha20;
    private decryptWithChaCha20;
    private encryptWithQuantumResistant;
    private decryptWithQuantumResistant;
    private generateLatticeMatrix;
    private applyLatticeEncryption;
    private reverseLatticeEncryption;
    private applyErrorCorrection;
    private removeErrorCorrection;
    private calculateParity;
    private simulateHashReverse;
    private performHKDFExpansion;
    private applyLatticeTransformation;
    private applyCodeBasedTransformation;
    private applyMultivariateTransformation;
    private applyIsogenyTransformation;
    private generateLatticeBasis;
    private generateCodeMatrix;
    private generateMultivariateCoefficients;
    private generateIsogenyParameters;
    private applyIsogenyMap;
    private generateMasterKey;
    private getCurrentEncryptionKey;
    private generateSessionId;
    private generateDeviceFingerprint;
    private generateAuditId;
    private auditEvent;
    private scheduleKeyRotation;
    private rotateEncryptionKeys;
    private initializeThreatDetectionRules;
    private evaluateRoleBasedAccess;
    private evaluateAttributeBasedAccess;
    private evaluatePolicyBasedAccess;
    private isDeviceTrusted;
    private hasGeographicRestrictions;
    private getUserSecurityHistory;
    private assessLocationRisk;
    private assessTimeBasedRisk;
    private assessDeviceRisk;
    /**
     * Detect anomalous device fingerprint patterns
     */
    private isAnomalousDevicePattern;
    private assessAuthenticationRisk;
    private getRetentionPeriod;
    private getGeographicRestrictions;
    private determineLegalBasis;
    private getGDPRRetentionPeriod;
    private analyzeThreatIndicators;
    private handleThreatDetection;
    /**
     * Get security analytics
     */
    getSecurityAnalytics(): {
        totalAuditEvents: number;
        securityViolations: number;
        averageRiskScore: number;
        encryptionUsage: number;
        complianceStatus: Record<ComplianceStandard, boolean>;
    };
    /**
     * Check device registration status in security database
     */
    private checkDeviceRegistration;
    /**
     * Validate device certificate for enhanced security
     */
    private validateDeviceCertificate;
    /**
     * Check device against threat intelligence feeds
     */
    private checkDeviceThreatIntelligence;
    /**
     * Get list of restricted countries based on compliance requirements
     */
    private getRestrictedCountries;
    /**
     * Assess IP address threat level using security intelligence
     */
    private assessIPThreatLevel;
    /**
     * Detect VPN/Proxy usage for compliance scenarios
     */
    private detectVPNUsage;
    /**
     * Validate IP address format
     */
    private isValidIP;
    /**
     * Check for known malicious IP patterns
     */
    private isKnownMaliciousPattern;
    private calculateGeolocationRisk;
    private assessMaliciousPatterns;
    private assessNetworkReputation;
    private assessAbuseIndicators;
    private getHistoricalIncidentRisk;
    private extractIncidentFeatures;
    private analyzeTemporalPatterns;
    private analyzeGeographicIncidents;
    private calculateMalwareRisk;
    private calculateBruteForceRisk;
    private calculatePhishingRisk;
    private calculateExfiltrationRisk;
    private calculateDDoSRisk;
    private calculateSpamRisk;
    private applyTemporalDecay;
    private calculateIncidentFrequency;
    private analyzeSeasonalPatterns;
    private calculateRegionalThreatLevel;
    private calculateNeighborhoodRisk;
    private extractSubnet;
    private estimateASN;
    private estimateGeolocation;
    private calculateStringEntropy;
    private hashString;
    private calculateASNRisk;
    private getASNReputation;
    private estimateSubnetSize;
    private assessDataQuality;
    private applyConfidenceInterval;
    private assessRecentActivity;
    private calculateTrendDirection;
    private assessCrossBorderActivity;
    private calculateGeographicRiskFactor;
    private calculateJurisdictionalRisk;
    private getRecentRequestCount;
    private getFailedLoginCount;
    private getScannerIndicators;
    private generateTimeWindows;
    private calculateWindowRequestCount;
    private generateIPBehaviorProfile;
    private adjustForIPBehavior;
    private calculateNetworkLevelModifier;
    private calculateSubnetReputation;
    private analyzeTimeBasedFailurePatterns;
    private calculateRecentFailures;
    private analyzeHistoricalFailurePattern;
    private analyzeAttackVectors;
    private detectCredentialStuffing;
    private detectBruteForcePatterns;
    private calculateCurrentTimeWindow;
    private generateHistoricalFailureData;
    private calculateFailurePatternModifier;
    private detectRapidFailures;
    private detectAccountEnumeration;
    private detectPasswordListUsage;
    private detectDistributedAttack;
    private detectSystematicAttempts;
    private detectPasswordVariations;
    private detectTargetFocusing;
    private assessAttackPersistence;
    private generateScanningProfile;
    private detectPortScanActivity;
    private detectServiceEnumeration;
    private detectVulnerabilityScanning;
    private detectWebAppScanning;
    private detectNetworkReconnaissance;
    private detectAutomatedTools;
    private calculateScanningIntensity;
    private analyzeScanningTargetDiversity;
    private analyzeScanningTemporalDistribution;
    private analyzeScanningProtocolCoverage;
    private detectScanningEvasion;
    private detectScanningAutomation;
    private calculateUserAgentConsistency;
    private analyzeSessionPatterns;
    private analyzeGeographicStability;
    private analyzeTimingCharacteristics;
    private analyzeResourceAccess;
    private analyzeTimingRegularity;
    private analyzeUserAgentPatterns;
    private analyzeRequestStructureConsistency;
    private analyzeErrorHandlingPatterns;
    private calculateIPHash;
    /**
     * Assess distributed attack patterns across multiple IPs
     */
    private assessDistributedAttackPattern;
    /**
     * Apply failure decay to risk scores over time
     */
    private applyFailureDecay;
    /**
     * Apply contextual adjustments based on environment and threat landscape
     */
    private applyContextualAdjustment;
    /**
     * Analyze temporal patterns in scanning behavior
     */
    private analyzeScanningTemporalPatterns;
    /**
     * Analyze scanning intensity and volume
     */
    private analyzeScanningIntensity;
    /**
     * Assess sophistication level of scanning techniques
     */
    private assessScanningSophistication;
    /**
     * Detect evasion techniques in scanning behavior
     */
    private detectEvasionTechniques;
    /**
     * Calculate base scanning score
     */
    private calculateBaseScanningScore;
    /**
     * Calculate pattern complexity bonus
     */
    private calculatePatternComplexityBonus;
    /**
     * Calculate sophistication penalty (higher sophistication = higher threat)
     */
    private calculateSophisticationPenalty;
    /**
     * Calculate scanning confidence level
     */
    private calculateScanningConfidence;
    /**
     * Apply confidence adjustment to final score
     */
    private applyConfidenceAdjustment;
    /**
     * Analyze protocol usage patterns
     */
    private analyzeProtocolUsage;
    /**
     * Identify failure peak times
     */
    private identifyFailurePeakTimes;
    /**
     * Analyze cyclical failure patterns
     */
    private analyzeCyclicalFailurePatterns;
    /**
     * Analyze network context for additional threat indicators
     */
    private analyzeNetworkContext;
}
//# sourceMappingURL=AdvancedMemorySecurityManager.d.ts.map