@niksbanna/bot-detector 1.0.2 → 1.0.4

package/src/signals/behavior/InteractionTimingSignal.js

@@ -1,170 +0,0 @@
-/**
- * @fileoverview Detects suspicious interaction timing patterns.
- */
-
-import { Signal } from '../../core/Signal.js';
-
-/**
- * Measures timing between page load and first interaction.
- * Bots often interact too fast or with perfect timing patterns.
- */
-class InteractionTimingSignal extends Signal {
-  static id = 'interaction-timing';
-  static category = 'behavior';
-  static weight = 0.6;
-  static description = 'Detects suspicious interaction timing';
-  static requiresInteraction = true;
-
-  constructor(options = {}) {
-    super(options);
-    this._pageLoadTime = performance.now();
-    this._firstInteractionTime = null;
-    this._interactions = [];
-    this._isTracking = false;
-    this._trackingDuration = options.trackingDuration || 5000;
-    this._boundHandler = null;
-  }
-
-  /**
-   * Start tracking interactions.
-   */
-  startTracking() {
-    if (this._isTracking) return;
-    
-    this._interactions = [];
-    this._isTracking = true;
-    
-    const interactionEvents = ['click', 'mousedown', 'touchstart', 'keydown', 'scroll'];
-    
-    this._boundHandler = (e) => {
-      const now = performance.now();
-      if (this._firstInteractionTime === null) {
-        this._firstInteractionTime = now;
-      }
-      this._interactions.push({
-        type: e.type,
-        t: now,
-        timeSinceLoad: now - this._pageLoadTime,
-      });
-    };
-    
-    for (const event of interactionEvents) {
-      document.addEventListener(event, this._boundHandler, { passive: true, capture: true });
-    }
-  }
-
-  /**
-   * Stop tracking interactions.
-   */
-  stopTracking() {
-    if (!this._isTracking) return;
-    
-    this._isTracking = false;
-    const interactionEvents = ['click', 'mousedown', 'touchstart', 'keydown', 'scroll'];
-    
-    if (this._boundHandler) {
-      for (const event of interactionEvents) {
-        document.removeEventListener(event, this._boundHandler, { capture: true });
-      }
-      this._boundHandler = null;
-    }
-  }
-
-  async detect() {
-    const anomalies = [];
-    let confidence = 0;
-
-    // Start tracking if not already
-    if (!this._isTracking && this._interactions.length === 0) {
-      this.startTracking();
-      await new Promise(resolve => setTimeout(resolve, this._trackingDuration));
-      this.stopTracking();
-    }
-
-    const interactions = this._interactions;
-
-    // No interactions - not necessarily suspicious, could be passive viewing
-    if (interactions.length === 0) {
-      return this.createResult(false, { 
-        reason: 'no-interactions',
-      }, 0);
-    }
-
-    // Check time to first interaction
-    const firstInteraction = interactions[0];
-    
-    // Suspiciously fast first interaction (< 100ms after page load)
-    if (firstInteraction.timeSinceLoad < 100) {
-      anomalies.push('instant-interaction');
-      confidence = Math.max(confidence, 0.9);
-    }
-    // Very fast interaction (< 300ms)
-    else if (firstInteraction.timeSinceLoad < 300) {
-      anomalies.push('very-fast-interaction');
-      confidence = Math.max(confidence, 0.6);
-    }
-
-    // Analyze interaction intervals
-    if (interactions.length > 3) {
-      const intervals = [];
-      for (let i = 1; i < interactions.length; i++) {
-        intervals.push(interactions[i].t - interactions[i - 1].t);
-      }
-
-      const avgInterval = intervals.reduce((a, b) => a + b, 0) / intervals.length;
-      const variance = intervals.reduce((acc, t) => 
-        acc + Math.pow(t - avgInterval, 2), 0) / intervals.length;
-
-      // Perfectly timed intervals (robotic)
-      if (variance < 10 && interactions.length > 5) {
-        anomalies.push('robotic-intervals');
-        confidence = Math.max(confidence, 0.8);
-      }
-
-      // Check for burst interactions (many in short time)
-      const burstThreshold = 50; // ms
-      let burstCount = 0;
-      for (const interval of intervals) {
-        if (interval < burstThreshold) burstCount++;
-      }
-      if (burstCount > intervals.length * 0.7) {
-        anomalies.push('burst-interactions');
-        confidence = Math.max(confidence, 0.7);
-      }
-    }
-
-    // Check interaction sequence (bots often follow predictable patterns)
-    const typeSequence = interactions.map(i => i.type).join(',');
-    
-    // Repeated identical sequences
-    if (interactions.length >= 6) {
-      const halfLength = Math.floor(interactions.length / 2);
-      const firstHalf = interactions.slice(0, halfLength).map(i => i.type).join(',');
-      const secondHalf = interactions.slice(halfLength, halfLength * 2).map(i => i.type).join(',');
-      
-      if (firstHalf === secondHalf && firstHalf.length > 0) {
-        anomalies.push('repeated-sequence');
-        confidence = Math.max(confidence, 0.6);
-      }
-    }
-
-    const triggered = anomalies.length > 0;
-
-    return this.createResult(triggered, {
-      anomalies,
-      interactionCount: interactions.length,
-      timeToFirstInteraction: firstInteraction.timeSinceLoad,
-      firstInteractionType: firstInteraction.type,
-    }, confidence);
-  }
-
-  reset() {
-    super.reset();
-    this.stopTracking();
-    this._pageLoadTime = performance.now();
-    this._firstInteractionTime = null;
-    this._interactions = [];
-  }
-}
-
-export { InteractionTimingSignal };

