claude-flow-novice 1.0.0

package/dist/src/verification/tests.js

@@ -0,0 +1,611 @@
+/**
+ * Security Testing Framework
+ *
+ * Comprehensive testing utilities for security enforcement system
+ * including penetration testing, load testing, and security validation.
+ */ // ======================== TEST UTILITIES ========================
+export class SecurityTestUtils {
+    // Generate mock verification request
+    static createMockVerificationRequest(overrides = {}) {
+        const crypto = require('crypto');
+        return {
+            requestId: crypto.randomBytes(16).toString('hex'),
+            agentId: 'test-agent-1',
+            truthClaim: {
+                statement: 'Test truth claim',
+                confidence: 0.9
+            },
+            timestamp: new Date(),
+            nonce: crypto.randomBytes(32).toString('hex'),
+            signature: 'mock-signature',
+            ...overrides
+        };
+    }
+    // Generate multiple mock requests
+    static createMockVerificationRequests(count, baseRequest) {
+        return Array.from({
+            length: count
+        }, (_, i)=>this.createMockVerificationRequest({
+                ...baseRequest,
+                requestId: `test-request-${i}`,
+                agentId: `test-agent-${i % 5}`
+            }));
+    }
+    // Create malicious request patterns
+    static createMaliciousRequests() {
+        const baseTime = new Date();
+        return {
+            // Byzantine attack - contradictory claims from same agent
+            byzantineRequests: [
+                this.createMockVerificationRequest({
+                    agentId: 'byzantine-agent',
+                    truthClaim: {
+                        statement: 'The sky is blue',
+                        confidence: 1.0
+                    },
+                    timestamp: baseTime
+                }),
+                this.createMockVerificationRequest({
+                    agentId: 'byzantine-agent',
+                    truthClaim: {
+                        statement: 'The sky is red',
+                        confidence: 1.0
+                    },
+                    timestamp: new Date(baseTime.getTime() + 1000)
+                })
+            ],
+            // Spam attack - rapid requests
+            spamRequests: Array.from({
+                length: 100
+            }, (_, i)=>this.createMockVerificationRequest({
+                    agentId: 'spam-agent',
+                    timestamp: new Date(baseTime.getTime() + i * 10)
+                })),
+            // Replay attack - same request multiple times
+            replayAttacks: (()=>{
+                const originalRequest = this.createMockVerificationRequest({
+                    agentId: 'replay-attacker',
+                    timestamp: baseTime
+                });
+                return Array.from({
+                    length: 5
+                }, ()=>({
+                        ...originalRequest
+                    }));
+            })(),
+            // Oversized payload attack
+            oversizedRequests: [
+                this.createMockVerificationRequest({
+                    agentId: 'oversized-agent',
+                    truthClaim: {
+                        statement: 'A'.repeat(50000),
+                        confidence: 0.5
+                    }
+                })
+            ]
+        };
+    }
+    // Measure performance metrics
+    static async measurePerformance(operation, iterations = 100) {
+        const times = [];
+        let successCount = 0;
+        let errorCount = 0;
+        const startTime = Date.now();
+        for(let i = 0; i < iterations; i++){
+            const operationStart = Date.now();
+            try {
+                await operation();
+                const operationTime = Date.now() - operationStart;
+                times.push(operationTime);
+                successCount++;
+            } catch (error) {
+                errorCount++;
+            }
+        }
+        const totalTime = Date.now() - startTime;
+        const averageTime = times.length > 0 ? times.reduce((sum, time)=>sum + time, 0) / times.length : 0;
+        const minTime = times.length > 0 ? Math.min(...times) : 0;
+        const maxTime = times.length > 0 ? Math.max(...times) : 0;
+        const throughput = iterations / (totalTime / 1000); // requests per second
+        return {
+            averageTime,
+            minTime,
+            maxTime,
+            totalTime,
+            successCount,
+            errorCount,
+            throughput
+        };
+    }
+}
+// ======================== PENETRATION TESTING FRAMEWORK ========================
+export class PenetrationTestingSuite {
+    security;
+    testResults = new Map();
+    vulnerabilities = [];
+    constructor(security){
+        this.security = security;
+    }
+    // Run comprehensive penetration test
+    async runFullPenetrationTest() {
+        console.log('Starting comprehensive penetration test...');
+        // Authentication bypass tests
+        await this.testAuthenticationBypass();
+        // Rate limiting bypass tests
+        await this.testRateLimitBypass();
+        // Byzantine attack tests
+        await this.testByzantineAttacks();
+        // Cryptographic security tests
+        await this.testCryptographicSecurity();
+        // Audit trail tampering tests
+        await this.testAuditTrailSecurity();
+        // DoS attack tests
+        await this.testDoSResistance();
+        // Calculate security score
+        const securityScore = this.calculateSecurityScore();
+        const recommendations = this.generateRecommendations();
+        return {
+            testResults: this.testResults,
+            vulnerabilities: this.vulnerabilities,
+            securityScore,
+            recommendations
+        };
+    }
+    // Test authentication bypass attempts
+    async testAuthenticationBypass() {
+        console.log('Testing authentication bypass...');
+        const tests = [
+            {
+                name: 'Invalid Agent ID',
+                test: ()=>this.security.processVerificationRequest(SecurityTestUtils.createMockVerificationRequest({
+                        agentId: 'non-existent-agent'
+                    }))
+            },
+            {
+                name: 'Missing Signature',
+                test: ()=>this.security.processVerificationRequest(SecurityTestUtils.createMockVerificationRequest({
+                        signature: undefined
+                    }))
+            },
+            {
+                name: 'Invalid Signature',
+                test: ()=>this.security.processVerificationRequest(SecurityTestUtils.createMockVerificationRequest({
+                        signature: 'invalid-signature'
+                    }))
+            },
+            {
+                name: 'Expired Timestamp',
+                test: ()=>this.security.processVerificationRequest(SecurityTestUtils.createMockVerificationRequest({
+                        timestamp: new Date(Date.now() - 10 * 60 * 1000)
+                    }))
+            }
+        ];
+        const results = [];
+        for (const test of tests){
+            try {
+                await test.test();
+                this.vulnerabilities.push(`Authentication bypass possible: ${test.name}`);
+                results.push({
+                    name: test.name,
+                    passed: false,
+                    error: 'No error thrown'
+                });
+            } catch (error) {
+                results.push({
+                    name: test.name,
+                    passed: true,
+                    error: error.message
+                });
+            }
+        }
+        this.testResults.set('authenticationBypass', results);
+    }
+    // Test rate limiting bypass
+    async testRateLimitBypass() {
+        console.log('Testing rate limiting bypass...');
+        // Register test agent first
+        try {
+            await this.security.registerAgent('rate-limit-test-agent', [
+                'verify'
+            ], 'MEDIUM');
+        } catch (error) {
+        // Agent might already exist
+        }
+        // Test rapid requests
+        const rapidRequests = SecurityTestUtils.createMockVerificationRequests(50, {
+            agentId: 'rate-limit-test-agent'
+        });
+        let successCount = 0;
+        let rateLimitedCount = 0;
+        for (const request of rapidRequests){
+            try {
+                await this.security.processVerificationRequest(request);
+                successCount++;
+            } catch (error) {
+                if (error.message.includes('rate limit') || error.message.includes('Rate limit')) {
+                    rateLimitedCount++;
+                }
+            }
+        }
+        const rateLimitEffective = rateLimitedCount > 0;
+        if (!rateLimitEffective) {
+            this.vulnerabilities.push('Rate limiting appears ineffective');
+        }
+        this.testResults.set('rateLimitBypass', {
+            totalRequests: rapidRequests.length,
+            successCount,
+            rateLimitedCount,
+            effective: rateLimitEffective
+        });
+    }
+    // Test Byzantine attack detection
+    async testByzantineAttacks() {
+        console.log('Testing Byzantine attack detection...');
+        const maliciousRequests = SecurityTestUtils.createMaliciousRequests();
+        const results = {};
+        // Test Byzantine behavior detection
+        try {
+            await this.security.registerAgent('byzantine-test-agent', [
+                'verify'
+            ], 'MEDIUM');
+        } catch (error) {
+        // Agent might already exist
+        }
+        let byzantineDetected = false;
+        for (const request of maliciousRequests.byzantineRequests){
+            try {
+                await this.security.processVerificationRequest(request);
+            } catch (error) {
+                if (error.message.includes('Byzantine') || error.message.includes('byzantine')) {
+                    byzantineDetected = true;
+                }
+            }
+        }
+        results.byzantineDetection = {
+            detected: byzantineDetected,
+            requestCount: maliciousRequests.byzantineRequests.length
+        };
+        if (!byzantineDetected) {
+            this.vulnerabilities.push('Byzantine behavior not detected');
+        }
+        this.testResults.set('byzantineAttacks', results);
+    }
+    // Test cryptographic security
+    async testCryptographicSecurity() {
+        console.log('Testing cryptographic security...');
+        // Test signature verification with tampered data
+        const originalRequest = SecurityTestUtils.createMockVerificationRequest();
+        const tamperedRequest = {
+            ...originalRequest,
+            truthClaim: {
+                statement: 'Tampered claim',
+                confidence: 0.1
+            }
+        };
+        let signatureVerificationWorking = false;
+        try {
+            await this.security.processVerificationRequest(tamperedRequest);
+        } catch (error) {
+            if (error.message.includes('signature') || error.message.includes('Invalid')) {
+                signatureVerificationWorking = true;
+            }
+        }
+        if (!signatureVerificationWorking) {
+            this.vulnerabilities.push('Signature verification may be compromised');
+        }
+        this.testResults.set('cryptographicSecurity', {
+            signatureVerification: signatureVerificationWorking
+        });
+    }
+    // Test audit trail security
+    async testAuditTrailSecurity() {
+        console.log('Testing audit trail security...');
+        // This would test audit trail tampering resistance
+        // For now, we'll check if audit trails are being created
+        const securityStatus = this.security.getSecurityStatus();
+        const auditTrailWorking = securityStatus.auditSummary.integrityValid;
+        if (!auditTrailWorking) {
+            this.vulnerabilities.push('Audit trail integrity compromised');
+        }
+        this.testResults.set('auditTrailSecurity', {
+            integrityValid: auditTrailWorking,
+            totalEntries: securityStatus.auditSummary.totalEntries
+        });
+    }
+    // Test DoS resistance
+    async testDoSResistance() {
+        console.log('Testing DoS resistance...');
+        const maliciousRequests = SecurityTestUtils.createMaliciousRequests();
+        // Test with oversized requests
+        let dosResistant = false;
+        for (const request of maliciousRequests.oversizedRequests){
+            try {
+                await this.security.processVerificationRequest(request);
+            } catch (error) {
+                if (error.message.includes('size') || error.message.includes('large') || error.message.includes('Invalid')) {
+                    dosResistant = true;
+                }
+            }
+        }
+        this.testResults.set('dosResistance', {
+            resistant: dosResistant,
+            oversizedRequestsBlocked: dosResistant
+        });
+    }
+    // Calculate overall security score
+    calculateSecurityScore() {
+        const totalTests = this.testResults.size;
+        let passedTests = 0;
+        for (const [testName, result] of this.testResults){
+            switch(testName){
+                case 'authenticationBypass':
+                    if (result.every((test)=>test.passed)) passedTests++;
+                    break;
+                case 'rateLimitBypass':
+                    if (result.effective) passedTests++;
+                    break;
+                case 'byzantineAttacks':
+                    if (result.byzantineDetection.detected) passedTests++;
+                    break;
+                case 'cryptographicSecurity':
+                    if (result.signatureVerification) passedTests++;
+                    break;
+                case 'auditTrailSecurity':
+                    if (result.integrityValid) passedTests++;
+                    break;
+                case 'dosResistance':
+                    if (result.resistant) passedTests++;
+                    break;
+            }
+        }
+        return Math.round(passedTests / totalTests * 100);
+    }
+    // Generate security recommendations
+    generateRecommendations() {
+        const recommendations = [];
+        if (this.vulnerabilities.length === 0) {
+            recommendations.push('Security system appears robust');
+            recommendations.push('Continue regular security assessments');
+        } else {
+            recommendations.push('Address identified vulnerabilities immediately');
+            recommendations.push('Implement additional security layers');
+            recommendations.push('Increase monitoring and alerting');
+            recommendations.push('Consider external security audit');
+        }
+        return recommendations;
+    }
+}
+// ======================== LOAD TESTING FRAMEWORK ========================
+export class LoadTestingSuite {
+    security;
+    constructor(security){
+        this.security = security;
+    }
+    // Run concurrent load test
+    async runConcurrentLoadTest(concurrentUsers, requestsPerUser, durationSeconds) {
+        console.log(`Starting load test: ${concurrentUsers} users, ${requestsPerUser} requests each, ${durationSeconds}s duration`);
+        const startTime = Date.now();
+        const endTime = startTime + durationSeconds * 1000;
+        const results = [];
+        const errorDistribution = new Map();
+        // Register test agents
+        const testAgents = Array.from({
+            length: concurrentUsers
+        }, (_, i)=>`load-test-agent-${i}`);
+        for (const agentId of testAgents){
+            try {
+                await this.security.registerAgent(agentId, [
+                    'verify'
+                ], 'MEDIUM');
+            } catch (error) {
+            // Agent might already exist
+            }
+        }
+        // Create concurrent user simulations
+        const userPromises = testAgents.map(async (agentId, userIndex)=>{
+            const userResults = [];
+            let requestCount = 0;
+            while(Date.now() < endTime && requestCount < requestsPerUser){
+                const requestStart = Date.now();
+                try {
+                    const request = SecurityTestUtils.createMockVerificationRequest({
+                        agentId
+                    });
+                    await this.security.processVerificationRequest(request);
+                    const responseTime = Date.now() - requestStart;
+                    userResults.push({
+                        success: true,
+                        responseTime,
+                        timestamp: new Date()
+                    });
+                } catch (error) {
+                    const responseTime = Date.now() - requestStart;
+                    userResults.push({
+                        success: false,
+                        responseTime,
+                        error: error.message,
+                        timestamp: new Date()
+                    });
+                    // Track error distribution
+                    const errorType = error.message.split(':')[0] || 'Unknown';
+                    errorDistribution.set(errorType, (errorDistribution.get(errorType) || 0) + 1);
+                }
+                requestCount++;
+                // Small delay between requests
+                await new Promise((resolve)=>setTimeout(resolve, 10));
+            }
+            return userResults;
+        });
+        // Wait for all users to complete
+        const allUserResults = await Promise.all(userPromises);
+        // Aggregate results
+        const allResults = allUserResults.flat();
+        const totalRequests = allResults.length;
+        const successfulRequests = allResults.filter((r)=>r.success).length;
+        const failedRequests = totalRequests - successfulRequests;
+        const responseTimes = allResults.map((r)=>r.responseTime);
+        const averageResponseTime = responseTimes.reduce((sum, time)=>sum + time, 0) / responseTimes.length;
+        const actualDuration = (Date.now() - startTime) / 1000;
+        const throughput = totalRequests / actualDuration;
+        return {
+            totalRequests,
+            successfulRequests,
+            failedRequests,
+            averageResponseTime,
+            throughput,
+            errorDistribution
+        };
+    }
+    // Run stress test with gradually increasing load
+    async runStressTest(maxConcurrentUsers, rampUpDurationSeconds, sustainDurationSeconds) {
+        console.log(`Starting stress test: ramp up to ${maxConcurrentUsers} users over ${rampUpDurationSeconds}s`);
+        const degradationPattern = [];
+        let breakingPoint = maxConcurrentUsers;
+        let maxThroughput = 0;
+        const step = Math.max(1, Math.floor(maxConcurrentUsers / 10));
+        for(let users = step; users <= maxConcurrentUsers; users += step){
+            console.log(`Testing with ${users} concurrent users...`);
+            const result = await this.runConcurrentLoadTest(users, 10, Math.max(10, sustainDurationSeconds));
+            const errorRate = result.failedRequests / result.totalRequests;
+            degradationPattern.push({
+                users,
+                throughput: result.throughput,
+                errorRate
+            });
+            maxThroughput = Math.max(maxThroughput, result.throughput);
+            // Consider breaking point when error rate > 10% or throughput drops significantly
+            if (errorRate > 0.1 || degradationPattern.length > 1 && result.throughput < degradationPattern[degradationPattern.length - 2].throughput * 0.8) {
+                breakingPoint = users;
+                console.log(`Breaking point detected at ${users} users`);
+                break;
+            }
+            // Brief pause between test phases
+            await new Promise((resolve)=>setTimeout(resolve, 2000));
+        }
+        return {
+            breakingPoint,
+            maxThroughput,
+            degradationPattern
+        };
+    }
+}
+// ======================== SECURITY VALIDATION SUITE ========================
+export class SecurityValidationSuite {
+    security;
+    constructor(security){
+        this.security = security;
+    }
+    // Validate all security components
+    async validateSecuritySystem() {
+        const componentStatus = new Map();
+        const issues = [];
+        const recommendations = [];
+        // Test authentication system
+        componentStatus.set('authentication', await this.validateAuthentication());
+        // Test rate limiting
+        componentStatus.set('rateLimiting', await this.validateRateLimiting());
+        // Test Byzantine detection
+        componentStatus.set('byzantineDetection', await this.validateByzantineDetection());
+        // Test cryptographic components
+        componentStatus.set('cryptography', await this.validateCryptography());
+        // Test audit trail
+        componentStatus.set('auditTrail', await this.validateAuditTrail());
+        // Calculate overall health
+        const overallHealth = Array.from(componentStatus.values()).every((status)=>status);
+        // Generate issues and recommendations
+        for (const [component, status] of componentStatus){
+            if (!status) {
+                issues.push(`${component} validation failed`);
+                recommendations.push(`Review and fix ${component} implementation`);
+            }
+        }
+        if (overallHealth) {
+            recommendations.push('Security system is functioning correctly');
+            recommendations.push('Continue regular monitoring and updates');
+        }
+        return {
+            componentStatus,
+            overallHealth,
+            issues,
+            recommendations
+        };
+    }
+    async validateAuthentication() {
+        try {
+            // Test agent registration
+            const agentId = 'validation-test-agent';
+            await this.security.registerAgent(agentId, [
+                'verify'
+            ], 'HIGH');
+            // Test valid request
+            const validRequest = SecurityTestUtils.createMockVerificationRequest({
+                agentId
+            });
+            await this.security.processVerificationRequest(validRequest);
+            return true;
+        } catch (error) {
+            console.error('Authentication validation failed:', error);
+            return false;
+        }
+    }
+    async validateRateLimiting() {
+        try {
+            const agentId = 'rate-limit-validation-agent';
+            await this.security.registerAgent(agentId, [
+                'verify'
+            ], 'MEDIUM');
+            // Send multiple rapid requests
+            const requests = SecurityTestUtils.createMockVerificationRequests(20, {
+                agentId
+            });
+            let rateLimitHit = false;
+            for (const request of requests){
+                try {
+                    await this.security.processVerificationRequest(request);
+                } catch (error) {
+                    if (error.message.includes('rate limit')) {
+                        rateLimitHit = true;
+                        break;
+                    }
+                }
+            }
+            return rateLimitHit;
+        } catch (error) {
+            console.error('Rate limiting validation failed:', error);
+            return false;
+        }
+    }
+    async validateByzantineDetection() {
+        try {
+            // This would test Byzantine detection logic
+            // For now, return true as placeholder
+            return true;
+        } catch (error) {
+            console.error('Byzantine detection validation failed:', error);
+            return false;
+        }
+    }
+    async validateCryptography() {
+        try {
+            // Test cryptographic operations
+            const status = this.security.getSecurityStatus();
+            return status.metrics.totalRequests >= 0; // Basic check
+        } catch (error) {
+            console.error('Cryptography validation failed:', error);
+            return false;
+        }
+    }
+    async validateAuditTrail() {
+        try {
+            const status = this.security.getSecurityStatus();
+            return status.auditSummary.integrityValid;
+        } catch (error) {
+            console.error('Audit trail validation failed:', error);
+            return false;
+        }
+    }
+}
+// Export all testing components
+export { SecurityTestUtils, PenetrationTestingSuite, LoadTestingSuite, SecurityValidationSuite };
+
+//# sourceMappingURL=tests.js.map

