@cleandns/whois-rdap 1.0.0

package/dist/utils/findInObject.d.ts

@@ -0,0 +1 @@
+export declare function findInObject(obj: Object, condition: (el: any) => boolean, extractor: (el: any) => any, fallback: any): any;

package/dist/utils/findInObject.js

@@ -0,0 +1,17 @@
+export function findInObject(obj, condition, extractor, fallback) {
+    const found = _findInObject(obj, condition);
+    return found === undefined ? fallback : extractor(found);
+}
+function _findInObject(obj, condition) {
+    for (const key in obj) {
+        if (condition(obj[key])) {
+            return obj[key];
+        }
+        if (typeof obj[key] === "object") {
+            const result = _findInObject(obj[key], condition);
+            if (result !== undefined) {
+                return result;
+            }
+        }
+    }
+}

package/dist/utils/fixArrays.d.ts

@@ -0,0 +1 @@
+export declare function fixArrays(data: any): any;

package/dist/utils/fixArrays.js

@@ -0,0 +1,15 @@
+// turn an object with sequential numeric keys into an array
+export function fixArrays(data) {
+    if (Array.isArray(data)) {
+        data = data.map(fixArrays);
+    }
+    else if (data && typeof data === "object") {
+        if (data['0']) {
+            data = Object.values(data).map(fixArrays);
+        }
+        else {
+            data = Object.fromEntries(Object.entries(data).map(([key, value]) => [key, fixArrays(value)]));
+        }
+    }
+    return data;
+}

package/dist/utils/ianaIdToRegistrar.d.ts

@@ -0,0 +1,11 @@
+type IanaRegistrarId = number;
+type IanaRegistrarStatus = "Terminated" | "Accredited" | "Reserved";
+interface IanaRegistrar {
+    id: IanaRegistrarId;
+    name: string;
+    status: IanaRegistrarStatus;
+    url: string;
+}
+export declare const ianaToRegistrarCache: Map<number, IanaRegistrar>;
+export declare function ianaIdToRegistrar(item: number): Promise<IanaRegistrar | undefined>;
+export {};

package/dist/utils/ianaIdToRegistrar.js

@@ -0,0 +1,16 @@
+export const ianaToRegistrarCache = new Map();
+export async function ianaIdToRegistrar(item) {
+    if (ianaToRegistrarCache.size === 0) {
+        // console.warn(`fetching iana-to-registrar`);
+        const response = await fetch(`https://www.iana.org/assignments/registrar-ids/registrar-ids-1.csv`).then((r) => r.text());
+        const records = response.matchAll(/^(?:"(\d+)"|(\d+)),(?:"([^\n\r"]*)"|([^\n\r",]*)),(?:"([^\n\r"]*)"|([^\n\r",]*)),(?:"([^\n\r"]*)"|([^\n\r",]*))/gm);
+        for (const record of records) {
+            const id = parseInt(record[1] || record[2]);
+            const name = record[3] || record[4];
+            const status = (record[5] || record[6]);
+            const url = record[7] || record[8];
+            ianaToRegistrarCache.set(id, { id, name, status, url });
+        }
+    }
+    return ianaToRegistrarCache.get(item);
+}

package/dist/utils/tldToRdap.d.ts

@@ -0,0 +1 @@
+export declare function tldToRdap(domain: string): Promise<[string, string | null]>;

package/dist/utils/tldToRdap.js

