@push.rocks/smartnetwork 4.4.0 → 4.5.0

package/dist_ts/smartnetwork.classes.ipintelligence.js

@@ -0,0 +1,442 @@
+import * as plugins from './smartnetwork.plugins.js';
+import { getLogger } from './logging.js';
+// CDN URLs for GeoLite2 MMDB files (served via jsDelivr from npm packages)
+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;
+/**
+ * IpIntelligence provides IP address intelligence by combining three data sources:
+ * - RDAP (direct to RIRs) for registration/org data
+ * - Team Cymru DNS for ASN
+ * - MaxMind GeoLite2 (in-memory MMDB) for geolocation
+ */
+export class IpIntelligence {
+    constructor(options) {
+        this.logger = getLogger();
+        // MaxMind readers (lazily initialized)
+        this.cityReader = null;
+        this.asnReader = null;
+        this.lastFetchTime = 0;
+        this.refreshPromise = null;
+        // RDAP bootstrap cache
+        this.bootstrapEntries = null;
+        this.bootstrapPromise = null;
+        this.dbMaxAge = options?.dbMaxAge ?? DEFAULT_DB_MAX_AGE;
+        this.timeout = options?.timeout ?? DEFAULT_TIMEOUT;
+    }
+    /**
+     * Get comprehensive IP intelligence for the given IP address.
+     * Runs RDAP, Team Cymru DNS, and MaxMind lookups in parallel.
+     */
+    async getIntelligence(ip) {
+        const result = {
+            asn: null,
+            asnOrg: null,
+            registrantOrg: null,
+            registrantCountry: null,
+            networkRange: null,
+            abuseContact: null,
+            country: null,
+            countryCode: null,
+            city: null,
+            latitude: null,
+            longitude: null,
+            accuracyRadius: null,
+            timezone: null,
+        };
+        // Run all three layers in parallel
+        const [rdapResult, cymruResult, maxmindResult] = await Promise.allSettled([
+            this.queryRdap(ip),
+            this.queryTeamCymru(ip),
+            this.queryMaxMind(ip),
+        ]);
+        // Merge RDAP results
+        if (rdapResult.status === 'fulfilled' && rdapResult.value) {
+            const rdap = rdapResult.value;
+            result.registrantOrg = rdap.registrantOrg;
+            result.registrantCountry = rdap.registrantCountry;
+            result.networkRange = rdap.networkRange;
+            result.abuseContact = rdap.abuseContact;
+        }
+        // Merge Team Cymru results (primary for ASN)
+        if (cymruResult.status === 'fulfilled' && cymruResult.value) {
+            const cymru = cymruResult.value;
+            result.asn = cymru.asn;
+        }
+        // Merge MaxMind results
+        if (maxmindResult.status === 'fulfilled' && maxmindResult.value) {
+            const mm = maxmindResult.value;
+            result.country = mm.country;
+            result.countryCode = mm.countryCode;
+            result.city = mm.city;
+            result.latitude = mm.latitude;
+            result.longitude = mm.longitude;
+            result.accuracyRadius = mm.accuracyRadius;
+            result.timezone = mm.timezone;
+            // Use MaxMind ASN as fallback if Team Cymru failed
+            if (result.asn === null && mm.asn !== null) {
+                result.asn = mm.asn;
+            }
+            if (mm.asnOrg) {
+                result.asnOrg = mm.asnOrg;
+            }
+        }
+        // If we got ASN from Team Cymru but not org, and MaxMind didn't provide org either,
+        // the asnOrg remains null (we don't do an additional lookup)
+        return result;
+    }
+    // ─── RDAP Subsystem ─────────────────────────────────────────────────
+    /**
+     * Load and cache the IANA RDAP bootstrap file
+     */
+    async ensureBootstrap() {
+        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();
+                    const entries = [];
+                    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) {
+                this.logger.debug?.(`Failed to load RDAP bootstrap: ${err.message}`);
+                this.bootstrapEntries = []; // empty = all RDAP lookups will skip
+            }
+        })();
+        await this.bootstrapPromise;
+        this.bootstrapPromise = null;
+    }
+    /**
+     * Find the RDAP base URL for a given IP via longest-prefix match
+     */
+    matchRir(ip) {
+        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
+     */
+    async queryRdap(ip) {
+        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();
+            let registrantOrg = null;
+            let registrantCountry = data.country || null;
+            let abuseContact = null;
+            // Parse network range
+            let networkRange = null;
+            if (data.cidr0_cidrs && data.cidr0_cidrs.length > 0) {
+                const cidr = data.cidr0_cidrs[0];
+                networkRange = `${cidr.v4prefix || cidr.v6prefix}/${cidr.length}`;
+            }
+            else if (data.startAddress && data.endAddress) {
+                networkRange = `${data.startAddress} - ${data.endAddress}`;
+            }
+            // Parse entities
+            if (data.entities && Array.isArray(data.entities)) {
+                for (const entity of data.entities) {
+                    const roles = 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 = subEntity.roles || [];
+                                if (subRoles.includes('abuse')) {
+                                    abuseContact = this.extractVcardEmail(subEntity);
+                                    if (abuseContact)
+                                        break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            return { registrantOrg, registrantCountry, networkRange, abuseContact };
+        }
+        catch (err) {
+            this.logger.debug?.(`RDAP query failed for ${ip}: ${err.message}`);
+            return null;
+        }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    /**
+     * Extract the 'fn' (formatted name) from an entity's vcardArray
+     */
+    extractVcardFn(entity) {
+        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
+     */
+    extractVcardEmail(entity) {
+        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
+     */
+    extractVcardCountry(entity) {
+        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 ───────────────────────────────────────
+    /**
+     * Query Team Cymru DNS for ASN information.
+     * Query format: reversed.ip.origin.asn.cymru.com TXT
+     * Response: "ASN | prefix | CC | rir | date"
+     */
+    async queryTeamCymru(ip) {
+        try {
+            const reversed = ip.split('.').reverse().join('.');
+            const queryName = `${reversed}.origin.asn.cymru.com`;
+            const dnsClient = new plugins.smartdns.dnsClientMod.Smartdns({
+                strategy: 'prefer-system',
+                allowDohFallback: true,
+                timeoutMs: this.timeout,
+            });
+            const records = await dnsClient.getRecordsTxt(queryName);
+            if (!records || records.length === 0)
+                return null;
+            // Parse the first TXT record: "13335 | 1.1.1.0/24 | AU | apnic | 2011-08-11"
+            const txt = records[0].value || records[0].data;
+            if (!txt)
+                return null;
+            const parts = txt.split('|').map((s) => s.trim());
+            if (parts.length < 3)
+                return null;
+            const asn = parseInt(parts[0], 10);
+            if (isNaN(asn))
+                return null;
+            return {
+                asn,
+                prefix: parts[1] || '',
+                country: parts[2] || '',
+            };
+        }
+        catch (err) {
+            this.logger.debug?.(`Team Cymru DNS query failed for ${ip}: ${err.message}`);
+            return null;
+        }
+    }
+    // ─── MaxMind GeoLite2 Subsystem ─────────────────────────────────────
+    /**
+     * Ensure MMDB readers are initialized. Downloads on first call,
+     * triggers background refresh if stale.
+     */
+    async ensureReaders() {
+        if (this.cityReader && this.asnReader) {
+            // Check if refresh needed
+            if (Date.now() - this.lastFetchTime > this.dbMaxAge && !this.refreshPromise) {
+                this.refreshPromise = this.downloadAndInitReaders()
+                    .catch((err) => this.logger.debug?.(`Background MMDB refresh failed: ${err.message}`))
+                    .finally(() => { this.refreshPromise = null; });
+            }
+            return;
+        }
+        // First time: blocking download
+        if (this.refreshPromise) {
+            await this.refreshPromise;
+            return;
+        }
+        this.refreshPromise = this.downloadAndInitReaders();
+        await this.refreshPromise;
+        this.refreshPromise = null;
+    }
+    /**
+     * Download MMDB files from CDN and create Reader instances
+     */
+    async downloadAndInitReaders() {
+        const [cityBuffer, asnBuffer] = await Promise.all([
+            this.fetchBuffer(CITY_MMDB_URL),
+            this.fetchBuffer(ASN_MMDB_URL),
+        ]);
+        this.cityReader = new plugins.maxmind.Reader(cityBuffer);
+        this.asnReader = new plugins.maxmind.Reader(asnBuffer);
+        this.lastFetchTime = Date.now();
+        this.logger.info?.('MaxMind MMDB databases loaded into memory');
+    }
+    /**
+     * Fetch a URL and return the response as a Buffer
+     */
+    async fetchBuffer(url) {
+        const response = await fetch(url, {
+            headers: { 'User-Agent': '@push.rocks/smartnetwork' },
+        });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch ${url}: HTTP ${response.status}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        return Buffer.from(arrayBuffer);
+    }
+    /**
+     * Query MaxMind for geo + ASN data
+     */
+    async queryMaxMind(ip) {
+        try {
+            await this.ensureReaders();
+        }
+        catch (err) {
+            this.logger.debug?.(`Failed to initialize MaxMind readers: ${err.message}`);
+            return null;
+        }
+        if (!this.cityReader || !this.asnReader)
+            return null;
+        let country = null;
+        let countryCode = null;
+        let city = null;
+        let latitude = null;
+        let longitude = null;
+        let accuracyRadius = null;
+        let timezone = null;
+        let asn = null;
+        let asnOrg = null;
+        // City lookup
+        try {
+            const cityResult = this.cityReader.get(ip);
+            if (cityResult) {
+                country = cityResult.country?.names?.en || null;
+                countryCode = cityResult.country?.iso_code || null;
+                city = cityResult.city?.names?.en || null;
+                latitude = cityResult.location?.latitude ?? null;
+                longitude = cityResult.location?.longitude ?? null;
+                accuracyRadius = cityResult.location?.accuracy_radius ?? null;
+                timezone = cityResult.location?.time_zone || null;
+            }
+        }
+        catch (err) {
+            this.logger.debug?.(`MaxMind city lookup failed for ${ip}: ${err.message}`);
+        }
+        // ASN lookup
+        try {
+            const asnResult = this.asnReader.get(ip);
+            if (asnResult) {
+                asn = asnResult.autonomous_system_number ?? null;
+                asnOrg = asnResult.autonomous_system_organization || null;
+            }
+        }
+        catch (err) {
+            this.logger.debug?.(`MaxMind ASN lookup failed for ${ip}: ${err.message}`);
+        }
+        return { country, countryCode, city, latitude, longitude, accuracyRadius, timezone, asn, asnOrg };
+    }
+    // ─── Utilities ──────────────────────────────────────────────────────
+    /**
+     * Convert an IPv4 address string to a 32-bit unsigned number
+     */
+    ipToNumber(ip) {
+        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);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartnetwork.classes.ipintelligence.js","sourceRoot":"","sources":["../ts/smartnetwork.classes.ipintelligence.ts"],"names":[],"mappings":"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"}

package/dist_ts/smartnetwork.classes.publicip.js

@@ -133,4 +133,4 @@ export class PublicIp {
         return ipv6Regex.test(ip) || ipv6CompressedRegex.test(ip);
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartnetwork.classes.rustbridge.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Command map for the rustnetwork IPC binary.
+ * Each key maps to { params, result } defining the typed IPC protocol.
+ */
+type TNetworkCommands = {
+    healthPing: {
+        params: Record<string, never>;
+        result: {
+            pong: boolean;
+        };
+    };
+    ping: {
+        params: {
+            host: string;
+            count?: number;
+            timeoutMs?: number;
+        };
+        result: {
+            alive: boolean;
+            times: (number | null)[];
+            min: number | null;
+            max: number | null;
+            avg: number | null;
+            stddev: number | null;
+            packetLoss: number;
+        };
+    };
+    traceroute: {
+        params: {
+            host: string;
+            maxHops?: number;
+            timeoutMs?: number;
+        };
+        result: {
+            hops: Array<{
+                ttl: number;
+                ip: string;
+                rtt: number | null;
+            }>;
+        };
+    };
+    tcpPortCheck: {
+        params: {
+            host: string;
+            port: number;
+            timeoutMs?: number;
+        };
+        result: {
+            isOpen: boolean;
+            latencyMs: number | null;
+        };
+    };
+    isLocalPortFree: {
+        params: {
+            port: number;
+        };
+        result: {
+            free: boolean;
+        };
+    };
+    defaultGateway: {
+        params: Record<string, never>;
+        result: {
+            interfaceName: string;
+            addresses: Array<{
+                family: string;
+                address: string;
+            }>;
+        };
+    };
+};
+/**
+ * Singleton bridge to the rustnetwork binary.
+ * Manages the IPC lifecycle for network diagnostics operations.
+ */
+export declare class RustNetworkBridge {
+    private static instance;
+    static getInstance(): RustNetworkBridge;
+    private bridge;
+    private constructor();
+    /**
+     * Spawn the Rust binary and wait for it to be ready.
+     */
+    start(): Promise<void>;
+    /**
+     * Kill the Rust binary.
+     */
+    stop(): Promise<void>;
+    /**
+     * Ensure the bridge is running before sending a command.
+     */
+    private ensureRunning;
+    ping(host: string, count?: number, timeoutMs?: number): Promise<TNetworkCommands['ping']['result']>;
+    traceroute(host: string, maxHops?: number, timeoutMs?: number): Promise<TNetworkCommands['traceroute']['result']>;
+    tcpPortCheck(host: string, port: number, timeoutMs?: number): Promise<TNetworkCommands['tcpPortCheck']['result']>;
+    isLocalPortFree(port: number): Promise<TNetworkCommands['isLocalPortFree']['result']>;
+    defaultGateway(): Promise<TNetworkCommands['defaultGateway']['result']>;
+    healthPing(): Promise<TNetworkCommands['healthPing']['result']>;
+}
+export {};