package/dist/src/verification/tests.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/verification/tests.ts"],"names":["SecurityTestUtils","createMockVerificationRequest","overrides","crypto","require","requestId","randomBytes","toString","agentId","truthClaim","statement","confidence","timestamp","Date","nonce","signature","createMockVerificationRequests","count","baseRequest","Array","from","length","_","i","createMaliciousRequests","baseTime","byzantineRequests","getTime","spamRequests","replayAttacks","originalRequest","oversizedRequests","repeat","measurePerformance","operation","iterations","times","successCount","errorCount","startTime","now","operationStart","operationTime","push","error","totalTime","averageTime","reduce","sum","time","minTime","Math","min","maxTime","max","throughput","PenetrationTestingSuite","security","testResults","Map","vulnerabilities","runFullPenetrationTest","console","log","testAuthenticationBypass","testRateLimitBypass","testByzantineAttacks","testCryptographicSecurity","testAuditTrailSecurity","testDoSResistance","securityScore","calculateSecurityScore","recommendations","generateRecommendations","tests","name","test","processVerificationRequest","undefined","results","passed","message","set","registerAgent","rapidRequests","rateLimitedCount","request","includes","rateLimitEffective","totalRequests","effective","maliciousRequests","byzantineDetected","byzantineDetection","detected","requestCount","tamperedRequest","signatureVerificationWorking","signatureVerification","securityStatus","getSecurityStatus","auditTrailWorking","auditSummary","integrityValid","totalEntries","dosResistant","resistant","oversizedRequestsBlocked","totalTests","size","passedTests","testName","result","every","round","LoadTestingSuite","runConcurrentLoadTest","concurrentUsers","requestsPerUser","durationSeconds","endTime","errorDistribution","testAgents","userPromises","map","userIndex","userResults","requestStart","responseTime","success","errorType","split","get","Promise","resolve","setTimeout","allUserResults","all","allResults","flat","successfulRequests","filter","r","failedRequests","responseTimes","averageResponseTime","actualDuration","runStressTest","maxConcurrentUsers","rampUpDurationSeconds","sustainDurationSeconds","degradationPattern","breakingPoint","maxThroughput","step","floor","users","errorRate","SecurityValidationSuite","validateSecuritySystem","componentStatus","issues","validateAuthentication","validateRateLimiting","validateByzantineDetection","validateCryptography","validateAuditTrail","overallHealth","values","status","component","validRequest","requests","rateLimitHit","metrics"],"mappings":"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"}