@@ -0,0 +1,61 @@
+import { ParseResultType, parseDomain } from "parse-domain";
+const tldCache = new Map([]);
+const tldCachePresets = [
+    ["br.com", "https://rdap.centralnic.com/br.com"],
+    ["cn.com", "https://rdap.centralnic.com/cn.com"],
+    ["de.com", "https://rdap.centralnic.com/de.com"],
+    ["eu.com", "https://rdap.centralnic.com/eu.com"],
+    ["gb.com", "https://rdap.centralnic.com/gb.com"],
+    ["gb.net", "https://rdap.centralnic.com/gb.net"],
+    ["gr.com", "https://rdap.centralnic.com/gr.com"],
+    ["hu.com", "https://rdap.centralnic.com/hu.com"],
+    ["in.net", "https://rdap.centralnic.com/in.net"],
+    ["jpn.com", "https://rdap.centralnic.com/jpn.com"],
+    ["no.com", "https://rdap.centralnic.com/no.com"],
+    ["qc.com", "https://rdap.centralnic.com/qc.com"],
+    ["ru.com", "https://rdap.centralnic.com/ru.com"],
+    ["sa.com", "https://rdap.centralnic.com/sa.com"],
+    ["se.com", "https://rdap.centralnic.com/se.com"],
+    ["se.net", "https://rdap.centralnic.com/se.net"],
+    ["uk.com", "https://rdap.centralnic.com/uk.com"],
+    ["uk.net", "https://rdap.centralnic.com/uk.net"],
+    ["us.com", "https://rdap.centralnic.com/us.com"],
+    ["uy.com", "https://rdap.centralnic.com/uy.com"],
+    ["web.com", "https://rdap.centralnic.com/web.com"],
+    ["za.com", "https://rdap.centralnic.com/za.com"],
+];
+export async function tldToRdap(domain) {
+    if (tldCache.size === 0) {
+        for (const [tld, url] of tldCachePresets) {
+            tldCache.set(tld, url);
+        }
+        // console.warn(`fetching tld-to-rdap`);
+        const response = await fetch(`https://data.iana.org/rdap/dns.json`).then((r) => r.json());
+        for (const [tlds, urls] of response.services) {
+            for (const tld of tlds) {
+                tldCache.set(tld, urls[0].replace(/\/$/, ''));
+            }
+        }
+    }
+    const parsed = parseDomain(domain);
+    if (parsed.type === ParseResultType.Listed) {
+        let tld = parsed.topLevelDomains.join(".");
+        if (tldCache.has(tld)) {
+            return [parsed.domain + '.' + tld, tldCache.get(tld)];
+        }
+        tld = parsed.icann.topLevelDomains.join(".");
+        if (tldCache.has(tld)) {
+            return [parsed.icann.domain + '.' + tld, tldCache.get(tld)];
+        }
+        // const tlds = [
+        //   parsed.topLevelDomains.join("."),
+        //   // parsed.icann.topLevelDomains.join("."),
+        // ];
+        // for (const tld of tlds) {
+        //   if (tldCache.has(tld)) {
+        //     return tldCache.get(tld);
+        //   }
+        // }
+    }
+    return [domain, null];
+}

package/dist/whoisStatus.d.ts

@@ -0,0 +1 @@
+export declare function normalizeWhoisStatus(status: string): string;

package/dist/whoisStatus.js