package/src/signals/behavior/KeyboardPatternSignal.js

@@ -1,235 +0,0 @@
-/**
- * @fileoverview Detects non-human keyboard input patterns.
- */
-
-import { Signal } from '../../core/Signal.js';
-
-/**
- * Analyzes keystroke timing patterns.
- * Bots often type with unnatural consistency or inhuman speeds.
- */
-class KeyboardPatternSignal extends Signal {
-  static id = 'keyboard-pattern';
-  static category = 'behavior';
-  static weight = 0.8;
-  static description = 'Detects non-human keystroke patterns';
-  static requiresInteraction = true;
-
-  constructor(options = {}) {
-    super(options);
-    this._keystrokes = [];
-    this._isTracking = false;
-    this._trackingDuration = options.trackingDuration || 5000;
-    this._minKeystrokes = options.minKeystrokes || 10;
-    this._boundKeydownHandler = null;
-    this._boundKeyupHandler = null;
-  }
-
-  /**
-   * Start tracking keyboard events.
-   */
-  startTracking() {
-    if (this._isTracking) return;
-    
-    this._keystrokes = [];
-    this._isTracking = true;
-    
-    this._boundKeydownHandler = (e) => {
-      this._keystrokes.push({
-        type: 'down',
-        key: e.key,
-        code: e.code,
-        t: performance.now(),
-      });
-    };
-
-    this._boundKeyupHandler = (e) => {
-      this._keystrokes.push({
-        type: 'up',
-        key: e.key,
-        code: e.code,
-        t: performance.now(),
-      });
-    };
-    
-    document.addEventListener('keydown', this._boundKeydownHandler, { passive: true });
-    document.addEventListener('keyup', this._boundKeyupHandler, { passive: true });
-  }
-
-  /**
-   * Stop tracking keyboard events.
-   */
-  stopTracking() {
-    if (!this._isTracking) return;
-    
-    this._isTracking = false;
-    if (this._boundKeydownHandler) {
-      document.removeEventListener('keydown', this._boundKeydownHandler);
-      this._boundKeydownHandler = null;
-    }
-    if (this._boundKeyupHandler) {
-      document.removeEventListener('keyup', this._boundKeyupHandler);
-      this._boundKeyupHandler = null;
-    }
-  }
-
-  async detect() {
-    const anomalies = [];
-    let confidence = 0;
-
-    // If no tracking has occurred, start it
-    if (this._keystrokes.length === 0) {
-      this.startTracking();
-      await new Promise(resolve => setTimeout(resolve, this._trackingDuration));
-      this.stopTracking();
-    }
-
-    const keystrokes = this._keystrokes;
-    const keydowns = keystrokes.filter(k => k.type === 'down');
-
-    // No keyboard activity
-    if (keydowns.length < this._minKeystrokes) {
-      // Not necessarily a bot - could just be no typing needed
-      return this.createResult(false, { 
-        reason: 'insufficient-data',
-        keystrokes: keydowns.length 
-      }, 0);
-    }
-
-    const analysis = this._analyzeKeystrokes(keystrokes);
-
-    // Check for inhuman typing speed (> 20 chars/second sustained)
-    if (analysis.avgInterKeystrokeTime < 50 && keydowns.length > 20) {
-      anomalies.push('inhuman-speed');
-      confidence = Math.max(confidence, 0.9);
-    }
-
-    // Check for too-consistent timing (robotic)
-    if (analysis.timingVariance < 5 && keydowns.length > 15) {
-      anomalies.push('robotic-timing');
-      confidence = Math.max(confidence, 0.8);
-    }
-
-    // Check for missing key-up events (programmatic input)
-    if (analysis.missingKeyups > keydowns.length * 0.5) {
-      anomalies.push('missing-keyups');
-      confidence = Math.max(confidence, 0.7);
-    }
-
-    // Check for perfect key hold times
-    if (analysis.holdTimeVariance < 2 && analysis.holdTimes.length > 10) {
-      anomalies.push('constant-hold-time');
-      confidence = Math.max(confidence, 0.6);
-    }
-
-    // Check for sequential key codes (batch input)
-    if (analysis.sequentialKeys > keydowns.length * 0.8 && keydowns.length > 10) {
-      anomalies.push('sequential-input');
-      confidence = Math.max(confidence, 0.5);
-    }
-
-    // Check for no typing rhythm variation
-    if (analysis.rhythmScore < 0.1 && keydowns.length > 20) {
-      anomalies.push('no-rhythm-variation');
-      confidence = Math.max(confidence, 0.6);
-    }
-
-    const triggered = anomalies.length > 0;
-
-    return this.createResult(triggered, {
-      anomalies,
-      keystrokeCount: keydowns.length,
-      analysis,
-    }, confidence);
-  }
-
-  /**
-   * Analyze keystroke patterns.
-   * @param {Array} keystrokes - Array of keystroke events
-   * @returns {Object} Analysis results
-   */
-  _analyzeKeystrokes(keystrokes) {
-    const keydowns = keystrokes.filter(k => k.type === 'down');
-    const keyups = keystrokes.filter(k => k.type === 'up');
-
-    if (keydowns.length < 2) {
-      return {
-        avgInterKeystrokeTime: Infinity,
-        timingVariance: Infinity,
-        missingKeyups: 0,
-        holdTimeVariance: Infinity,
-        holdTimes: [],
-        sequentialKeys: 0,
-        rhythmScore: 1,
-      };
-    }
-
-    // Calculate inter-keystroke times
-    const interTimes = [];
-    for (let i = 1; i < keydowns.length; i++) {
-      interTimes.push(keydowns[i].t - keydowns[i - 1].t);
-    }
-
-    const avgInterKeystrokeTime = interTimes.reduce((a, b) => a + b, 0) / interTimes.length;
-    const timingVariance = interTimes.reduce((acc, t) => 
-      acc + Math.pow(t - avgInterKeystrokeTime, 2), 0) / interTimes.length;
-
-    // Calculate hold times (time between keydown and keyup for same key)
-    const holdTimes = [];
-    for (const down of keydowns) {
-      const up = keyups.find(u => u.key === down.key && u.t > down.t);
-      if (up) {
-        holdTimes.push(up.t - down.t);
-      }
-    }
-
-    const avgHoldTime = holdTimes.length > 0 
-      ? holdTimes.reduce((a, b) => a + b, 0) / holdTimes.length 
-      : 0;
-    const holdTimeVariance = holdTimes.length > 0
-      ? holdTimes.reduce((acc, t) => acc + Math.pow(t - avgHoldTime, 2), 0) / holdTimes.length
-      : Infinity;
-
-    // Count missing keyups
-    const missingKeyups = keydowns.length - holdTimes.length;
-
-    // Count sequential keys (chars typed in order, like 'abc' or '123')
-    let sequentialKeys = 0;
-    for (let i = 1; i < keydowns.length; i++) {
-      const prevCode = keydowns[i - 1].key.charCodeAt(0);
-      const currCode = keydowns[i].key.charCodeAt(0);
-      if (Math.abs(currCode - prevCode) === 1) {
-        sequentialKeys++;
-      }
-    }
-
-    // Calculate typing rhythm score (variation in timing patterns)
-    // Humans have natural rhythm variations (pause after words, faster for common patterns)
-    let rhythmScore = 0;
-    if (interTimes.length > 5) {
-      const sortedTimes = [...interTimes].sort((a, b) => a - b);
-      const median = sortedTimes[Math.floor(sortedTimes.length / 2)];
-      // Count how many timings deviate significantly from median
-      const deviations = interTimes.filter(t => Math.abs(t - median) > median * 0.3).length;
-      rhythmScore = deviations / interTimes.length;
-    }
-
-    return {
-      avgInterKeystrokeTime,
-      timingVariance,
-      missingKeyups,
-      holdTimeVariance,
-      holdTimes,
-      sequentialKeys,
-      rhythmScore,
-    };
-  }
-
-  reset() {
-    super.reset();
-    this.stopTracking();
-    this._keystrokes = [];
-  }
-}
-
-export { KeyboardPatternSignal };

