honeyweb-core 2.0.2 → 2.0.4

package/storage/memory-store.js

@@ -1,45 +1,28 @@
 // honeyweb-core/storage/memory-store.js
-// In-memory storage for testing
 
 class MemoryStore {
     constructor(config) {
-        this.bannedIPs = new Map(); // ip -> { reason, timestamp, expiry }
-        this.banDuration = config.banDuration || 86400000; // 24 hours
+        this.bannedIPs = new Map();
+        this.banDuration = config.banDuration || 86400000;
         this.autoCleanup = config.autoCleanup !== false;
 
-        // Start auto-cleanup if enabled
         if (this.autoCleanup) {
-            this.cleanupInterval = setInterval(() => {
-                this._cleanupExpired();
-            }, 60000); // Clean up every minute
+            this.cleanupInterval = setInterval(() => this._cleanupExpired(), 60000);
         }
     }
 
-    /**
-     * Get all banned IPs
-     * @returns {Promise<Array>}
-     */
     async getAll() {
         const result = [];
         for (const [ip, data] of this.bannedIPs.entries()) {
-            result.push({
-                ip,
-                ...data
-            });
+            result.push({ ip, ...data });
         }
         return result;
     }
 
-    /**
-     * Check if IP is banned
-     * @param {string} ip
-     * @returns {Promise<boolean>}
-     */
     async isBanned(ip) {
         const entry = this.bannedIPs.get(ip);
         if (!entry) return false;
 
-        // Check if expired
         if (entry.expiry && Date.now() > entry.expiry) {
             this.bannedIPs.delete(ip);
             return false;
@@ -48,12 +31,6 @@ class MemoryStore {
         return true;
     }
 
-    /**
-     * Ban an IP
-     * @param {string} ip
-     * @param {string} reason
-     * @returns {Promise<void>}
-     */
     async ban(ip, reason = 'Suspicious activity') {
         this.bannedIPs.set(ip, {
             reason,
@@ -62,19 +39,10 @@ class MemoryStore {
         });
     }
 
-    /**
-     * Unban an IP
-     * @param {string} ip
-     * @returns {Promise<void>}
-     */
     async unban(ip) {
         this.bannedIPs.delete(ip);
     }
 
-    /**
-     * Clean up expired bans
-     * @private
-     */
     _cleanupExpired() {
         const now = Date.now();
         for (const [ip, entry] of this.bannedIPs.entries()) {
@@ -84,44 +52,24 @@ class MemoryStore {
         }
     }
 
-    /**
-     * Get statistics
-     * @returns {Promise<Object>}
-     */
     async getStats() {
         const now = Date.now();
-        let active = 0;
-        let expired = 0;
+        let active = 0, expired = 0;
 
         for (const entry of this.bannedIPs.values()) {
-            if (!entry.expiry || now <= entry.expiry) {
-                active++;
-            } else {
-                expired++;
-            }
+            if (!entry.expiry || now <= entry.expiry) active++;
+            else expired++;
         }
 
-        return {
-            total: this.bannedIPs.size,
-            active,
-            expired
-        };
+        return { total: this.bannedIPs.size, active, expired };
     }
 
-    /**
-     * Clear all bans
-     */
     clear() {
         this.bannedIPs.clear();
     }
 
-    /**
-     * Cleanup and stop intervals
-     */
     destroy() {
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-        }
+        if (this.cleanupInterval) clearInterval(this.cleanupInterval);
     }
 }
 

package/utils/cache.js

@@ -1,26 +1,16 @@
 // honeyweb-core/utils/cache.js
-// LRU cache implementation for DNS verification and blocklist
 
 class LRUCache {
     constructor(maxSize = 1000, ttl = 3600000) {
         this.maxSize = maxSize;
-        this.ttl = ttl; // Time to live in milliseconds
+        this.ttl = ttl;
         this.cache = new Map();
     }
 
-    /**
-     * Get value from cache
-     * @param {string} key
-     * @returns {*} - Value or undefined if not found/expired
-     */
     get(key) {
         const item = this.cache.get(key);
+        if (!item) return undefined;
 
-        if (!item) {
-            return undefined;
-        }
-
-        // Check if expired
         if (Date.now() > item.expiry) {
             this.cache.delete(key);
             return undefined;
@@ -29,76 +19,43 @@ class LRUCache {
         // Move to end (most recently used)
         this.cache.delete(key);
         this.cache.set(key, item);
-
         return item.value;
     }
 
-    /**
-     * Set value in cache
-     * @param {string} key
-     * @param {*} value
-     * @param {number} customTTL - Optional custom TTL for this entry
-     */
     set(key, value, customTTL) {
-        // Remove if already exists
-        if (this.cache.has(key)) {
-            this.cache.delete(key);
-        }
+        if (this.cache.has(key)) this.cache.delete(key);
 
-        // Evict oldest if at capacity
         if (this.cache.size >= this.maxSize) {
             const firstKey = this.cache.keys().next().value;
             this.cache.delete(firstKey);
         }
 
-        const ttl = customTTL || this.ttl;
         this.cache.set(key, {
             value,
-            expiry: Date.now() + ttl
+            expiry: Date.now() + (customTTL || this.ttl)
         });
     }
 
-    /**
-     * Check if key exists and is not expired
-     * @param {string} key
-     * @returns {boolean}
-     */
     has(key) {
         return this.get(key) !== undefined;
     }
 
-    /**
-     * Delete key from cache
-     * @param {string} key
-     */
     delete(key) {
         this.cache.delete(key);
     }
 
-    /**
-     * Clear all entries
-     */
     clear() {
         this.cache.clear();
     }
 
-    /**
-     * Get cache size
-     * @returns {number}
-     */
     size() {
         return this.cache.size;
     }
 
-    /**
-     * Clean up expired entries
-     */
     cleanup() {
         const now = Date.now();
         for (const [key, item] of this.cache.entries()) {
-            if (now > item.expiry) {
-                this.cache.delete(key);
-            }
+            if (now > item.expiry) this.cache.delete(key);
         }
     }
 }

package/utils/dns-verify.js

@@ -1,92 +1,55 @@
 // honeyweb-core/utils/dns-verify.js
-// DNS verification utilities for bot whitelist
 
 const dns = require('dns').promises;
 const LRUCache = require('./cache');
 
 class DNSVerifier {
     constructor(cacheTTL = 86400000) {
-        // Cache DNS results for 24 hours by default
         this.cache = new LRUCache(500, cacheTTL);
     }
 
-    /**
-     * Verify if IP belongs to claimed bot domain
-     * @param {string} ip - IP address to verify
-     * @param {string} expectedDomain - Expected domain pattern (e.g., 'googlebot.com')
-     * @returns {Promise<Object>} - { verified: boolean, hostname: string, error: string }
-     */
     async verify(ip, expectedDomain) {
-        // Check cache first
         const cacheKey = `${ip}:${expectedDomain}`;
-        if (this.cache.has(cacheKey)) {
-            return this.cache.get(cacheKey);
-        }
+        if (this.cache.has(cacheKey)) return this.cache.get(cacheKey);
 
         try {
-            // Step 1: Reverse DNS lookup (IP -> hostname)
+            // Reverse DNS: IP -> hostname
             const hostnames = await dns.reverse(ip);
 
             if (!hostnames || hostnames.length === 0) {
-                const result = {
-                    verified: false,
-                    hostname: null,
-                    error: 'No reverse DNS record found'
-                };
+                const result = { verified: false, hostname: null, error: 'No reverse DNS record found' };
                 this.cache.set(cacheKey, result);
                 return result;
             }
 
             const hostname = hostnames[0];
 
-            // Step 2: Check if hostname matches expected domain
             if (!hostname.endsWith(expectedDomain)) {
-                const result = {
-                    verified: false,
-                    hostname,
-                    error: `Hostname ${hostname} does not match expected domain ${expectedDomain}`
-                };
+                const result = { verified: false, hostname, error: `Hostname ${hostname} does not match ${expectedDomain}` };
                 this.cache.set(cacheKey, result);
                 return result;
             }
 
-            // Step 3: Forward DNS lookup (hostname -> IP) to verify
+            // Forward DNS: hostname -> IP (verification)
             const addresses = await dns.resolve4(hostname);
 
             if (!addresses.includes(ip)) {
-                const result = {
-                    verified: false,
-                    hostname,
-                    error: 'Forward DNS lookup does not match original IP'
-                };
+                const result = { verified: false, hostname, error: 'Forward DNS does not match original IP' };
                 this.cache.set(cacheKey, result);
                 return result;
             }
 
-            // Verification successful
-            const result = {
-                verified: true,
-                hostname,
-                error: null
-            };
+            const result = { verified: true, hostname, error: null };
             this.cache.set(cacheKey, result);
             return result;
 
         } catch (err) {
-            const result = {
-                verified: false,
-                hostname: null,
-                error: err.message
-            };
-            // Cache failures for shorter time (5 minutes)
+            const result = { verified: false, hostname: null, error: err.message };
             this.cache.set(cacheKey, result, 300000);
             return result;
         }
     }
 
-    /**
-     * Clear DNS cache
-     */
     clearCache() {
         this.cache.clear();
     }

package/utils/event-emitter.js

@@ -1,64 +1,32 @@
 // honeyweb-core/utils/event-emitter.js
-// Event system for extensibility
+// Events: trap:triggered, threat:detected, ip:banned, request:blocked, ai:analysis
 
 const { EventEmitter } = require('events');
 
-/**
- * HoneyWeb Event Emitter
- * Provides a centralized event system for middleware extensibility
- *
- * Events:
- * - 'trap:triggered' - { ip, path, timestamp }
- * - 'threat:detected' - { ip, threats, threatLevel, timestamp }
- * - 'ip:banned' - { ip, reason, timestamp }
- * - 'request:blocked' - { ip, reason, timestamp }
- * - 'ai:analysis' - { ip, report, timestamp }
- */
 class HoneyWebEvents extends EventEmitter {
     constructor() {
         super();
-        this.setMaxListeners(20); // Allow more listeners for extensibility
+        this.setMaxListeners(20);
     }
 
     emitTrapTriggered(ip, path) {
-        this.emit('trap:triggered', {
-            ip,
-            path,
-            timestamp: Date.now()
-        });
+        this.emit('trap:triggered', { ip, path, timestamp: Date.now() });
     }
 
     emitThreatDetected(ip, threats, threatLevel) {
-        this.emit('threat:detected', {
-            ip,
-            threats,
-            threatLevel,
-            timestamp: Date.now()
-        });
+        this.emit('threat:detected', { ip, threats, threatLevel, timestamp: Date.now() });
     }
 
     emitIpBanned(ip, reason) {
-        this.emit('ip:banned', {
-            ip,
-            reason,
-            timestamp: Date.now()
-        });
+        this.emit('ip:banned', { ip, reason, timestamp: Date.now() });
     }
 
     emitRequestBlocked(ip, reason) {
-        this.emit('request:blocked', {
-            ip,
-            reason,
-            timestamp: Date.now()
-        });
+        this.emit('request:blocked', { ip, reason, timestamp: Date.now() });
     }
 
     emitAiAnalysis(ip, report) {
-        this.emit('ai:analysis', {
-            ip,
-            report,
-            timestamp: Date.now()
-        });
+        this.emit('ai:analysis', { ip, report, timestamp: Date.now() });
     }
 }
 

package/utils/logger.js

@@ -1,12 +1,6 @@
 // honeyweb-core/utils/logger.js
-// Structured logging utility
 
-const LOG_LEVELS = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3
-};
+const LOG_LEVELS = { debug: 0, info: 1, warn: 2, error: 3 };
 
 class Logger {
     constructor(config = {}) {
@@ -23,48 +17,31 @@ class Logger {
         const timestamp = new Date().toISOString();
 
         if (this.format === 'json') {
-            return JSON.stringify({
-                timestamp,
-                level: level.toUpperCase(),
-                message,
-                ...meta
-            });
+            return JSON.stringify({ timestamp, level: level.toUpperCase(), message, ...meta });
         }
 
-        // Pretty format
-        const metaStr = Object.keys(meta).length > 0
-            ? ' ' + JSON.stringify(meta)
-            : '';
+        const metaStr = Object.keys(meta).length > 0 ? ' ' + JSON.stringify(meta) : '';
         return `${this.prefix} [${level.toUpperCase()}] ${message}${metaStr}`;
     }
 
     debug(message, meta) {
-        if (this._shouldLog('debug')) {
-            console.log(this._formatMessage('debug', message, meta));
-        }
+        if (this._shouldLog('debug')) console.log(this._formatMessage('debug', message, meta));
     }
 
     info(message, meta) {
-        if (this._shouldLog('info')) {
-            console.log(this._formatMessage('info', message, meta));
-        }
+        if (this._shouldLog('info')) console.log(this._formatMessage('info', message, meta));
     }
 
     warn(message, meta) {
-        if (this._shouldLog('warn')) {
-            console.warn(this._formatMessage('warn', message, meta));
-        }
+        if (this._shouldLog('warn')) console.warn(this._formatMessage('warn', message, meta));
     }
 
     error(message, meta) {
-        if (this._shouldLog('error')) {
-            console.error(this._formatMessage('error', message, meta));
-        }
+        if (this._shouldLog('error')) console.error(this._formatMessage('error', message, meta));
     }
 
-    // Convenience methods for common HoneyWeb events
     trapTriggered(ip, path) {
-        this.warn(`🚨 TRAP TRIGGERED by ${ip} on ${path}`, { ip, path, event: 'trap_triggered' });
+        this.warn(`TRAP TRIGGERED by ${ip} on ${path}`, { ip, path, event: 'trap_triggered' });
     }
 
     ipBanned(ip, reason) {
@@ -73,10 +50,7 @@ class Logger {
 
     threatDetected(ip, threats, level) {
         this.warn(`THREAT DETECTED from ${ip}: ${threats.join(', ')} (level: ${level})`, {
-            ip,
-            threats,
-            threatLevel: level,
-            event: 'threat_detected'
+            ip, threats, threatLevel: level, event: 'threat_detected'
         });
     }