@@ -0,0 +1,36 @@
+const statusMap = {
+    'inactive': 'inactive',
+    'active': 'active',
+    'ok': 'active',
+    'pendingcreate': 'pending create',
+    'pendingdelete': 'pending delete',
+    'pendingrenew': 'pending renew',
+    'pendingrestore': 'pending restore',
+    'pendingtransfer': 'pending transfer',
+    'pendingupdate': 'pending update',
+    'addperiod': 'add period',
+    'autorenewperiod': 'auto renew period',
+    'redemptionperiod': 'redemption period',
+    'renewperiod': 'renew period',
+    'transferperiod': 'transfer period',
+    'serverhold': 'server hold',
+    'serverdeleteprohibited': 'server delete prohibited',
+    'serverdeletedprohibited': 'server delete prohibited',
+    'serverrenewprohibited': 'server renew prohibited',
+    'servertransferprohibited': 'server transfer prohibited',
+    'serverupdateprohibited': 'server update prohibited',
+    'clienthold': 'client hold',
+    'clientdeleteprohibited': 'client delete prohibited',
+    'clientrenewprohibited': 'client renew prohibited',
+    'clienttransferprohibited': 'client transfer prohibited',
+    'clientupdateprohibited': 'client update prohibited',
+    'hold': 'client hold',
+    'deleteprohibited': 'client delete prohibited',
+    'renewprohibited': 'client renew prohibited',
+    'transferprohibited': 'client transfer prohibited',
+    'updatedprohibited': 'client update prohibited',
+};
+export function normalizeWhoisStatus(status) {
+    status = (status || "").toLocaleLowerCase();
+    return statusMap[status.replace(/[ _]/g, '')] || status;
+}

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@cleandns/whois-rdap",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cleandns-inc/tool-whois.git"
+  },
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/cleandns-inc/tool-whois/issues"
+  },
+  "homepage": "https://github.com/cleandns-inc/tool-whois#readme",
+  "devDependencies": {
+    "typescript": "^5.4.3"
+  },
+  "dependencies": {
+    "parse-domain": "^8.0.2",
+    "promise-socket": "^7.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,246 @@
+import { WhoisOptions, WhoisResponse, WhoisTimestampFields } from "../whois.js";
+import { determinePort43Domain, port43 } from "./port43.js";
+import { findInObject } from "./utils/findInObject.js";
+import { fixArrays } from "./utils/fixArrays.js";
+import { ianaIdToRegistrar } from "./utils/ianaIdToRegistrar.js";
+import { tldToRdap } from "./utils/tldToRdap.js";
+import { normalizeWhoisStatus } from "./whoisStatus.js";
+
+const eventMap = new Map<string, WhoisTimestampFields>([
+  ["registration", "created"],
+  ["last changed", "updated"],
+  ["expiration", "expires"],
+]);
+
+export async function whois(domain: string, options: WhoisOptions = { fetch: fetch }): Promise<WhoisResponse> {
+  const fetch = options.fetch!;
+
+  let url: string | null = null;
+  [domain, url] = await tldToRdap(domain);
+
+  const response: WhoisResponse = {
+    found: false,
+    registrar: { id: 0, name: null },
+    reseller: null,
+    status: [],
+    nameservers: [],
+    ts: { created: null, updated: null, expires: null },
+  };
+
+  if (url === null) {
+    if (determinePort43Domain(domain)[2]) {
+      return port43(domain);
+    }
+    url = "https://rdap.org";
+  }
+
+  const thinRdap = `${url}/domain/${domain}`;
+  // console.log(`fetching thin RDAP: ${thinRdap}`);
+
+  let thinResponse = await fetch(thinRdap)
+    .then((r) => r.json() as any)
+    .catch(() => null);
+  if (thinResponse && !thinResponse.errorCode) {
+  } else {
+    return response;
+  }
+
+  if (thinResponse?.rdapConformance?.["0"]) {
+    thinResponse = fixArrays(thinResponse);
+  }
+
+  const selfRdap = thinResponse.links?.find((link: any) => link.rel === "self");
+  const thickRdap = thinResponse.links
+    ?.find(
+      (link: any) =>
+        link.href !== selfRdap?.href &&
+        link.rel === "related" &&
+        link.type === "application/rdap+json"
+    )
+    ?.href.replace("/domain/domain/", "/domain/");
+
+  let thickResponse: any = null;
+
+  if (thickRdap) {
+    // console.log(`fetching thick RDAP: ${thickRdap}`);
+    thickResponse = await fetch(thickRdap)
+      .then((r) => r.json() as any)
+      .catch(() => null);
+    if (thickResponse && !thickResponse.errorCode && !thickResponse.error) {
+    } else {
+      thickResponse = null;
+      // console.warn(`thick RDAP failed for ${domain}`);
+    }
+  }
+
+  if (thickResponse?.rdapConformance?.["0"]) {
+    thickResponse = fixArrays(thickResponse);
+  }
+
+  const registrars: any[] = [];
+  const resellers: any[] = [];
+
+  async function extractRegistrarsAndResellers(response: any, url: string) {
+    for (const ent of [
+      ...(response.entities || []),
+      response.entity ? { events: response.events, ...response.entity } : null,
+    ].filter(Boolean)) {
+      if (ent.roles?.includes("registrar") || ent.role === "registrar") {
+        const pubIds: any[] = [];
+        if (ent.publicIds) {
+          pubIds.push(
+            ...(Array.isArray(ent.publicIds)
+              ? ent.publicIds
+              : [[ent.publicIds]])
+          );
+        }
+        if (ent.publicIDs) {
+          pubIds.push(
+            ...(Array.isArray(ent.publicIDs)
+              ? ent.publicIDs
+              : [[ent.publicIDs]])
+          );
+        }
+        const reg =
+          pubIds.find((id: any) => id.type === "PANDI Registrar ID")
+            ?.Identifier ||
+          pubIds.find((id: any) => id.type === "PANDI Registrar ID")
+            ?.identifier ||
+          pubIds.find((id: any) => id.type === "IANA Registrar ID")
+            ?.Identifier ||
+          pubIds.find((id: any) => id.type === "IANA Registrar ID")?.identifier;
+
+        if (reg) {
+          const id = reg;
+          const name =
+            parseInt(id) == id
+              ? (await ianaIdToRegistrar(parseInt(id)))?.name
+              : findInObject(
+                  ent.vcardArray,
+                  (el: any) =>
+                    Array.isArray(el) && (el[0] === "fn" || el[0] === "org"),
+                  (el: any[]) => el[3],
+                  reg
+                );
+          const events =
+            ent.events || response.events || ent.enents || response.enents;
+          registrars.push({ id, name, events });
+        }
+      }
+
+      if (
+        (ent.roles?.includes("reseller") || ent.role === "reseller") &&
+        ent.vcardArray
+      ) {
+        // vcard objects can be unexpectedly and arbitrarily nested
+        const name = findInObject(
+          ent.vcardArray,
+          (el: any) => Array.isArray(el) && (el[0] === "fn" || el[0] === "org"),
+          (el: any[]) => el[3],
+          ""
+        );
+        resellers.push({ name });
+      }
+    }
+  }
+
+  if (thickResponse && !thickResponse.errorCode) {
+    await extractRegistrarsAndResellers(thickResponse, thickRdap);
+  }
+  if (thinResponse && !thinResponse.errorCode) {
+    await extractRegistrarsAndResellers(thinResponse, thinRdap);
+  }
+
+  response.found = true;
+
+  // registrar
+  const { events, ...registrar } = registrars.sort((a: any, b: any) => {
+    // console.warn({ a, b });
+    const aDate =
+      a.events.find((ev: any) => ev.eventAction === "registration")
+        ?.eventDate || 0;
+    const bDate =
+      b.events.find((ev: any) => ev.eventAction === "registration")
+        ?.eventDate || 0;
+    return new Date(bDate).valueOf() - new Date(aDate).valueOf();
+  })[0] || { id: 0, name: "" };
+  response.registrar = registrar;
+
+  // reseller
+  const reseller = resellers[0]?.name || "";
+  response.reseller = reseller;
+
+  // status
+  response.status = findStatus(
+    thickResponse?.status || thinResponse?.status || [],
+    domain
+  );
+
+  // nameservers
+  response.nameservers = findNameservers(
+    thickResponse?.nameservers || thinResponse?.nameservers || []
+  );
+
+  // ts
+  response.ts = findTimestamps(
+    thickResponse?.events || thinResponse?.events || []
+  );
+
+  return response;
+}
+
+function findStatus(statuses: string | string[], domain: string): string[] {
+  // console.warn({ domain, statuses });
+
+  return (Array.isArray(statuses)
+    ? statuses
+    : statuses && typeof statuses === "object"
+    ? Object.keys(statuses)
+    : (statuses || "").trim().split(/\s*,\s*/)
+  ).map((status) => normalizeWhoisStatus(status));
+}
+
+function findNameservers(values: any[]): string[] {
+  let nameservers: any[] = [];
+  if (Array.isArray(values)) {
+    nameservers = values;
+  } else if (typeof values === "object") {
+    nameservers = Object.values(values);
+  }
+
+  return nameservers
+    .map((ns) => ns.ldhName || ns.ldnName || ns.ipAddresses?.v4)
+    .flat()
+    .filter((ns) => ns)
+    .map((ns) => (ns.stringValue || ns).toLocaleLowerCase())
+    .sort();
+}
+
+function findTimestamps(values: any[]) {
+  const ts: Record<WhoisTimestampFields, Date | null> = {
+    created: null,
+    updated: null,
+    expires: null,
+  };
+
+  let events: any = [];
+
+  if (Array.isArray(values)) {
+    events = values;
+  } else if (typeof values === "object") {
+    events = Object.values(values);
+  }
+
+  for (const [event, field] of eventMap) {
+    const date = events.find((ev: any) => ev.eventAction === event);
+    if (date?.eventDate) {
+      ts[field] = new Date(date.eventDate);
+    }
+  }
+
+  return ts;
+}
+
+// await whois(process.argv[2]).then((r) =>
+//   console.log(JSON.stringify(r, null, 2))
+// );

package/src/port43.ts

@@ -0,0 +1,164 @@
+import { ParseResultType, parseDomain } from "parse-domain";
+import { PromiseSocket } from "promise-socket";
+import { Socket } from "net";
+import { port43servers, port43parsers } from "./port43servers.js";
+import { ianaToRegistrarCache } from "./utils/ianaIdToRegistrar.js";
+import { WhoisResponse } from "../whois.js";
+import { normalizeWhoisStatus } from "./whoisStatus.js";
+
+export function determinePort43Domain(actor: string) {
+  const parsed = parseDomain(actor);
+
+  if (parsed.type === ParseResultType.Listed) {
+    let tld = parsed.topLevelDomains.join(".");
+    if (port43servers[tld]) {
+      const domain = parsed.domain + "." + tld;
+      return [domain, tld, port43servers[tld]];
+    }
+
+    tld = parsed.icann.topLevelDomains.join(".");
+    if (port43servers[tld]) {
+      const domain = parsed.icann.domain + "." + tld;
+      return [domain, tld, port43servers[tld]];
+    }
+  }
+
+  return [actor, "", null];
+}
+
+export async function port43(actor: string): Promise<WhoisResponse> {
+  const [domain, tld, whoisServer] = determinePort43Domain(actor);
+  const opts = whoisServer;
+  const server = opts?.host || opts || null;
+  const query = opts?.query
+    ? opts.query.replace("$addr", domain)
+    : `${domain}\r\n`;
+  const port = opts?.port || 43;
+
+  // console.log(`looking up ${domain} on ${server}`);
+
+  const response: WhoisResponse = {
+    found: true,
+    registrar: { id: 0, name: null },
+    reseller: null,
+    status: [],
+    nameservers: [],
+    ts: { created: null, updated: null, expires: null },
+  };
+
+  if (!server) {
+    return response;
+  }
+
+  let port43response = "";
+
+  try {
+    const promiseSocket = new PromiseSocket(new Socket());
+    promiseSocket.setTimeout(5 * 1000);
+    await promiseSocket.connect(port, server);
+    await promiseSocket.write(query);
+    port43response = (await promiseSocket.readAll())!
+      .toString()
+      .replace(/^[ \t]+/gm, "");
+    await promiseSocket.end();
+  } catch (error) {
+    response.found = false;
+  }
+
+  if (!response.found) {
+    return response;
+  }
+
+  if (
+    port43response.match(
+      /^%*\s+(NOT FOUND|No match|NO OBJECT FOUND|No entries found|No Data Found|No information available|Status: free)\b/im
+    )
+  ) {
+    response.found = false;
+    return response;
+  }
+
+  let m;
+
+  if (port43parsers[tld]) {
+    port43parsers[tld](port43response, response);
+  }
+
+  !response.registrar.name &&
+    (m = port43response.match(
+      /^(?:Registrar(?: Name)?|registrar_name|registrar):[ \t]*(\S.+)/m
+    )) &&
+    (response.registrar.name = m[1]);
+  !response.reseller &&
+    (m = port43response.match(
+      /^(?:Reseller(?: Name)?|reseller_name|reseller):[ \t]*(\S.+)/m
+    )) &&
+    (response.reseller = m[1]);
+  !response.registrar.id &&
+    (m = port43response.match(/^Registrar IANA ID:[ \t]*(\d+)/m)) &&
+    (response.registrar.id = parseInt(m[1] || "0"));
+  !response.ts.updated &&
+    (m = port43response.match(
+      /^(?:Last Modified|Updated Date|domain_datelastmodified|last-update):[ \t]*(\S.+)/m
+    )) &&
+    (response.ts.updated = new Date(m[1]) || null);
+  !response.ts.created &&
+    (m = port43response.match(
+      /^(?:Creation Date|domain_dateregistered|created):[ \t]*(\S.+)/m
+    )) &&
+    (response.ts.created = new Date(m[1]) || null);
+  !response.ts.expires &&
+    (m = port43response.match(
+      /^(?:(?:Registry )?Expiry Date):[ \t]*(\S.+)/m
+    )) &&
+    (response.ts.expires = new Date(m[1]) || null);
+  (m = port43response.match(/^(?:Status|Domain Status|status):.*/gm)) &&
+    m.forEach((s) => {
+      let m;
+      (m = s.match(
+        /^(?:Status|Domain Status|status):[ \t]*(?:<a[^>]*>)?(\S+)/m
+      )) && response.status.push(normalizeWhoisStatus(m[1]));
+    });
+  (m = port43response.match(
+    /^(?:Name Server|ns_name_\d+|namserver|nserver):.*/gm
+  )) &&
+    m.forEach((s) => {
+      let m;
+      (m = s.match(
+        /^(?:Name Server|ns_name_\d+|namserver|nserver):[ \t]*(.*)/m
+      )) && response.nameservers.push(m[1].toLowerCase());
+    });
+
+  if (response.registrar.id === 0 && response.registrar.name !== "") {
+    for (const [id, { name }] of ianaToRegistrarCache.entries()) {
+      if (name === response.registrar.name) {
+        response.registrar.id = id;
+        break;
+      }
+    }
+  }
+
+  if (response.registrar.id === 0 && response.registrar.name !== "") {
+    for (const [id, { name }] of ianaToRegistrarCache.entries()) {
+      if (name.match(new RegExp(`\\b${response.registrar.name}\\b`, "i"))) {
+        response.registrar.id = id;
+        break;
+      }
+    }
+  }
+
+  if (response.registrar.id === 0 && response.registrar.name) {
+    for (const [id, { name }] of ianaToRegistrarCache.entries()) {
+      if (
+        name.match(
+          new RegExp(`\\b${response.registrar.name.replace(/,.*/, "")}\\b`, "i")
+        )
+      ) {
+        response.registrar.id = id;
+        break;
+      }
+    }
+  }
+
+  return response;
+}