@push.rocks/smartproxy 20.0.1 → 21.1.0

package/ts/detection/utils/buffer-utils.ts

@@ -0,0 +1,141 @@
+/**
+ * Buffer manipulation utilities for protocol detection
+ */
+
+// Import from protocols
+import { HttpParser } from '../../protocols/http/index.js';
+
+/**
+ * BufferAccumulator class for handling fragmented data
+ */
+export class BufferAccumulator {
+  private chunks: Buffer[] = [];
+  private totalLength = 0;
+  
+  /**
+   * Append data to the accumulator
+   */
+  append(data: Buffer): void {
+    this.chunks.push(data);
+    this.totalLength += data.length;
+  }
+  
+  /**
+   * Get the accumulated buffer
+   */
+  getBuffer(): Buffer {
+    if (this.chunks.length === 0) {
+      return Buffer.alloc(0);
+    }
+    if (this.chunks.length === 1) {
+      return this.chunks[0];
+    }
+    return Buffer.concat(this.chunks, this.totalLength);
+  }
+  
+  /**
+   * Get current buffer length
+   */
+  length(): number {
+    return this.totalLength;
+  }
+  
+  /**
+   * Clear all accumulated data
+   */
+  clear(): void {
+    this.chunks = [];
+    this.totalLength = 0;
+  }
+  
+  /**
+   * Check if accumulator has minimum bytes
+   */
+  hasMinimumBytes(minBytes: number): boolean {
+    return this.totalLength >= minBytes;
+  }
+}
+
+/**
+ * Read a big-endian 16-bit integer from buffer
+ */
+export function readUInt16BE(buffer: Buffer, offset: number): number {
+  if (offset + 2 > buffer.length) {
+    throw new Error('Buffer too short for UInt16BE read');
+  }
+  return (buffer[offset] << 8) | buffer[offset + 1];
+}
+
+/**
+ * Read a big-endian 24-bit integer from buffer
+ */
+export function readUInt24BE(buffer: Buffer, offset: number): number {
+  if (offset + 3 > buffer.length) {
+    throw new Error('Buffer too short for UInt24BE read');
+  }
+  return (buffer[offset] << 16) | (buffer[offset + 1] << 8) | buffer[offset + 2];
+}
+
+/**
+ * Find a byte sequence in a buffer
+ */
+export function findSequence(buffer: Buffer, sequence: Buffer, startOffset = 0): number {
+  if (sequence.length === 0) {
+    return startOffset;
+  }
+  
+  const searchLength = buffer.length - sequence.length + 1;
+  for (let i = startOffset; i < searchLength; i++) {
+    let found = true;
+    for (let j = 0; j < sequence.length; j++) {
+      if (buffer[i + j] !== sequence[j]) {
+        found = false;
+        break;
+      }
+    }
+    if (found) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+/**
+ * Extract a line from buffer (up to CRLF or LF)
+ */
+export function extractLine(buffer: Buffer, startOffset = 0): { line: string; nextOffset: number } | null {
+  // Delegate to protocol parser
+  return HttpParser.extractLine(buffer, startOffset);
+}
+
+/**
+ * Check if buffer starts with a string (case-insensitive)
+ */
+export function startsWithString(buffer: Buffer, str: string, offset = 0): boolean {
+  if (offset + str.length > buffer.length) {
+    return false;
+  }
+  
+  const bufferStr = buffer.slice(offset, offset + str.length).toString('utf8');
+  return bufferStr.toLowerCase() === str.toLowerCase();
+}
+
+/**
+ * Safe buffer slice that doesn't throw on out-of-bounds
+ */
+export function safeSlice(buffer: Buffer, start: number, end?: number): Buffer {
+  const safeStart = Math.max(0, Math.min(start, buffer.length));
+  const safeEnd = end === undefined 
+    ? buffer.length 
+    : Math.max(safeStart, Math.min(end, buffer.length));
+    
+  return buffer.slice(safeStart, safeEnd);
+}
+
+/**
+ * Check if buffer contains printable ASCII
+ */
+export function isPrintableAscii(buffer: Buffer, length?: number): boolean {
+  // Delegate to protocol parser
+  return HttpParser.isPrintableAscii(buffer, length);
+}

package/ts/detection/utils/fragment-manager.ts

@@ -0,0 +1,64 @@
+/**
+ * Fragment Manager for Detection Module
+ * 
+ * Manages fragmented protocol data using the shared fragment handler
+ */
+
+import { FragmentHandler, type IFragmentOptions } from '../../protocols/common/fragment-handler.js';
+import type { IConnectionContext } from '../../protocols/common/types.js';
+
+/**
+ * Detection-specific fragment manager
+ */
+export class DetectionFragmentManager {
+  private tlsFragments: FragmentHandler;
+  private httpFragments: FragmentHandler;
+  
+  constructor() {
+    // Configure fragment handlers with appropriate limits
+    const tlsOptions: IFragmentOptions = {
+      maxBufferSize: 16384,  // TLS record max size
+      timeout: 5000,
+      cleanupInterval: 30000
+    };
+    
+    const httpOptions: IFragmentOptions = {
+      maxBufferSize: 8192,   // HTTP header reasonable limit
+      timeout: 5000,
+      cleanupInterval: 30000
+    };
+    
+    this.tlsFragments = new FragmentHandler(tlsOptions);
+    this.httpFragments = new FragmentHandler(httpOptions);
+  }
+  
+  /**
+   * Get fragment handler for protocol type
+   */
+  getHandler(protocol: 'tls' | 'http'): FragmentHandler {
+    return protocol === 'tls' ? this.tlsFragments : this.httpFragments;
+  }
+  
+  /**
+   * Create connection ID from context
+   */
+  static createConnectionId(context: IConnectionContext): string {
+    return context.id || `${context.sourceIp}:${context.sourcePort}-${context.destIp}:${context.destPort}`;
+  }
+  
+  /**
+   * Clean up all handlers
+   */
+  cleanup(): void {
+    this.tlsFragments.cleanup();
+    this.httpFragments.cleanup();
+  }
+  
+  /**
+   * Destroy all handlers
+   */
+  destroy(): void {
+    this.tlsFragments.destroy();
+    this.httpFragments.destroy();
+  }
+}

package/ts/detection/utils/parser-utils.ts

@@ -0,0 +1,77 @@
+/**
+ * Parser utilities for protocol detection
+ * Now delegates to protocol modules for actual parsing
+ */
+
+import type { THttpMethod, TTlsVersion } from '../models/detection-types.js';
+import { HttpParser, HTTP_METHODS, HTTP_VERSIONS } from '../../protocols/http/index.js';
+import { tlsVersionToString as protocolTlsVersionToString } from '../../protocols/tls/index.js';
+
+// Re-export constants for backward compatibility
+export { HTTP_METHODS, HTTP_VERSIONS };
+
+/**
+ * Parse HTTP request line
+ */
+export function parseHttpRequestLine(line: string): {
+  method: THttpMethod;
+  path: string;
+  version: string;
+} | null {
+  // Delegate to protocol parser
+  const result = HttpParser.parseRequestLine(line);
+  return result ? {
+    method: result.method as THttpMethod,
+    path: result.path,
+    version: result.version
+  } : null;
+}
+
+/**
+ * Parse HTTP header line
+ */
+export function parseHttpHeader(line: string): { name: string; value: string } | null {
+  // Delegate to protocol parser
+  return HttpParser.parseHeaderLine(line);
+}
+
+/**
+ * Parse HTTP headers from lines
+ */
+export function parseHttpHeaders(lines: string[]): Record<string, string> {
+  // Delegate to protocol parser
+  return HttpParser.parseHeaders(lines);
+}
+
+/**
+ * Convert TLS version bytes to version string
+ */
+export function tlsVersionToString(major: number, minor: number): TTlsVersion | null {
+  // Delegate to protocol parser
+  return protocolTlsVersionToString(major, minor) as TTlsVersion;
+}
+
+/**
+ * Extract domain from Host header value
+ */
+export function extractDomainFromHost(hostHeader: string): string {
+  // Delegate to protocol parser
+  return HttpParser.extractDomainFromHost(hostHeader);
+}
+
+/**
+ * Validate domain name
+ */
+export function isValidDomain(domain: string): boolean {
+  // Delegate to protocol parser
+  return HttpParser.isValidDomain(domain);
+}
+
+/**
+ * Check if string is a valid HTTP method
+ */
+export function isHttpMethod(str: string): str is THttpMethod {
+  // Delegate to protocol parser
+  return HttpParser.isHttpMethod(str) && (str as THttpMethod) !== undefined;
+}
+

package/ts/index.ts

@@ -32,7 +32,8 @@ export * from './core/models/common-types.js';
 export type { IAcmeOptions } from './proxies/smart-proxy/models/interfaces.js';
 
 // Modular exports for new architecture
-export * as forwarding from './forwarding/index.js';
 // Certificate module has been removed - use SmartCertManager instead
 export * as tls from './tls/index.js';
-export * as routing from './routing/index.js';
+export * as routing from './routing/index.js';
+export * as detection from './detection/index.js';
+export * as protocols from './protocols/index.js';

package/ts/protocols/common/fragment-handler.ts

@@ -0,0 +1,163 @@
+/**
+ * Shared Fragment Handler for Protocol Detection
+ * 
+ * Provides unified fragment buffering and reassembly for protocols
+ * that may span multiple TCP packets.
+ */
+
+import { Buffer } from 'buffer';
+
+/**
+ * Fragment tracking information
+ */
+export interface IFragmentInfo {
+  buffer: Buffer;
+  timestamp: number;
+  connectionId: string;
+}
+
+/**
+ * Options for fragment handling
+ */
+export interface IFragmentOptions {
+  maxBufferSize?: number;
+  timeout?: number;
+  cleanupInterval?: number;
+}
+
+/**
+ * Result of fragment processing
+ */
+export interface IFragmentResult {
+  isComplete: boolean;
+  buffer?: Buffer;
+  needsMoreData: boolean;
+  error?: string;
+}
+
+/**
+ * Shared fragment handler for protocol detection
+ */
+export class FragmentHandler {
+  private fragments = new Map<string, IFragmentInfo>();
+  private cleanupTimer?: NodeJS.Timeout;
+  
+  constructor(private options: IFragmentOptions = {}) {
+    // Start cleanup timer if not already running
+    if (options.cleanupInterval && !this.cleanupTimer) {
+      this.cleanupTimer = setInterval(
+        () => this.cleanup(),
+        options.cleanupInterval
+      );
+    }
+  }
+  
+  /**
+   * Add a fragment for a connection
+   */
+  addFragment(connectionId: string, fragment: Buffer): IFragmentResult {
+    const existing = this.fragments.get(connectionId);
+    
+    if (existing) {
+      // Append to existing buffer
+      const newBuffer = Buffer.concat([existing.buffer, fragment]);
+      
+      // Check size limit
+      const maxSize = this.options.maxBufferSize || 65536;
+      if (newBuffer.length > maxSize) {
+        this.fragments.delete(connectionId);
+        return {
+          isComplete: false,
+          needsMoreData: false,
+          error: 'Buffer size exceeded maximum allowed'
+        };
+      }
+      
+      // Update fragment info
+      this.fragments.set(connectionId, {
+        buffer: newBuffer,
+        timestamp: Date.now(),
+        connectionId
+      });
+      
+      return {
+        isComplete: false,
+        buffer: newBuffer,
+        needsMoreData: true
+      };
+    } else {
+      // New fragment
+      this.fragments.set(connectionId, {
+        buffer: fragment,
+        timestamp: Date.now(),
+        connectionId
+      });
+      
+      return {
+        isComplete: false,
+        buffer: fragment,
+        needsMoreData: true
+      };
+    }
+  }
+  
+  /**
+   * Get the current buffer for a connection
+   */
+  getBuffer(connectionId: string): Buffer | undefined {
+    return this.fragments.get(connectionId)?.buffer;
+  }
+  
+  /**
+   * Mark a connection as complete and clean up
+   */
+  complete(connectionId: string): void {
+    this.fragments.delete(connectionId);
+  }
+  
+  /**
+   * Check if we're tracking a connection
+   */
+  hasConnection(connectionId: string): boolean {
+    return this.fragments.has(connectionId);
+  }
+  
+  /**
+   * Clean up expired fragments
+   */
+  cleanup(): void {
+    const now = Date.now();
+    const timeout = this.options.timeout || 5000;
+    
+    for (const [connectionId, info] of this.fragments.entries()) {
+      if (now - info.timestamp > timeout) {
+        this.fragments.delete(connectionId);
+      }
+    }
+  }
+  
+  /**
+   * Clear all fragments
+   */
+  clear(): void {
+    this.fragments.clear();
+  }
+  
+  /**
+   * Destroy the handler and clean up resources
+   */
+  destroy(): void {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = undefined;
+    }
+    this.clear();
+  }
+  
+  /**
+   * Get the number of tracked connections
+   */
+  get size(): number {
+    return this.fragments.size;
+  }
+}

package/ts/protocols/common/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Common Protocol Infrastructure
+ * 
+ * Shared utilities and types for protocol handling
+ */
+
+export * from './fragment-handler.js';
+export * from './types.js';

package/ts/protocols/common/types.ts

@@ -0,0 +1,76 @@
+/**
+ * Common Protocol Types
+ * 
+ * Shared types used across different protocol implementations
+ */
+
+/**
+ * Supported protocol types
+ */
+export type TProtocolType = 'tls' | 'http' | 'https' | 'websocket' | 'unknown';
+
+/**
+ * Protocol detection result
+ */
+export interface IProtocolDetectionResult {
+  protocol: TProtocolType;
+  confidence: number; // 0-100
+  requiresMoreData?: boolean;
+  metadata?: {
+    version?: string;
+    method?: string;
+    [key: string]: any;
+  };
+}
+
+/**
+ * Routing information extracted from protocols
+ */
+export interface IRoutingInfo {
+  domain?: string;
+  port?: number;
+  path?: string;
+  protocol: TProtocolType;
+}
+
+/**
+ * Connection context for protocol operations
+ */
+export interface IConnectionContext {
+  id: string;
+  sourceIp?: string;
+  sourcePort?: number;
+  destIp?: string;
+  destPort?: number;
+  timestamp?: number;
+}
+
+/**
+ * Protocol detection options
+ */
+export interface IProtocolDetectionOptions {
+  quickMode?: boolean;        // Only do minimal detection
+  extractRouting?: boolean;   // Extract routing information
+  maxWaitTime?: number;       // Max time to wait for complete data
+  maxBufferSize?: number;     // Max buffer size for fragmented data
+}
+
+/**
+ * Base interface for protocol detectors
+ */
+export interface IProtocolDetector {
+  /**
+   * Check if this detector can handle the data
+   */
+  canHandle(data: Buffer): boolean;
+  
+  /**
+   * Perform quick detection (first few bytes only)
+   */
+  quickDetect(data: Buffer): IProtocolDetectionResult;
+  
+  /**
+   * Extract routing information if possible
+   */
+  extractRouting?(data: Buffer, context?: IConnectionContext): IRoutingInfo | null;
+}