package/src/signals/behavior/MouseMovementSignal.js

@@ -1,215 +0,0 @@
-/**
- * @fileoverview Detects non-human mouse movement patterns.
- */
-
-import { Signal } from '../../core/Signal.js';
-
-/**
- * Tracks and analyzes mouse movement patterns.
- * Bots often have perfectly linear paths, no movement, or teleportation.
- */
-class MouseMovementSignal extends Signal {
-  static id = 'mouse-movement';
-  static category = 'behavior';
-  static weight = 0.9;
-  static description = 'Detects non-human mouse movement patterns';
-  static requiresInteraction = true;
-
-  constructor(options = {}) {
-    super(options);
-    this._movements = [];
-    this._isTracking = false;
-    this._trackingDuration = options.trackingDuration || 3000; // Default 3 seconds
-    this._minMovements = options.minMovements || 5;
-    this._boundHandler = null;
-  }
-
-  /**
-   * Start tracking mouse movements.
-   * @returns {Promise<void>}
-   */
-  startTracking() {
-    if (this._isTracking) return;
-    
-    this._movements = [];
-    this._isTracking = true;
-    
-    this._boundHandler = (e) => {
-      this._movements.push({
-        x: e.clientX,
-        y: e.clientY,
-        t: performance.now(),
-      });
-    };
-    
-    document.addEventListener('mousemove', this._boundHandler, { passive: true });
-  }
-
-  /**
-   * Stop tracking mouse movements.
-   */
-  stopTracking() {
-    if (!this._isTracking) return;
-    
-    this._isTracking = false;
-    if (this._boundHandler) {
-      document.removeEventListener('mousemove', this._boundHandler);
-      this._boundHandler = null;
-    }
-  }
-
-  async detect() {
-    const anomalies = [];
-    let confidence = 0;
-
-    // If no tracking has occurred, check if we have movement data
-    if (this._movements.length === 0) {
-      // Start tracking for a period, then analyze
-      this.startTracking();
-      
-      await new Promise(resolve => setTimeout(resolve, this._trackingDuration));
-      
-      this.stopTracking();
-    }
-
-    const movements = this._movements;
-
-    // No mouse movements detected
-    if (movements.length < this._minMovements) {
-      anomalies.push('no-mouse-movement');
-      confidence = Math.max(confidence, 0.6);
-      return this.createResult(true, { anomalies, movements: movements.length }, confidence);
-    }
-
-    // Analyze movement patterns
-    const analysis = this._analyzeMovements(movements);
-
-    // Check for teleportation (large instant jumps)
-    if (analysis.teleportCount > 0) {
-      anomalies.push('mouse-teleportation');
-      confidence = Math.max(confidence, 0.7);
-    }
-
-    // Check for perfect linear paths
-    if (analysis.linearPathRatio > 0.9) {
-      anomalies.push('linear-path');
-      confidence = Math.max(confidence, 0.8);
-    }
-
-    // Check for constant velocity (too perfect)
-    if (analysis.velocityVariance < 0.01 && movements.length > 10) {
-      anomalies.push('constant-velocity');
-      confidence = Math.max(confidence, 0.7);
-    }
-
-    // Check for zero acceleration changes
-    if (analysis.accelerationChanges === 0 && movements.length > 10) {
-      anomalies.push('no-acceleration-variance');
-      confidence = Math.max(confidence, 0.6);
-    }
-
-    // Check for robotic timing (perfect intervals)
-    if (analysis.timingVariance < 1 && movements.length > 10) {
-      anomalies.push('robotic-timing');
-      confidence = Math.max(confidence, 0.8);
-    }
-
-    const triggered = anomalies.length > 0;
-
-    return this.createResult(triggered, {
-      anomalies,
-      movementCount: movements.length,
-      analysis,
-    }, confidence);
-  }
-
-  /**
-   * Analyze movement patterns for anomalies.
-   * @param {Array} movements - Array of movement points
-   * @returns {Object} Analysis results
-   */
-  _analyzeMovements(movements) {
-    if (movements.length < 3) {
-      return {
-        teleportCount: 0,
-        linearPathRatio: 0,
-        velocityVariance: 0,
-        accelerationChanges: 0,
-        timingVariance: 0,
-      };
-    }
-
-    let teleportCount = 0;
-    const velocities = [];
-    const angles = [];
-    const timeIntervals = [];
-
-    for (let i = 1; i < movements.length; i++) {
-      const prev = movements[i - 1];
-      const curr = movements[i];
-      
-      const dx = curr.x - prev.x;
-      const dy = curr.y - prev.y;
-      const dt = curr.t - prev.t;
-      
-      if (dt === 0) continue;
-      
-      const distance = Math.sqrt(dx * dx + dy * dy);
-      const velocity = distance / dt;
-      
-      velocities.push(velocity);
-      angles.push(Math.atan2(dy, dx));
-      timeIntervals.push(dt);
-
-      // Teleportation: large jump in very short time
-      if (distance > 300 && dt < 10) {
-        teleportCount++;
-      }
-    }
-
-    // Calculate velocity variance
-    const avgVelocity = velocities.reduce((a, b) => a + b, 0) / velocities.length;
-    const velocityVariance = velocities.reduce((acc, v) => 
-      acc + Math.pow(v - avgVelocity, 2), 0) / velocities.length;
-
-    // Calculate angle consistency (linear path detection)
-    let angleConsistency = 0;
-    if (angles.length > 1) {
-      let consistentAngles = 0;
-      for (let i = 1; i < angles.length; i++) {
-        const angleDiff = Math.abs(angles[i] - angles[i - 1]);
-        if (angleDiff < 0.1) consistentAngles++;
-      }
-      angleConsistency = consistentAngles / (angles.length - 1);
-    }
-
-    // Calculate timing variance
-    const avgInterval = timeIntervals.reduce((a, b) => a + b, 0) / timeIntervals.length;
-    const timingVariance = timeIntervals.reduce((acc, t) => 
-      acc + Math.pow(t - avgInterval, 2), 0) / timeIntervals.length;
-
-    // Count acceleration changes
-    let accelerationChanges = 0;
-    for (let i = 1; i < velocities.length; i++) {
-      if ((velocities[i] - velocities[i - 1]) * (velocities[i - 1] - (velocities[i - 2] || 0)) < 0) {
-        accelerationChanges++;
-      }
-    }
-
-    return {
-      teleportCount,
-      linearPathRatio: angleConsistency,
-      velocityVariance,
-      accelerationChanges,
-      timingVariance,
-    };
-  }
-
-  reset() {
-    super.reset();
-    this.stopTracking();
-    this._movements = [];
-  }
-}
-
-export { MouseMovementSignal };