@push.rocks/smartproxy 12.0.0 → 13.1.2

package/ts/certificate/storage/file-storage.ts

@@ -0,0 +1,234 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as plugins from '../../plugins.js';
+import type { ICertificateData, ICertificates } from '../models/certificate-types.js';
+import { ensureCertificateDirectory } from '../utils/certificate-helpers.js';
+
+/**
+ * FileStorage provides file system storage for certificates
+ */
+export class FileStorage {
+  private storageDir: string;
+  
+  /**
+   * Creates a new file storage provider
+   * @param storageDir Directory to store certificates
+   */
+  constructor(storageDir: string) {
+    this.storageDir = path.resolve(storageDir);
+    ensureCertificateDirectory(this.storageDir);
+  }
+  
+  /**
+   * Save a certificate to the file system
+   * @param domain Domain name
+   * @param certData Certificate data to save
+   */
+  public async saveCertificate(domain: string, certData: ICertificateData): Promise<void> {
+    const sanitizedDomain = this.sanitizeDomain(domain);
+    const certDir = path.join(this.storageDir, sanitizedDomain);
+    ensureCertificateDirectory(certDir);
+    
+    const certPath = path.join(certDir, 'fullchain.pem');
+    const keyPath = path.join(certDir, 'privkey.pem');
+    const metaPath = path.join(certDir, 'metadata.json');
+    
+    // Write certificate and private key
+    await fs.promises.writeFile(certPath, certData.certificate, 'utf8');
+    await fs.promises.writeFile(keyPath, certData.privateKey, 'utf8');
+    
+    // Write metadata
+    const metadata = {
+      domain: certData.domain,
+      expiryDate: certData.expiryDate.toISOString(),
+      source: certData.source || 'unknown',
+      issuedAt: new Date().toISOString()
+    };
+    
+    await fs.promises.writeFile(
+      metaPath, 
+      JSON.stringify(metadata, null, 2), 
+      'utf8'
+    );
+  }
+  
+  /**
+   * Load a certificate from the file system
+   * @param domain Domain name
+   * @returns Certificate data if found, null otherwise
+   */
+  public async loadCertificate(domain: string): Promise<ICertificateData | null> {
+    const sanitizedDomain = this.sanitizeDomain(domain);
+    const certDir = path.join(this.storageDir, sanitizedDomain);
+    
+    if (!fs.existsSync(certDir)) {
+      return null;
+    }
+    
+    const certPath = path.join(certDir, 'fullchain.pem');
+    const keyPath = path.join(certDir, 'privkey.pem');
+    const metaPath = path.join(certDir, 'metadata.json');
+    
+    try {
+      // Check if all required files exist
+      if (!fs.existsSync(certPath) || !fs.existsSync(keyPath)) {
+        return null;
+      }
+      
+      // Read certificate and private key
+      const certificate = await fs.promises.readFile(certPath, 'utf8');
+      const privateKey = await fs.promises.readFile(keyPath, 'utf8');
+      
+      // Try to read metadata if available
+      let expiryDate = new Date();
+      let source: 'static' | 'http01' | 'dns01' | undefined;
+      
+      if (fs.existsSync(metaPath)) {
+        const metaContent = await fs.promises.readFile(metaPath, 'utf8');
+        const metadata = JSON.parse(metaContent);
+        
+        if (metadata.expiryDate) {
+          expiryDate = new Date(metadata.expiryDate);
+        }
+        
+        if (metadata.source) {
+          source = metadata.source as 'static' | 'http01' | 'dns01';
+        }
+      }
+      
+      return {
+        domain,
+        certificate,
+        privateKey,
+        expiryDate,
+        source
+      };
+    } catch (error) {
+      console.error(`Error loading certificate for ${domain}:`, error);
+      return null;
+    }
+  }
+  
+  /**
+   * Delete a certificate from the file system
+   * @param domain Domain name
+   */
+  public async deleteCertificate(domain: string): Promise<boolean> {
+    const sanitizedDomain = this.sanitizeDomain(domain);
+    const certDir = path.join(this.storageDir, sanitizedDomain);
+    
+    if (!fs.existsSync(certDir)) {
+      return false;
+    }
+    
+    try {
+      // Recursively delete the certificate directory
+      await this.deleteDirectory(certDir);
+      return true;
+    } catch (error) {
+      console.error(`Error deleting certificate for ${domain}:`, error);
+      return false;
+    }
+  }
+  
+  /**
+   * List all domains with stored certificates
+   * @returns Array of domain names
+   */
+  public async listCertificates(): Promise<string[]> {
+    try {
+      const entries = await fs.promises.readdir(this.storageDir, { withFileTypes: true });
+      return entries
+        .filter(entry => entry.isDirectory())
+        .map(entry => entry.name);
+    } catch (error) {
+      console.error('Error listing certificates:', error);
+      return [];
+    }
+  }
+  
+  /**
+   * Check if a certificate is expiring soon
+   * @param domain Domain name
+   * @param thresholdDays Days threshold to consider expiring
+   * @returns Information about expiring certificate or null
+   */
+  public async isExpiringSoon(
+    domain: string, 
+    thresholdDays: number = 30
+  ): Promise<{ domain: string; expiryDate: Date; daysRemaining: number } | null> {
+    const certData = await this.loadCertificate(domain);
+    
+    if (!certData) {
+      return null;
+    }
+    
+    const now = new Date();
+    const expiryDate = certData.expiryDate;
+    const timeRemaining = expiryDate.getTime() - now.getTime();
+    const daysRemaining = Math.floor(timeRemaining / (1000 * 60 * 60 * 24));
+    
+    if (daysRemaining <= thresholdDays) {
+      return {
+        domain,
+        expiryDate,
+        daysRemaining
+      };
+    }
+    
+    return null;
+  }
+  
+  /**
+   * Check all certificates for expiration
+   * @param thresholdDays Days threshold to consider expiring
+   * @returns List of expiring certificates
+   */
+  public async getExpiringCertificates(
+    thresholdDays: number = 30
+  ): Promise<Array<{ domain: string; expiryDate: Date; daysRemaining: number }>> {
+    const domains = await this.listCertificates();
+    const expiringCerts = [];
+    
+    for (const domain of domains) {
+      const expiring = await this.isExpiringSoon(domain, thresholdDays);
+      if (expiring) {
+        expiringCerts.push(expiring);
+      }
+    }
+    
+    return expiringCerts;
+  }
+  
+  /**
+   * Delete a directory recursively
+   * @param directoryPath Directory to delete
+   */
+  private async deleteDirectory(directoryPath: string): Promise<void> {
+    if (fs.existsSync(directoryPath)) {
+      const entries = await fs.promises.readdir(directoryPath, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(directoryPath, entry.name);
+        
+        if (entry.isDirectory()) {
+          await this.deleteDirectory(fullPath);
+        } else {
+          await fs.promises.unlink(fullPath);
+        }
+      }
+      
+      await fs.promises.rmdir(directoryPath);
+    }
+  }
+  
+  /**
+   * Sanitize a domain name for use as a directory name
+   * @param domain Domain name
+   * @returns Sanitized domain name
+   */
+  private sanitizeDomain(domain: string): string {
+    // Replace wildcard and any invalid filesystem characters
+    return domain.replace(/\*/g, '_wildcard_').replace(/[/\\:*?"<>|]/g, '_');
+  }
+}

package/ts/certificate/storage/index.ts

@@ -0,0 +1,3 @@
+/**
+ * Certificate storage mechanisms
+ */

package/ts/certificate/utils/certificate-helpers.ts

@@ -0,0 +1,50 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import type { ICertificates } from '../models/certificate-types.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Loads the default SSL certificates from the assets directory
+ * @returns The certificate key pair
+ */
+export function loadDefaultCertificates(): ICertificates {
+  try {
+    // Need to adjust path from /ts/certificate/utils to /assets/certs
+    const certPath = path.join(__dirname, '..', '..', '..', 'assets', 'certs');
+    const privateKey = fs.readFileSync(path.join(certPath, 'key.pem'), 'utf8');
+    const publicKey = fs.readFileSync(path.join(certPath, 'cert.pem'), 'utf8');
+
+    if (!privateKey || !publicKey) {
+      throw new Error('Failed to load default certificates');
+    }
+
+    return {
+      privateKey,
+      publicKey
+    };
+  } catch (error) {
+    console.error('Error loading default certificates:', error);
+    throw error;
+  }
+}
+
+/**
+ * Checks if a certificate file exists at the specified path
+ * @param certPath Path to check for certificate
+ * @returns True if the certificate exists, false otherwise
+ */
+export function certificateExists(certPath: string): boolean {
+  return fs.existsSync(certPath);
+}
+
+/**
+ * Ensures the certificate directory exists
+ * @param dirPath Path to the certificate directory
+ */
+export function ensureCertificateDirectory(dirPath: string): void {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}

package/ts/common/eventUtils.ts

@@ -1,4 +1,4 @@
-import type { Port80Handler } from '../port80handler/classes.port80handler.js';
+import type { Port80Handler } from '../http/port80/port80-handler.js';
 import { Port80HandlerEvents } from './types.js';
 import type { ICertificateData, ICertificateFailure, ICertificateExpiring } from './types.js';
 

package/ts/common/port80-adapter.ts

@@ -7,7 +7,7 @@ import type {
 
 import type {
   IForwardConfig
-} from '../smartproxy/types/forwarding.types.js';
+} from '../forwarding/config/forwarding-types.js';
 
 /**
  * Converts a forwarding configuration target to the legacy format

package/ts/core/events/index.ts

@@ -0,0 +1,3 @@
+/**
+ * Common event definitions
+ */

package/ts/core/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Core functionality module
+ */
+
+// Export submodules
+export * from './models/index.js';
+export * from './utils/index.js';
+export * from './events/index.js';

package/ts/core/models/common-types.ts

@@ -0,0 +1,91 @@
+import * as plugins from '../../plugins.js';
+
+/**
+ * Shared types for certificate management and domain options
+ */
+
+/**
+ * Domain forwarding configuration
+ */
+export interface IForwardConfig {
+  ip: string;
+  port: number;
+}
+
+/**
+ * Domain configuration options
+ */
+export interface IDomainOptions {
+  domainName: string;
+  sslRedirect: boolean;   // if true redirects the request to port 443
+  acmeMaintenance: boolean; // tries to always have a valid cert for this domain
+  forward?: IForwardConfig; // forwards all http requests to that target
+  acmeForward?: IForwardConfig; // forwards letsencrypt requests to this config
+}
+
+/**
+ * Certificate data that can be emitted via events or set from outside
+ */
+export interface ICertificateData {
+  domain: string;
+  certificate: string;
+  privateKey: string;
+  expiryDate: Date;
+}
+
+/**
+ * Events emitted by the Port80Handler
+ */
+export enum Port80HandlerEvents {
+  CERTIFICATE_ISSUED = 'certificate-issued',
+  CERTIFICATE_RENEWED = 'certificate-renewed',
+  CERTIFICATE_FAILED = 'certificate-failed',
+  CERTIFICATE_EXPIRING = 'certificate-expiring',
+  MANAGER_STARTED = 'manager-started',
+  MANAGER_STOPPED = 'manager-stopped',
+  REQUEST_FORWARDED = 'request-forwarded',
+}
+
+/**
+ * Certificate failure payload type
+ */
+export interface ICertificateFailure {
+  domain: string;
+  error: string;
+  isRenewal: boolean;
+}
+
+/**
+ * Certificate expiry payload type
+ */
+export interface ICertificateExpiring {
+  domain: string;
+  expiryDate: Date;
+  daysRemaining: number;
+}
+/**
+ * Forwarding configuration for specific domains in ACME setup
+ */
+export interface IDomainForwardConfig {
+  domain: string;
+  forwardConfig?: IForwardConfig;
+  acmeForwardConfig?: IForwardConfig;
+  sslRedirect?: boolean;
+}
+
+/**
+ * Unified ACME configuration options used across proxies and handlers
+ */
+export interface IAcmeOptions {
+  accountEmail?: string;          // Email for Let's Encrypt account
+  enabled?: boolean;              // Whether ACME is enabled
+  port?: number;                  // Port to listen on for ACME challenges (default: 80)
+  useProduction?: boolean;        // Use production environment (default: staging)
+  httpsRedirectPort?: number;     // Port to redirect HTTP requests to HTTPS (default: 443)
+  renewThresholdDays?: number;    // Days before expiry to renew certificates
+  renewCheckIntervalHours?: number; // How often to check for renewals (in hours)
+  autoRenew?: boolean;            // Whether to automatically renew certificates
+  certificateStore?: string;      // Directory to store certificates
+  skipConfiguredCerts?: boolean;  // Skip domains with existing certificates
+  domainForwards?: IDomainForwardConfig[]; // Domain-specific forwarding configs
+}

package/ts/core/models/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Core data models and interfaces
+ */
+
+export * from './common-types.js';

package/ts/core/utils/event-utils.ts

@@ -0,0 +1,34 @@
+import type { Port80Handler } from '../../http/port80/port80-handler.js';
+import { Port80HandlerEvents } from '../models/common-types.js';
+import type { ICertificateData, ICertificateFailure, ICertificateExpiring } from '../models/common-types.js';
+
+/**
+ * Subscribers callback definitions for Port80Handler events
+ */
+export interface IPort80HandlerSubscribers {
+  onCertificateIssued?: (data: ICertificateData) => void;
+  onCertificateRenewed?: (data: ICertificateData) => void;
+  onCertificateFailed?: (data: ICertificateFailure) => void;
+  onCertificateExpiring?: (data: ICertificateExpiring) => void;
+}
+
+/**
+ * Subscribes to Port80Handler events based on provided callbacks
+ */
+export function subscribeToPort80Handler(
+  handler: Port80Handler,
+  subscribers: IPort80HandlerSubscribers
+): void {
+  if (subscribers.onCertificateIssued) {
+    handler.on(Port80HandlerEvents.CERTIFICATE_ISSUED, subscribers.onCertificateIssued);
+  }
+  if (subscribers.onCertificateRenewed) {
+    handler.on(Port80HandlerEvents.CERTIFICATE_RENEWED, subscribers.onCertificateRenewed);
+  }
+  if (subscribers.onCertificateFailed) {
+    handler.on(Port80HandlerEvents.CERTIFICATE_FAILED, subscribers.onCertificateFailed);
+  }
+  if (subscribers.onCertificateExpiring) {
+    handler.on(Port80HandlerEvents.CERTIFICATE_EXPIRING, subscribers.onCertificateExpiring);
+  }
+}

package/ts/core/utils/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Core utility functions
+ */
+
+export * from './event-utils.js';
+export * from './validation-utils.js';
+export * from './ip-utils.js';

package/ts/core/utils/ip-utils.ts

@@ -0,0 +1,175 @@
+import * as plugins from '../../plugins.js';
+
+/**
+ * Utility class for IP address operations
+ */
+export class IpUtils {
+  /**
+   * Check if the IP matches any of the glob patterns
+   *
+   * This method checks IP addresses against glob patterns and handles IPv4/IPv6 normalization.
+   * It's used to implement IP filtering based on security configurations.
+   *
+   * @param ip - The IP address to check
+   * @param patterns - Array of glob patterns
+   * @returns true if IP matches any pattern, false otherwise
+   */
+  public static isGlobIPMatch(ip: string, patterns: string[]): boolean {
+    if (!ip || !patterns || patterns.length === 0) return false;
+
+    // Normalize the IP being checked
+    const normalizedIPVariants = this.normalizeIP(ip);
+    if (normalizedIPVariants.length === 0) return false;
+
+    // Normalize the pattern IPs for consistent comparison
+    const expandedPatterns = patterns.flatMap(pattern => this.normalizeIP(pattern));
+
+    // Check for any match between normalized IP variants and patterns
+    return normalizedIPVariants.some((ipVariant) =>
+      expandedPatterns.some((pattern) => plugins.minimatch(ipVariant, pattern))
+    );
+  }
+
+  /**
+   * Normalize IP addresses for consistent comparison
+   * 
+   * @param ip The IP address to normalize
+   * @returns Array of normalized IP forms
+   */
+  public static normalizeIP(ip: string): string[] {
+    if (!ip) return [];
+    
+    // Handle IPv4-mapped IPv6 addresses (::ffff:127.0.0.1)
+    if (ip.startsWith('::ffff:')) {
+      const ipv4 = ip.slice(7);
+      return [ip, ipv4];
+    }
+    
+    // Handle IPv4 addresses by also checking IPv4-mapped form
+    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(ip)) {
+      return [ip, `::ffff:${ip}`];
+    }
+    
+    return [ip];
+  }
+
+  /**
+   * Check if an IP is authorized using security rules
+   *
+   * @param ip - The IP address to check
+   * @param allowedIPs - Array of allowed IP patterns
+   * @param blockedIPs - Array of blocked IP patterns
+   * @returns true if IP is authorized, false if blocked
+   */
+  public static isIPAuthorized(ip: string, allowedIPs: string[] = [], blockedIPs: string[] = []): boolean {
+    // Skip IP validation if no rules are defined
+    if (!ip || (allowedIPs.length === 0 && blockedIPs.length === 0)) {
+      return true;
+    }
+
+    // First check if IP is blocked - blocked IPs take precedence
+    if (blockedIPs.length > 0 && this.isGlobIPMatch(ip, blockedIPs)) {
+      return false;
+    }
+
+    // Then check if IP is allowed (if no allowed IPs are specified, all non-blocked IPs are allowed)
+    return allowedIPs.length === 0 || this.isGlobIPMatch(ip, allowedIPs);
+  }
+
+  /**
+   * Check if an IP address is a private network address
+   * 
+   * @param ip The IP address to check
+   * @returns true if the IP is a private network address, false otherwise
+   */
+  public static isPrivateIP(ip: string): boolean {
+    if (!ip) return false;
+
+    // Handle IPv4-mapped IPv6 addresses
+    if (ip.startsWith('::ffff:')) {
+      ip = ip.slice(7);
+    }
+
+    // Check IPv4 private ranges
+    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(ip)) {
+      const parts = ip.split('.').map(Number);
+      
+      // Check common private ranges
+      // 10.0.0.0/8
+      if (parts[0] === 10) return true;
+      
+      // 172.16.0.0/12
+      if (parts[0] === 172 && parts[1] >= 16 && parts[1] <= 31) return true;
+      
+      // 192.168.0.0/16
+      if (parts[0] === 192 && parts[1] === 168) return true;
+      
+      // 127.0.0.0/8 (localhost)
+      if (parts[0] === 127) return true;
+      
+      return false;
+    }
+    
+    // IPv6 local addresses
+    return ip === '::1' || ip.startsWith('fc00:') || ip.startsWith('fd00:') || ip.startsWith('fe80:');
+  }
+
+  /**
+   * Check if an IP address is a public network address
+   * 
+   * @param ip The IP address to check
+   * @returns true if the IP is a public network address, false otherwise
+   */
+  public static isPublicIP(ip: string): boolean {
+    return !this.isPrivateIP(ip);
+  }
+
+  /**
+   * Convert a subnet CIDR to an IP range for filtering
+   * 
+   * @param cidr The CIDR notation (e.g., "192.168.1.0/24")
+   * @returns Array of glob patterns that match the CIDR range
+   */
+  public static cidrToGlobPatterns(cidr: string): string[] {
+    if (!cidr || !cidr.includes('/')) return [];
+    
+    const [ipPart, prefixPart] = cidr.split('/');
+    const prefix = parseInt(prefixPart, 10);
+    
+    if (isNaN(prefix) || prefix < 0 || prefix > 32) return [];
+    
+    // For IPv4 only for now
+    if (!/^\d{1,3}(\.\d{1,3}){3}$/.test(ipPart)) return [];
+    
+    const ipParts = ipPart.split('.').map(Number);
+    const fullMask = Math.pow(2, 32 - prefix) - 1;
+    
+    // Convert IP to a numeric value
+    const ipNum = (ipParts[0] << 24) | (ipParts[1] << 16) | (ipParts[2] << 8) | ipParts[3];
+    
+    // Calculate network address (IP & ~fullMask)
+    const networkNum = ipNum & ~fullMask;
+    
+    // For large ranges, return wildcard patterns
+    if (prefix <= 8) {
+      return [`${(networkNum >>> 24) & 255}.*.*.*`];
+    } else if (prefix <= 16) {
+      return [`${(networkNum >>> 24) & 255}.${(networkNum >>> 16) & 255}.*.*`];
+    } else if (prefix <= 24) {
+      return [`${(networkNum >>> 24) & 255}.${(networkNum >>> 16) & 255}.${(networkNum >>> 8) & 255}.*`];
+    }
+    
+    // For small ranges, create individual IP patterns
+    const patterns = [];
+    const maxAddresses = Math.min(256, Math.pow(2, 32 - prefix));
+    
+    for (let i = 0; i < maxAddresses; i++) {
+      const currentIpNum = networkNum + i;
+      patterns.push(
+        `${(currentIpNum >>> 24) & 255}.${(currentIpNum >>> 16) & 255}.${(currentIpNum >>> 8) & 255}.${currentIpNum & 255}`
+      );
+    }
+    
+    return patterns;
+  }
+}