@push.rocks/smartnetwork 4.8.0 → 4.10.0

package/ts/smartnetwork.classes.ipintelligence.ts

@@ -64,30 +64,12 @@ export interface IIpIntelligenceOptions {
 const CITY_MMDB_URL = 'https://cdn.jsdelivr.net/npm/@ip-location-db/geolite2-city-mmdb/geolite2-city-ipv4.mmdb';
 const ASN_MMDB_URL = 'https://cdn.jsdelivr.net/npm/@ip-location-db/geolite2-asn-mmdb/geolite2-asn-ipv4.mmdb';
 
-// IANA bootstrap for RDAP
-const IANA_BOOTSTRAP_IPV4_URL = 'https://data.iana.org/rdap/ipv4.json';
-
 const DEFAULT_DB_MAX_AGE = 7 * 24 * 60 * 60 * 1000; // 7 days
 const DEFAULT_TIMEOUT = 5000;
 
-/**
- * Parsed IANA bootstrap entry: a CIDR prefix mapped to an RDAP base URL
- */
-interface IBootstrapEntry {
-  prefix: string;
-  prefixNum: number;  // numeric representation of the network address
-  maskBits: number;
-  baseUrl: string;
-}
-
-interface IRdapNetworkInfo {
-  networkRange: string | null;
-  networkCidrs: string[] | null;
-}
-
 /**
  * IpIntelligence provides IP address intelligence by combining three data sources:
- * - RDAP (direct to RIRs) for registration/org data
+ * - RDAP (direct to RIRs, via @push.rocks/smartwhois) for registration/org data
  * - Team Cymru DNS for ASN
  * - MaxMind GeoLite2 (in-memory MMDB) for geolocation
  */
@@ -102,9 +84,8 @@ export class IpIntelligence {
   private lastFetchTime = 0;
   private refreshPromise: Promise<void> | null = null;
 
-  // RDAP bootstrap cache
-  private bootstrapEntries: IBootstrapEntry[] | null = null;
-  private bootstrapPromise: Promise<void> | null = null;
+  // RDAP client from smartwhois (owns bootstrap caching and RIR matching)
+  private readonly rdapClient: plugins.smartwhois.RdapClient;
 
   // Optional injected smartdns client (shared by SmartNetwork)
   private readonly sharedDnsClient: InstanceType<typeof plugins.smartdns.dnsClientMod.Smartdns> | null;
@@ -113,6 +94,11 @@ export class IpIntelligence {
     this.dbMaxAge = options?.dbMaxAge ?? DEFAULT_DB_MAX_AGE;
     this.timeout = options?.timeout ?? DEFAULT_TIMEOUT;
     this.sharedDnsClient = options?.dnsClient ?? null;
+    this.rdapClient = new plugins.smartwhois.RdapClient({
+      requestTimeoutMs: this.timeout,
+      totalTimeoutMs: this.timeout,
+      userAgent: '@push.rocks/smartnetwork',
+    });
   }
 
   /**
@@ -186,80 +172,10 @@ export class IpIntelligence {
     return result;
   }
 
-  // ─── RDAP Subsystem ─────────────────────────────────────────────────
-
-  /**
-   * Load and cache the IANA RDAP bootstrap file
-   */
-  private async ensureBootstrap(): Promise<void> {
-    if (this.bootstrapEntries) return;
-    if (this.bootstrapPromise) {
-      await this.bootstrapPromise;
-      return;
-    }
-
-    this.bootstrapPromise = (async () => {
-      try {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        try {
-          const response = await fetch(IANA_BOOTSTRAP_IPV4_URL, {
-            signal: controller.signal,
-            headers: { 'User-Agent': '@push.rocks/smartnetwork' },
-          });
-          if (!response.ok) throw new Error(`HTTP ${response.status}`);
-          const data = await response.json() as { services: [string[], string[]][] };
-
-          const entries: IBootstrapEntry[] = [];
-          for (const [prefixes, urls] of data.services) {
-            const baseUrl = urls[0]; // first URL is preferred
-            for (const prefix of prefixes) {
-              const [network, bits] = prefix.split('/');
-              entries.push({
-                prefix,
-                prefixNum: this.ipToNumber(network),
-                maskBits: parseInt(bits, 10),
-                baseUrl: baseUrl.replace(/\/$/, ''), // strip trailing slash
-              });
-            }
-          }
-
-          // Sort by mask bits descending for longest-prefix match
-          entries.sort((a, b) => b.maskBits - a.maskBits);
-          this.bootstrapEntries = entries;
-        } finally {
-          clearTimeout(timeoutId);
-        }
-      } catch (err: any) {
-        this.logger.debug?.(`Failed to load RDAP bootstrap: ${err.message}`);
-        this.bootstrapEntries = []; // empty = all RDAP lookups will skip
-      }
-    })();
-
-    await this.bootstrapPromise;
-    this.bootstrapPromise = null;
-  }
+  // ─── RDAP Subsystem (delegated to @push.rocks/smartwhois) ───────────
 
   /**
-   * Find the RDAP base URL for a given IP via longest-prefix match
-   */
-  private matchRir(ip: string): string | null {
-    if (!this.bootstrapEntries || this.bootstrapEntries.length === 0) return null;
-
-    const ipNum = this.ipToNumber(ip);
-
-    for (const entry of this.bootstrapEntries) {
-      const mask = (0xFFFFFFFF << (32 - entry.maskBits)) >>> 0;
-      if ((ipNum & mask) === (entry.prefixNum & mask)) {
-        return entry.baseUrl;
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * Query RDAP for registration data
+   * Query RDAP for registration data via the smartwhois RdapClient (IPv4 and IPv6).
    */
   private async queryRdap(ip: string): Promise<{
     registrantOrg: string | null;
@@ -268,160 +184,20 @@ export class IpIntelligence {
     networkCidrs: string[] | null;
     abuseContact: string | null;
   } | null> {
-    await this.ensureBootstrap();
-    const baseUrl = this.matchRir(ip);
-    if (!baseUrl) return null;
-
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
     try {
-      const response = await fetch(`${baseUrl}/ip/${ip}`, {
-        signal: controller.signal,
-        headers: {
-          'Accept': 'application/rdap+json',
-          'User-Agent': '@push.rocks/smartnetwork',
-        },
-      });
-      if (!response.ok) return null;
-      const data = await response.json() as any;
-
-      let registrantOrg: string | null = null;
-      let registrantCountry: string | null = data.country || null;
-      let abuseContact: string | null = null;
-
-      const { networkRange, networkCidrs } = this.parseRdapNetworkInfo(data);
-
-      // Parse entities
-      if (data.entities && Array.isArray(data.entities)) {
-        for (const entity of data.entities) {
-          const roles: string[] = entity.roles || [];
-
-          if (roles.includes('registrant') || roles.includes('administrative')) {
-            const orgName = this.extractVcardFn(entity);
-            if (orgName) registrantOrg = orgName;
-
-            // Try to get country from registrant address if not at top level
-            if (!registrantCountry) {
-              registrantCountry = this.extractVcardCountry(entity);
-            }
-          }
-
-          if (roles.includes('abuse')) {
-            abuseContact = this.extractVcardEmail(entity);
-            // Check nested entities for abuse contact
-            if (!abuseContact && entity.entities) {
-              for (const subEntity of entity.entities) {
-                const subRoles: string[] = subEntity.roles || [];
-                if (subRoles.includes('abuse')) {
-                  abuseContact = this.extractVcardEmail(subEntity);
-                  if (abuseContact) break;
-                }
-              }
-            }
-          }
-        }
-      }
-
-      return { registrantOrg, registrantCountry, networkRange, networkCidrs, abuseContact };
+      const rdapRecord = await this.rdapClient.lookupIp(ip);
+      if (!rdapRecord) return null;
+      return {
+        registrantOrg: rdapRecord.registrantOrg ?? null,
+        registrantCountry: rdapRecord.registrantCountry ?? null,
+        networkRange: rdapRecord.networkRange ?? null,
+        networkCidrs: rdapRecord.networkCidrs ?? null,
+        abuseContact: rdapRecord.abuseEmail ?? null,
+      };
     } catch (err: any) {
       this.logger.debug?.(`RDAP query failed for ${ip}: ${err.message}`);
       return null;
-    } finally {
-      clearTimeout(timeoutId);
-    }
-  }
-
-  private parseRdapNetworkInfo(data: any): IRdapNetworkInfo {
-    const cidrs = this.extractRdapCidrs(data);
-    if (cidrs.length > 0) {
-      return {
-        networkRange: cidrs[0],
-        networkCidrs: cidrs,
-      };
     }
-
-    if (typeof data.startAddress === 'string' && typeof data.endAddress === 'string') {
-      const rangeCidrs = this.ipv4RangeToCidrs(data.startAddress, data.endAddress);
-      return {
-        networkRange: rangeCidrs.length === 1
-          ? rangeCidrs[0]
-          : `${data.startAddress} - ${data.endAddress}`,
-        networkCidrs: rangeCidrs.length > 0 ? rangeCidrs : null,
-      };
-    }
-
-    return { networkRange: null, networkCidrs: null };
-  }
-
-  private extractRdapCidrs(data: any): string[] {
-    if (!Array.isArray(data.cidr0_cidrs)) return [];
-    return data.cidr0_cidrs
-      .map((cidr: any) => {
-        const prefix = cidr?.v4prefix || cidr?.v6prefix;
-        const length = Number(cidr?.length);
-        if (typeof prefix !== 'string' || !Number.isInteger(length)) return null;
-        return `${prefix}/${length}`;
-      })
-      .filter(Boolean) as string[];
-  }
-
-  /**
-   * Extract the 'fn' (formatted name) from an entity's vcardArray
-   */
-  private extractVcardFn(entity: any): string | null {
-    if (!entity.vcardArray || !Array.isArray(entity.vcardArray)) return null;
-    const properties = entity.vcardArray[1];
-    if (!Array.isArray(properties)) return null;
-
-    for (const prop of properties) {
-      if (Array.isArray(prop) && prop[0] === 'fn') {
-        return prop[3] || null;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Extract email from an entity's vcardArray
-   */
-  private extractVcardEmail(entity: any): string | null {
-    if (!entity.vcardArray || !Array.isArray(entity.vcardArray)) return null;
-    const properties = entity.vcardArray[1];
-    if (!Array.isArray(properties)) return null;
-
-    for (const prop of properties) {
-      if (Array.isArray(prop) && prop[0] === 'email') {
-        return prop[3] || null;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Extract country from an entity's vcardArray address field
-   */
-  private extractVcardCountry(entity: any): string | null {
-    if (!entity.vcardArray || !Array.isArray(entity.vcardArray)) return null;
-    const properties = entity.vcardArray[1];
-    if (!Array.isArray(properties)) return null;
-
-    for (const prop of properties) {
-      if (Array.isArray(prop) && prop[0] === 'adr') {
-        // The label parameter often contains the full address with country at the end
-        const label = prop[1]?.label;
-        if (typeof label === 'string') {
-          const lines = label.split('\n');
-          const lastLine = lines[lines.length - 1]?.trim();
-          if (lastLine && lastLine.length > 1) return lastLine;
-        }
-        // Also check the structured value (7-element array, last element is country)
-        const value = prop[3];
-        if (Array.isArray(value) && value.length >= 7 && value[6]) {
-          return value[6];
-        }
-      }
-    }
-    return null;
   }
 
   // ─── Team Cymru DNS Subsystem ───────────────────────────────────────
@@ -601,71 +377,4 @@ export class IpIntelligence {
 
     return { country, countryCode, city, latitude, longitude, accuracyRadius, timezone, asn, asnOrg };
   }
-
-  // ─── Utilities ──────────────────────────────────────────────────────
-
-  /**
-   * Convert an IPv4 address string to a 32-bit unsigned number
-   */
-  private ipToNumber(ip: string): number {
-    const parts = ip.split('.');
-    return (
-      ((parseInt(parts[0], 10) << 24) |
-       (parseInt(parts[1], 10) << 16) |
-       (parseInt(parts[2], 10) << 8) |
-        parseInt(parts[3], 10)) >>> 0
-    );
-  }
-
-  private ipv4RangeToCidrs(startIp: string, endIp: string): string[] {
-    const start = this.ipv4ToBigInt(startIp);
-    const end = this.ipv4ToBigInt(endIp);
-    if (start === undefined || end === undefined || start > end) return [];
-
-    const cidrs: string[] = [];
-    let current = start;
-    while (current <= end) {
-      let maxBlockSize = current === 0n ? 1n << 32n : current & -current;
-      const remaining = end - current + 1n;
-      while (maxBlockSize > remaining) {
-        maxBlockSize = maxBlockSize / 2n;
-      }
-      const prefixLength = 32 - this.powerOfTwoExponent(maxBlockSize);
-      cidrs.push(`${this.numberToIpv4(current)}/${prefixLength}`);
-      current += maxBlockSize;
-    }
-    return cidrs;
-  }
-
-  private ipv4ToBigInt(ip: string): bigint | undefined {
-    const parts = ip.trim().split('.');
-    if (parts.length !== 4) return undefined;
-    let result = 0n;
-    for (const part of parts) {
-      if (!/^\d+$/.test(part)) return undefined;
-      const number = Number(part);
-      if (!Number.isInteger(number) || number < 0 || number > 255) return undefined;
-      result = (result * 256n) + BigInt(number);
-    }
-    return result;
-  }
-
-  private numberToIpv4(value: bigint): string {
-    return [
-      Number((value >> 24n) & 255n),
-      Number((value >> 16n) & 255n),
-      Number((value >> 8n) & 255n),
-      Number(value & 255n),
-    ].join('.');
-  }
-
-  private powerOfTwoExponent(value: bigint): number {
-    let exponent = 0;
-    let remaining = value;
-    while (remaining > 1n) {
-      remaining >>= 1n;
-      exponent++;
-    }
-    return exponent;
-  }
 }

package/ts/smartnetwork.plugins.ts

@@ -8,8 +8,9 @@ export { os, https, perfHooks };
 // @pushrocks scope
 import * as smartdns from '@push.rocks/smartdns';
 import * as smartrust from '@push.rocks/smartrust';
+import * as smartwhois from '@push.rocks/smartwhois';
 
-export { smartdns, smartrust };
+export { smartdns, smartrust, smartwhois };
 
 // third party
 import * as maxmind from 'maxmind';