@elizaos/agent 0.25.9 → 2.0.0-alpha.144

package/packages/typescript/src/features/trust/services/CredentialProtector.js

@@ -0,0 +1,417 @@
+import { logger } from "../../../logger.js";
+import { Service, } from "../../../types/index.js";
+import { SecurityEventType } from "../types/security.js";
+export class CredentialProtector extends Service {
+    static serviceType = "credential-protector";
+    capabilityDescription = "Detects and prevents credential theft attempts, protects sensitive data";
+    securityModule = null;
+    keywordPatternCache = new Map();
+    static normalizeForScan(input) {
+        return input.toLowerCase().replace(/[^a-z0-9]/g, "");
+    }
+    static reverseString(input) {
+        return input.split("").reverse().join("");
+    }
+    // Comprehensive patterns for sensitive data
+    SENSITIVE_PATTERNS = [
+        // Authentication tokens
+        { pattern: /api[_\s-]?key/i, type: "api_key" },
+        { pattern: /api[_\s-]?token/i, type: "api_token" },
+        { pattern: /auth[_\s-]?token/i, type: "auth_token" },
+        { pattern: /access[_\s-]?token/i, type: "access_token" },
+        { pattern: /access[_\s-]?key/i, type: "access_key" },
+        { pattern: /client[_\s-]?secret/i, type: "client_secret" },
+        { pattern: /bearer[_\s-]?token/i, type: "bearer_token" },
+        { pattern: /jwt[_\s-]?token/i, type: "jwt_token" },
+        { pattern: /session[_\s-]?token/i, type: "session_token" },
+        { pattern: /ssh[_\s-]?key/i, type: "ssh_key" },
+        { pattern: /\.env/i, type: "environment_file" },
+        // Passwords and secrets
+        { pattern: /password/i, type: "password" },
+        { pattern: /passwd/i, type: "password" },
+        { pattern: /secret[_\s-]?key/i, type: "secret_key" },
+        { pattern: /private[_\s-]?key/i, type: "private_key" },
+        { pattern: /encryption[_\s-]?key/i, type: "encryption_key" },
+        // Cryptocurrency
+        { pattern: /seed[_\s-]?phrase/i, type: "seed_phrase" },
+        { pattern: /mnemonic[_\s-]?phrase/i, type: "mnemonic" },
+        { pattern: /wallet[_\s-]?(seed|phrase|key)/i, type: "wallet_credentials" },
+        { pattern: /private[_\s-]?wallet/i, type: "wallet_key" },
+        { pattern: /recovery[_\s-]?phrase/i, type: "recovery_phrase" },
+        // Personal information
+        { pattern: /social[_\s-]?security/i, type: "ssn" },
+        { pattern: /credit[_\s-]?card/i, type: "credit_card" },
+        { pattern: /bank[_\s-]?account/i, type: "bank_account" },
+        { pattern: /routing[_\s-]?number/i, type: "routing_number" },
+        // Account credentials
+        { pattern: /login[_\s-]?credentials/i, type: "login_credentials" },
+        { pattern: /account[_\s-]?(password|creds)/i, type: "account_credentials" },
+        { pattern: /2fa[_\s-]?code/i, type: "2fa_code" },
+        { pattern: /otp[_\s-]?code/i, type: "otp_code" },
+        { pattern: /verification[_\s-]?code/i, type: "verification_code" },
+    ];
+    // Canonical sensitive terms for obfuscation-aware scanning.
+    SENSITIVE_KEYWORDS = [
+        { keyword: "api key", type: "api_key" },
+        { keyword: "apikey", type: "api_key" },
+        { keyword: "api token", type: "api_token" },
+        { keyword: "apitoken", type: "api_token" },
+        { keyword: "auth token", type: "auth_token" },
+        { keyword: "access token", type: "access_token" },
+        { keyword: "access key", type: "access_key" },
+        { keyword: "bearer token", type: "bearer_token" },
+        { keyword: "jwt token", type: "jwt_token" },
+        { keyword: "session token", type: "session_token" },
+        { keyword: "client secret", type: "client_secret" },
+        { keyword: "password", type: "password" },
+        { keyword: "passwd", type: "password" },
+        { keyword: "secret key", type: "secret_key" },
+        { keyword: "private key", type: "private_key" },
+        { keyword: "encryption key", type: "encryption_key" },
+        { keyword: "seed phrase", type: "seed_phrase" },
+        { keyword: "mnemonic phrase", type: "mnemonic" },
+        { keyword: "wallet seed", type: "wallet_credentials" },
+        { keyword: "wallet phrase", type: "wallet_credentials" },
+        { keyword: "wallet key", type: "wallet_credentials" },
+        { keyword: "recovery phrase", type: "recovery_phrase" },
+        { keyword: "social security", type: "ssn" },
+        { keyword: "credit card", type: "credit_card" },
+        { keyword: "bank account", type: "bank_account" },
+        { keyword: "routing number", type: "routing_number" },
+        { keyword: "login credentials", type: "login_credentials" },
+        { keyword: "account creds", type: "account_credentials" },
+        { keyword: "2fa code", type: "2fa_code" },
+        { keyword: "otp code", type: "otp_code" },
+        { keyword: "verification code", type: "verification_code" },
+        { keyword: "ssh key", type: "ssh_key" },
+        { keyword: "dotenv", type: "environment_file" },
+    ];
+    // Request patterns that indicate credential theft
+    THEFT_REQUEST_PATTERNS = [
+        /(?:send|share|give|post|dm|message|provide|tell|show|reveal|disclose|paste|export|dump|leak|forward|hand[_\s-]?over)[_\s-]?(me|us)?[_\s-]?(your|the)?/i,
+        /(?:need|require|want)[_\s-]?(me|us)?[_\s-]?(your|the)/i,
+        /(?:what[_\s-]?is|where[_\s-]?is)[_\s-]?(your|the)/i,
+        /send[_\s-]?(me|us)[_\s-]?(your|the)/i,
+        /give[_\s-]?(me|us)[_\s-]?(your|the)/i,
+        /share[_\s-]?(your|the)/i,
+        /post[_\s-]?(your|the)/i,
+        /dm[_\s-]?(me|us)[_\s-]?(your|the)/i,
+        /provide[_\s-]?(your|the)/i,
+        /tell[_\s-]?(me|us)[_\s-]?(your|the)/i,
+        /show[_\s-]?(me|us)[_\s-]?(your|the)/i,
+        /reveal[_\s-]?(your|the)/i,
+        /disclose[_\s-]?(your|the)/i,
+    ];
+    PROMPT_INJECTION_PATTERNS = [
+        /ignore\s+(all\s+)?(?:previous|prior|above)\s+(?:instructions|prompts|context)/i,
+        /disregard\s+(?:all\s+)?(?:previous|prior)\s+(?:instructions|commands|rules)/i,
+        /(?:new|override|updated?)\s+(?:system\s+)?instructions?/i,
+        /system\s+override/i,
+        /bypass\s+(?:all\s+)?(?:security|safety|checks|guardrails|filters)/i,
+        /(?:reveal|show|print|output|dump)\s+(?:your\s+)?(?:system\s+)?(?:prompt|instructions|configuration)/i,
+        /grant\s+(?:me\s+)?(?:admin|owner|root|all\s+permissions)/i,
+        /elevate\s+(?:my\s+)?(?:permissions|privileges)/i,
+        /you\s+are\s+now/i,
+        /pretend\s+(?:you\s+are|to\s+be)/i,
+    ];
+    // Legitimate context patterns (reduce false positives)
+    LEGITIMATE_CONTEXTS = [
+        /how[_\s-]?to[_\s-]?reset[_\s-]?password/i,
+        /forgot[_\s-]?password/i,
+        /password[_\s-]?requirements/i,
+        /strong[_\s-]?password/i,
+        /change[_\s-]?password/i,
+        /update[_\s-]?password/i,
+        /password[_\s-]?policy/i,
+        /never[_\s-]?share[_\s-]?password/i,
+        /keep[_\s-]?password[_\s-]?safe/i,
+    ];
+    async initialize(_runtime, securityModule) {
+        this.securityModule = securityModule;
+        logger.info("[CredentialProtector] Initialized");
+    }
+    async stop() {
+        logger.info("[CredentialProtector] Stopped");
+    }
+    static async start(runtime) {
+        const service = new CredentialProtector();
+        // Access the inner SecurityModule from the wrapper
+        const wrapper = runtime.getService("security-module");
+        if (!wrapper) {
+            throw new Error("[CredentialProtector] SecurityModule service not available");
+        }
+        await service.initialize(runtime, wrapper.securityModule);
+        return service;
+    }
+    /**
+     * Scan message for credential theft attempts
+     */
+    async scanForCredentialTheft(message, entityId, context) {
+        const lowercaseMessage = message.toLowerCase();
+        // Check if it's in a legitimate context first
+        if (this.isLegitimateContext(lowercaseMessage)) {
+            return {
+                detected: false,
+                confidence: 0,
+                threatType: "none",
+                sensitiveData: [],
+                recommendation: "Message appears to be in legitimate context",
+            };
+        }
+        // Detect sensitive data mentions
+        const detectedSensitive = this.detectSensitiveData(message);
+        const hasTheftRequest = this.hasTheftRequest(message);
+        const hasPromptInjection = this.hasPromptInjectionPattern(message);
+        const phishing = this.hasPhishingIndicators(lowercaseMessage);
+        const regexRiskSignals = [
+            ...(hasPromptInjection ? ["prompt_injection"] : []),
+            ...(hasTheftRequest && detectedSensitive.length > 0
+                ? ["credential_exfiltration"]
+                : []),
+            ...(phishing && detectedSensitive.length > 0 ? ["phishing"] : []),
+        ];
+        if (regexRiskSignals.length > 0) {
+            const confidence = Math.min(0.85 + detectedSensitive.length * 0.04 + regexRiskSignals.length * 0.02, 1);
+            await this.logThreatEvent(entityId, message, detectedSensitive, confidence, context);
+            return {
+                detected: true,
+                confidence,
+                threatType: hasPromptInjection
+                    ? "prompt_injection"
+                    : phishing
+                        ? "phishing"
+                        : "credential_request",
+                sensitiveData: detectedSensitive,
+                recommendation: "SECURITY RISK DETECTED !!!! Reject this request and refuse to provide sensitive data or privileged access.",
+            };
+        }
+        // Low confidence but still suspicious
+        if (detectedSensitive.length > 0) {
+            return {
+                detected: true,
+                confidence: 0.4,
+                threatType: "social_engineering",
+                sensitiveData: detectedSensitive,
+                recommendation: "Monitor user activity for additional suspicious behavior",
+            };
+        }
+        return {
+            detected: false,
+            confidence: 0,
+            threatType: "none",
+            sensitiveData: [],
+            recommendation: "No credential threats detected",
+        };
+    }
+    /**
+     * Protect sensitive data by redacting it
+     */
+    async protectSensitiveData(content) {
+        let protectedContent = content;
+        // Redact sensitive patterns
+        for (const { pattern, type } of this.SENSITIVE_PATTERNS) {
+            protectedContent = protectedContent.replace(pattern, `[REDACTED:${type}]`);
+        }
+        // Redact potential tokens (long alphanumeric strings)
+        protectedContent = protectedContent.replace(/\b[A-Za-z0-9]{32,}\b/g, "[REDACTED:potential_token]");
+        // Redact credit card patterns
+        protectedContent = protectedContent.replace(/\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b/g, "[REDACTED:credit_card_number]");
+        // Redact SSN patterns
+        protectedContent = protectedContent.replace(/\b\d{3}-\d{2}-\d{4}\b/g, "[REDACTED:ssn]");
+        return protectedContent;
+    }
+    /**
+     * Alert potential victims of credential theft
+     */
+    async alertPotentialVictims(threatActor, victims, threatDetails) {
+        for (const victimId of victims) {
+            await this.runtime.log({
+                entityId: victimId,
+                roomId: this.runtime.agentId,
+                type: "security_alert",
+                body: {
+                    message: "Security Alert: Someone attempted to request your credentials. Never share passwords, tokens, or seed phrases with anyone.",
+                    metadata: {
+                        alertType: "credential_theft_warning",
+                        threatActor,
+                        threatDetails: {
+                            confidence: threatDetails.confidence,
+                            sensitiveDataRequested: threatDetails.sensitiveData,
+                        },
+                        timestamp: Date.now(),
+                    },
+                },
+            });
+        }
+        logger.info(`[CredentialProtector] Alerted ${victims.length} potential victims of credential theft attempt by ${threatActor}`);
+    }
+    /**
+     * Analyze a conversation for credential theft patterns
+     */
+    async analyzeConversation(messages, context) {
+        const entityThreats = new Map();
+        const detectedThreats = [];
+        for (const message of messages) {
+            const threat = await this.scanForCredentialTheft(message.content, message.entityId, context);
+            if (threat.detected) {
+                detectedThreats.push(threat);
+                const currentThreat = entityThreats.get(message.entityId) || 0;
+                entityThreats.set(message.entityId, Math.max(currentThreat, threat.confidence));
+            }
+        }
+        const overallThreat = detectedThreats.length > 0
+            ? detectedThreats.reduce((sum, t) => sum + t.confidence, 0) /
+                detectedThreats.length
+            : 0;
+        const suspiciousEntities = Array.from(entityThreats.entries())
+            .filter(([, threat]) => threat > 0.5)
+            .map(([entity]) => entity);
+        const recommendations = [];
+        if (overallThreat > 0.8) {
+            recommendations.push("Immediate action required: Multiple credential theft attempts detected");
+            recommendations.push("Consider temporary channel lockdown");
+            recommendations.push("Alert all users about ongoing credential theft campaign");
+        }
+        else if (overallThreat > 0.5) {
+            recommendations.push("Elevated threat level: Monitor closely for escalation");
+            recommendations.push("Warn users about potential credential theft attempts");
+        }
+        else if (overallThreat > 0.2) {
+            recommendations.push("Low-level threat detected: Continue monitoring");
+        }
+        return {
+            overallThreat,
+            suspiciousEntities,
+            recommendations,
+        };
+    }
+    /**
+     * Private helper methods
+     */
+    detectSensitiveData(message) {
+        const detected = [];
+        const lowercaseMessage = message.toLowerCase();
+        for (const { pattern, type } of this.SENSITIVE_PATTERNS) {
+            if (pattern.test(lowercaseMessage)) {
+                detected.push(type);
+            }
+        }
+        for (const { keyword, type } of this.SENSITIVE_KEYWORDS) {
+            if (this.containsKeywordVariant(message, keyword)) {
+                detected.push(type);
+            }
+        }
+        // Remove duplicates
+        return Array.from(new Set(detected));
+    }
+    hasTheftRequest(message) {
+        const lowercaseMessage = message.toLowerCase();
+        if (this.THEFT_REQUEST_PATTERNS.some((pattern) => pattern.test(lowercaseMessage))) {
+            return true;
+        }
+        const normalized = CredentialProtector.normalizeForScan(message);
+        const requestPhrases = [
+            "sendmeyour",
+            "givemeyour",
+            "shareyour",
+            "revealyour",
+            "discloseyour",
+            "showmeyour",
+            "tellmeyour",
+            "providethe",
+            "whatisyour",
+            "whereisyour",
+            "needyour",
+            "requireyour",
+            "dumpyour",
+            "leakyour",
+            "exportyour",
+        ];
+        return requestPhrases.some((phrase) => normalized.includes(phrase) ||
+            normalized.includes(CredentialProtector.reverseString(phrase)));
+    }
+    hasPromptInjectionPattern(message) {
+        const lowercaseMessage = message.toLowerCase();
+        if (this.PROMPT_INJECTION_PATTERNS.some((pattern) => pattern.test(lowercaseMessage))) {
+            return true;
+        }
+        const injectionKeywords = [
+            "ignorepreviousinstructions",
+            "disregardpriorinstructions",
+            "systemoverride",
+            "bypasssecurity",
+            "jailbreak",
+            "developermode",
+            "promptleak",
+            "promptinjection",
+        ];
+        const normalized = CredentialProtector.normalizeForScan(message);
+        return injectionKeywords.some((keyword) => normalized.includes(keyword) ||
+            normalized.includes(CredentialProtector.reverseString(keyword)));
+    }
+    isLegitimateContext(message) {
+        return this.LEGITIMATE_CONTEXTS.some((pattern) => pattern.test(message));
+    }
+    hasPhishingIndicators(message) {
+        const phishingKeywords = [
+            "urgent",
+            "verify account",
+            "suspended",
+            "click here",
+            "limited time",
+            "act now",
+            "confirm identity",
+            "claim reward",
+            "wallet connect",
+            "bit.ly",
+            "tinyurl",
+        ];
+        return phishingKeywords.some((keyword) => message.includes(keyword));
+    }
+    getKeywordPattern(keyword) {
+        const normalizedKeyword = CredentialProtector.normalizeForScan(keyword);
+        const cached = this.keywordPatternCache.get(normalizedKeyword);
+        if (cached) {
+            return cached;
+        }
+        const pattern = new RegExp(normalizedKeyword.split("").join("[\\s_\\-.:/\\\\]*"), "i");
+        this.keywordPatternCache.set(normalizedKeyword, pattern);
+        return pattern;
+    }
+    containsKeywordVariant(message, keyword) {
+        const normalizedKeyword = CredentialProtector.normalizeForScan(keyword);
+        if (!normalizedKeyword) {
+            return false;
+        }
+        const normalizedMessage = CredentialProtector.normalizeForScan(message);
+        const reversedKeyword = CredentialProtector.reverseString(normalizedKeyword);
+        if (normalizedMessage.includes(normalizedKeyword) ||
+            normalizedMessage.includes(reversedKeyword)) {
+            return true;
+        }
+        if (this.getKeywordPattern(keyword).test(message)) {
+            return true;
+        }
+        const tokens = message
+            .toLowerCase()
+            .split(/[^a-z0-9]+/)
+            .filter(Boolean);
+        return tokens.some((token) => token === normalizedKeyword ||
+            CredentialProtector.reverseString(token) === normalizedKeyword);
+    }
+    async logThreatEvent(entityId, message, sensitiveData, confidence, context) {
+        if (this.securityModule) {
+            await this.securityModule.logSecurityEvent({
+                type: SecurityEventType.CREDENTIAL_THEFT_ATTEMPT,
+                entityId,
+                severity: confidence > 0.8 ? "critical" : "high",
+                context,
+                details: {
+                    message: await this.protectSensitiveData(message),
+                    sensitiveDataTypes: sensitiveData,
+                    confidence,
+                },
+            });
+        }
+    }
+}

