honeyweb-core 2.0.3 → 2.0.4

package/storage/json-store.js

@@ -1,5 +1,4 @@
 // honeyweb-core/storage/json-store.js
-// Async JSON storage with in-memory cache
 
 const fs = require('fs-extra');
 const path = require('path');
@@ -8,18 +7,14 @@ const LRUCache = require('../utils/cache');
 class JsonStore {
     constructor(config) {
         this.filePath = path.resolve(config.path || './blocked-ips.json');
-        this.banDuration = config.banDuration || 86400000; // 24 hours
+        this.banDuration = config.banDuration || 86400000;
         this.autoCleanup = config.autoCleanup !== false;
-        this.cache = config.cache ? new LRUCache(1000, 60000) : null; // 1 minute cache
+        this.cache = config.cache ? new LRUCache(1000, 60000) : null;
 
-        // Initialize file
         this._initFile();
 
-        // Start auto-cleanup if enabled
         if (this.autoCleanup) {
-            this.cleanupInterval = setInterval(() => {
-                this._cleanupExpired();
-            }, 300000); // Clean up every 5 minutes
+            this.cleanupInterval = setInterval(() => this._cleanupExpired(), 300000);
         }
     }
 
@@ -33,24 +28,12 @@ class JsonStore {
         }
     }
 
-    /**
-     * Get all banned IPs
-     * @returns {Promise<Array>} - Array of banned IP objects
-     */
     async getAll() {
-        // Check cache first
-        if (this.cache && this.cache.has('all')) {
-            return this.cache.get('all');
-        }
+        if (this.cache && this.cache.has('all')) return this.cache.get('all');
 
         try {
             const data = await fs.readJson(this.filePath);
-
-            // Cache the result
-            if (this.cache) {
-                this.cache.set('all', data);
-            }
-
+            if (this.cache) this.cache.set('all', data);
             return data;
         } catch (err) {
             console.error('[JsonStore] Error reading file:', err);
@@ -58,24 +41,16 @@ class JsonStore {
         }
     }
 
-    /**
-     * Check if IP is banned
-     * @param {string} ip
-     * @returns {Promise<boolean>}
-     */
     async isBanned(ip) {
         const bannedIPs = await this.getAll();
 
-        // Support both simple array format and object format
         if (bannedIPs.length > 0 && typeof bannedIPs[0] === 'string') {
             return bannedIPs.includes(ip);
         }
 
-        // Object format with expiry
         const entry = bannedIPs.find(entry => entry.ip === ip);
         if (!entry) return false;
 
-        // Check if expired
         if (entry.expiry && Date.now() > entry.expiry) {
             await this.unban(ip);
             return false;
@@ -84,79 +59,47 @@ class JsonStore {
         return true;
     }
 
-    /**
-     * Ban an IP
-     * @param {string} ip
-     * @param {string} reason
-     * @returns {Promise<void>}
-     */
     async ban(ip, reason = 'Suspicious activity') {
         const bannedIPs = await this.getAll();
 
-        // Check if already banned
-        const existingIndex = bannedIPs.findIndex(entry =>
+        const exists = bannedIPs.some(entry =>
             typeof entry === 'string' ? entry === ip : entry.ip === ip
         );
+        if (exists) return;
 
-        if (existingIndex !== -1) {
-            return; // Already banned
-        }
-
-        // Add new ban with expiry
-        const banEntry = {
+        bannedIPs.push({
             ip,
             reason,
             timestamp: Date.now(),
             expiry: Date.now() + this.banDuration
-        };
-
-        bannedIPs.push(banEntry);
+        });
 
         await this._save(bannedIPs);
     }
 
-    /**
-     * Unban an IP
-     * @param {string} ip
-     * @returns {Promise<void>}
-     */
     async unban(ip) {
         const bannedIPs = await this.getAll();
-
         const filtered = bannedIPs.filter(entry =>
             typeof entry === 'string' ? entry !== ip : entry.ip !== ip
         );
-
         await this._save(filtered);
     }
 
-    /**
-     * Save data to file and invalidate cache
-     * @private
-     */
     async _save(data) {
         try {
             await fs.writeJson(this.filePath, data, { spaces: 2 });
-
-            // Invalidate cache
-            if (this.cache) {
-                this.cache.delete('all');
-            }
+            if (this.cache) this.cache.delete('all');
         } catch (err) {
             console.error('[JsonStore] Error writing file:', err);
         }
     }
 
-    /**
-     * Clean up expired bans
-     * @private
-     */
     async _cleanupExpired() {
         const bannedIPs = await this.getAll();
         const now = Date.now();
 
         const active = bannedIPs.filter(entry => {
-            if (typeof entry === 'string') return true; // Keep simple format
+            if (typeof entry === 'string') return true;
             return !entry.expiry || now <= entry.expiry;
         });
 
@@ -165,41 +108,24 @@ class JsonStore {
         }
     }
 
-    /**
-     * Get statistics
-     * @returns {Promise<Object>}
-     */
     async getStats() {
         const bannedIPs = await this.getAll();
         const now = Date.now();
-
-        let active = 0;
-        let expired = 0;
+        let active = 0, expired = 0;
 
         bannedIPs.forEach(entry => {
-            if (typeof entry === 'string') {
-                active++;
-            } else if (!entry.expiry || now <= entry.expiry) {
+            if (typeof entry === 'string' || !entry.expiry || now <= entry.expiry) {
                 active++;
             } else {
                 expired++;
             }
         });
 
-        return {
-            total: bannedIPs.length,
-            active,
-            expired
-        };
+        return { total: bannedIPs.length, active, expired };
     }
 
-    /**
-     * Cleanup and stop intervals
-     */
     destroy() {
-        if (this.cleanupInterval) {
-            clearInterval(this.cleanupInterval);
-        }
+        if (this.cleanupInterval) clearInterval(this.cleanupInterval);
     }
 }
 

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() });
     }
 }