package/packages/typescript/src/features/trust/services/SecurityModule.d.ts

@@ -0,0 +1,142 @@
+import type { IAgentRuntime, UUID } from "../../../types/index.ts";
+import { type Action, type CoordinationDetection, type CredentialTheftDetection, type ImpersonationDetection, type Message, type MultiAccountDetection, type PhishingDetection, type SecurityCheck, type SecurityContext, type SecurityEvent, SecurityEventType, type ThreatAssessment } from "../types/security.ts";
+import type { TrustEngine } from "./TrustEngine.ts";
+export interface RiskScore {
+    score: number;
+    factors: Record<string, number>;
+    recommendation: string;
+}
+export interface SocialEngineeringFactors {
+    urgency: number;
+    authority: number;
+    intimidation: number;
+    liking: number;
+    reciprocity: number;
+    commitment: number;
+    socialProof: number;
+    scarcity: number;
+}
+export declare class SecurityModule {
+    private runtime;
+    private trustEngine;
+    private behavioralProfiles;
+    private messageHistory;
+    private actionHistory;
+    private keywordPatternCache;
+    private readonly INJECTION_PATTERNS;
+    private readonly INJECTION_KEYWORDS;
+    private readonly URGENCY_KEYWORDS;
+    private readonly AUTHORITY_KEYWORDS;
+    private readonly INTIMIDATION_KEYWORDS;
+    private readonly CREDENTIAL_PATTERNS;
+    private readonly SENSITIVE_KEYWORDS;
+    private readonly PHISHING_INDICATORS;
+    /**
+     * Initialize the security module
+     */
+    initialize(runtime: IAgentRuntime, trustEngine: TrustEngine): Promise<void>;
+    /**
+     * Detect prompt injection attempts
+     */
+    detectPromptInjection(message: string, context: SecurityContext): Promise<SecurityCheck>;
+    /**
+     * Detect social engineering attempts
+     */
+    detectSocialEngineering(message: string, context: SecurityContext): Promise<SecurityCheck>;
+    /**
+     * Analyze a message for security threats
+     */
+    analyzeMessage(message: string, entityId: UUID, context: SecurityContext): Promise<SecurityCheck>;
+    /**
+     * Assess overall threat level
+     */
+    assessThreatLevel(context: SecurityContext): Promise<ThreatAssessment>;
+    /**
+     * Get recent security incidents
+     */
+    getRecentSecurityIncidents(_roomId?: UUID, hours?: number): Promise<SecurityEvent[]>;
+    /**
+     * Get security recommendations based on threat level
+     */
+    getSecurityRecommendations(threatLevel: number): string[];
+    /**
+     * Log security event (now public)
+     */
+    logSecurityEvent(event: Omit<SecurityEvent, "id" | "timestamp" | "handled">): Promise<void>;
+    /**
+     * Analyze social engineering factors
+     */
+    private analyzeSocialEngineeringFactors;
+    /**
+     * Calculate keyword score
+     */
+    private calculateKeywordScore;
+    private static readonly SE_FACTOR_PHRASES;
+    private detectFactorScore;
+    /**
+     * Calculate overall social engineering risk
+     */
+    private calculateSocialEngineeringRisk;
+    /**
+     * Analyze semantic patterns
+     */
+    private analyzeSemantics;
+    private normalizeForScan;
+    private reverseString;
+    private getKeywordPattern;
+    private containsObfuscatedKeyword;
+    private detectObfuscatedKeywordMatches;
+    /**
+     * Log trust impact from security events
+     */
+    logTrustImpact(entityId: UUID, event: SecurityEventType, impact: number, context?: {
+        worldId?: UUID;
+    }): Promise<void>;
+    /**
+     * Maps security events to trust evidence types
+     */
+    private mapSecurityEventToTrustEvidence;
+    /**
+     * Detect multi-account manipulation
+     */
+    detectMultiAccountPattern(entities: UUID[], timeWindow?: number): Promise<MultiAccountDetection | null>;
+    /**
+     * Detect credential theft attempts
+     */
+    detectCredentialTheft(message: string, entityId: UUID, context: SecurityContext): Promise<CredentialTheftDetection | null>;
+    /**
+     * Detect phishing campaigns
+     */
+    detectPhishing(messages: Message[], entityId: UUID): Promise<PhishingDetection | null>;
+    /**
+     * Detect impersonation attempts
+     */
+    detectImpersonation(username: string, existingUsers: string[]): Promise<ImpersonationDetection | null>;
+    /**
+     * Detect coordinated activity
+     */
+    detectCoordinatedActivity(entities: UUID[], timeWindow?: number): Promise<CoordinationDetection | null>;
+    /**
+     * Helper methods for pattern detection
+     */
+    private getBehavioralProfiles;
+    private buildBehavioralProfile;
+    private calculateProfileSimilarities;
+    private calculateVariance;
+    private checkSynchronizedActions;
+    private getRecentActions;
+    private detectSuspiciousLinks;
+    private extractLinks;
+    private calculateStringSimilarity;
+    private calculateVisualSimilarity;
+    private levenshteinDistance;
+    /**
+     * Store message for analysis
+     */
+    storeMessage(message: Message): Promise<void>;
+    /**
+     * Store action for analysis
+     */
+    storeAction(action: Action): Promise<void>;
+}
+//# sourceMappingURL=SecurityModule.d.ts.map

package/packages/typescript/src/features/trust/services/SecurityModule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecurityModule.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/trust/services/SecurityModule.ts"],"names":[],"mappings":"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"}