@slicedearth/whoisleuth-cli 1.45.0 → 2.0.0

package/lib/rdap-normalization.mjs

@@ -49,18 +49,24 @@ function truncatedText(value, maxLength) {
         return null;
     return value.replace(/\s+/g, ' ').trim().slice(0, maxLength).trim() || null;
 }
-function flattenScalarValues(value, maxValues = 32) {
+function flattenScalarValuesWithCompleteness(value, maxValues = 32) {
     const output = [];
     const stack = [{ value, depth: 0 }];
     let visited = 0;
+    let truncated = false;
     while (stack.length && output.length < maxValues && visited < 128) {
         const current = stack.pop();
         if (!current)
             continue;
         visited += 1;
         if (Array.isArray(current.value)) {
-            if (current.depth >= MAX_RDAP_ENTITY_DEPTH)
+            if (current.depth >= MAX_RDAP_ENTITY_DEPTH) {
+                if (current.value.length > 0)
+                    truncated = true;
                 continue;
+            }
+            if (current.value.length > maxValues)
+                truncated = true;
             for (let i = Math.min(current.value.length, maxValues) - 1; i >= 0; i -= 1) {
                 stack.push({ value: current.value[i], depth: current.depth + 1 });
             }
@@ -71,8 +77,16 @@ function flattenScalarValues(value, maxValues = 32) {
         else if (typeof current.value === 'number' && Number.isFinite(current.value)) {
             output.push(String(current.value));
         }
+        else {
+            truncated = true;
+        }
     }
-    return output;
+    if (stack.length > 0)
+        truncated = true;
+    return { values: output, truncated };
+}
+function flattenScalarValues(value, maxValues = 32) {
+    return flattenScalarValuesWithCompleteness(value, maxValues).values;
 }
 function vcardRawValues(vcardArray, field) {
     if (!Array.isArray(vcardArray) || !Array.isArray(vcardArray[1]))
@@ -119,79 +133,156 @@ function normalizeAddresses(vcardArray) {
     return addresses;
 }
 function contactValuesTruncated(vcardArray) {
-    for (const field of ['fn', 'org', 'email', 'tel']) {
+    const scalarFields = [
+        { field: 'fn', maxLength: 300, lower: false },
+        { field: 'org', maxLength: 300, lower: false },
+        { field: 'email', maxLength: 320, lower: true },
+        { field: 'tel', maxLength: 100, lower: false },
+    ];
+    for (const { field, maxLength, lower } of scalarFields) {
         let count = 0;
         for (const raw of vcardRawValues(vcardArray, field)) {
-            count += flattenScalarValues(raw, MAX_CONTACT_VALUES + 1).length;
+            const flattened = flattenScalarValuesWithCompleteness(raw, MAX_CONTACT_VALUES + 1);
+            if (flattened.truncated
+                || flattened.values.some((value) => boundedString(value, maxLength, { lower }) === null))
+                return true;
+            count += flattened.values.length;
             if (count > MAX_CONTACT_VALUES)
                 return true;
         }
     }
-    return vcardRawValues(vcardArray, 'adr').length > MAX_CONTACT_VALUES;
+    const addressValues = vcardRawValues(vcardArray, 'adr');
+    if (addressValues.length > MAX_CONTACT_VALUES)
+        return true;
+    for (const raw of addressValues) {
+        const flattened = flattenScalarValuesWithCompleteness(raw, 33);
+        if (flattened.truncated || flattened.values.length > 32)
+            return true;
+        const parts = flattened.values.map((part) => boundedString(part, 300));
+        const rejectedNonBlankPart = parts.some((part, index) => {
+            if (part !== null)
+                return false;
+            const rawPart = flattened.values[index] ?? '';
+            return rawPart.length > 300 || /[\u0000-\u001f\u007f]/u.test(rawPart) || rawPart.trim() !== '';
+        });
+        const retainedParts = parts.filter((part) => part !== null);
+        if (rejectedNonBlankPart
+            || boundedString(retainedParts.join(', '), 1000) === null)
+            return true;
+    }
+    return false;
+}
+function malformedVcardEvidence(vcardArray) {
+    if (vcardArray === undefined)
+        return false;
+    if (!Array.isArray(vcardArray)
+        || String(vcardArray[0]).toLowerCase() !== 'vcard'
+        || !Array.isArray(vcardArray[1]))
+        return true;
+    const entries = vcardArray[1];
+    if (entries.length > MAX_VCARD_ENTRIES)
+        return true;
+    return entries.slice(0, MAX_VCARD_ENTRIES).some((entry) => (!Array.isArray(entry)
+        || entry.length < 4
+        || typeof entry[0] !== 'string'
+        || !entry[0].trim()));
 }
 function normalizeLinks(links, maxLinks = MAX_RDAP_LINKS) {
-    if (!Array.isArray(links))
-        return [];
     const normalized = [];
+    if (links === undefined)
+        return { items: normalized, truncated: false };
+    if (!Array.isArray(links))
+        return { items: normalized, truncated: true };
+    let truncated = links.length > 100 || links.length > maxLinks;
     for (const linkValue of links.slice(0, 100)) {
-        if (!linkValue || typeof linkValue !== 'object' || Array.isArray(linkValue))
+        if (!linkValue || typeof linkValue !== 'object' || Array.isArray(linkValue)) {
+            truncated = true;
             continue;
+        }
         const link = linkValue;
         const href = boundedString(link.href, 2048);
-        if (!href)
+        if (!href) {
+            truncated = true;
             continue;
+        }
         try {
             const parsed = new URL(href);
-            if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:')
+            if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
+                truncated = true;
                 continue;
+            }
         }
         catch {
+            truncated = true;
             continue;
         }
+        const rel = boundedString(link.rel, 100, { lower: true });
+        const type = boundedString(link.type, 160, { lower: true });
+        const title = boundedString(link.title, 300);
+        if (link.rel !== undefined && !rel
+            || link.type !== undefined && !type
+            || link.title !== undefined && !title)
+            truncated = true;
         normalized.push({
-            rel: boundedString(link.rel, 100, { lower: true }),
+            rel,
             href,
-            type: boundedString(link.type, 160, { lower: true }),
-            title: boundedString(link.title, 300),
+            type,
+            title,
         });
         if (normalized.length >= maxLinks)
             break;
     }
-    return normalized;
+    return { items: normalized, truncated };
 }
 function normalizePublicIds(publicIds) {
-    if (!Array.isArray(publicIds))
-        return [];
     const normalized = [];
+    if (publicIds === undefined)
+        return { items: normalized, truncated: false };
+    if (!Array.isArray(publicIds))
+        return { items: normalized, truncated: true };
+    let truncated = publicIds.length > 100 || publicIds.length > 20;
     for (const itemValue of publicIds.slice(0, 100)) {
-        if (!itemValue || typeof itemValue !== 'object' || Array.isArray(itemValue))
+        if (!itemValue || typeof itemValue !== 'object' || Array.isArray(itemValue)) {
+            truncated = true;
             continue;
+        }
         const item = itemValue;
         const type = boundedString(item.type, 160);
         const identifier = boundedString(item.identifier, 300);
-        if (!type || !identifier)
+        if (!type || !identifier) {
+            truncated = true;
             continue;
+        }
         normalized.push({ type, identifier });
         if (normalized.length >= 20)
             break;
     }
-    return normalized;
+    return { items: normalized, truncated };
 }
 function normalizeStringList(value, maxItems, maxLength, { lower = false } = {}) {
+    if (value === undefined)
+        return { items: [], truncated: false };
     if (!Array.isArray(value))
-        return [];
+        return { items: [], truncated: true };
     const output = [];
     const seen = new Set();
-    for (const item of value.slice(0, Math.max(maxItems * 4, maxItems))) {
+    const inspectionLimit = Math.max(maxItems * 4, maxItems);
+    let truncated = value.length > inspectionLimit;
+    for (const item of value.slice(0, inspectionLimit)) {
         const normalized = boundedString(item, maxLength, { lower });
-        if (!normalized || seen.has(normalized.toLowerCase()))
+        if (!normalized) {
+            truncated = true;
+            continue;
+        }
+        if (seen.has(normalized.toLowerCase()))
             continue;
         seen.add(normalized.toLowerCase());
-        output.push(normalized);
-        if (output.length >= maxItems)
-            break;
+        if (output.length < maxItems)
+            output.push(normalized);
+        else
+            truncated = true;
     }
-    return output;
+    return { items: output, truncated };
 }
 function redactionLabel(value) {
     if (typeof value === 'string')
@@ -201,16 +292,36 @@ function redactionLabel(value) {
     const record = value;
     return boundedString(record.type, 160) || boundedString(record.description, 300);
 }
+function suppliedBoundedStringRejected(record, field, maxLength, options = {}) {
+    return Object.hasOwn(record, field) && boundedString(record[field], maxLength, options) === null;
+}
+function redactionLabelHasRejectedContent(value) {
+    if (typeof value === 'string')
+        return boundedString(value, 300) === null;
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return true;
+    const label = value;
+    const hasType = Object.hasOwn(label, 'type');
+    const hasDescription = Object.hasOwn(label, 'description');
+    return (!hasType && !hasDescription)
+        || (hasType && boundedString(label.type, 160) === null)
+        || (hasDescription && boundedString(label.description, 300) === null);
+}
 function normalizeRedactions(redacted) {
-    if (!Array.isArray(redacted))
+    if (redacted === undefined)
         return { redactions: [], redactionsTruncated: false };
+    if (!Array.isArray(redacted))
+        return { redactions: [], redactionsTruncated: true };
     const redactions = [];
     const candidates = redacted.slice(0, MAX_RDAP_REDACTIONS * 2);
     let stoppedAt = candidates.length;
+    let truncated = redacted.length > candidates.length;
     for (let index = 0; index < candidates.length; index += 1) {
         const itemValue = candidates[index];
-        if (!itemValue || typeof itemValue !== 'object' || Array.isArray(itemValue))
+        if (!itemValue || typeof itemValue !== 'object' || Array.isArray(itemValue)) {
+            truncated = true;
             continue;
+        }
         const item = itemValue;
         const entry = {
             name: redactionLabel(item.name),
@@ -221,8 +332,19 @@ function normalizeRedactions(redacted) {
             postPath: boundedString(item.postPath, 512),
             replacementPath: boundedString(item.replacementPath, 512),
         };
-        if (!Object.values(entry).some(Boolean))
+        if (Object.hasOwn(item, 'name') && redactionLabelHasRejectedContent(item.name)
+            || Object.hasOwn(item, 'reason') && redactionLabelHasRejectedContent(item.reason)
+            || suppliedBoundedStringRejected(item, 'method', 80, { lower: true })
+            || suppliedBoundedStringRejected(item, 'pathLang', 80, { lower: true })
+            || suppliedBoundedStringRejected(item, 'prePath', 512)
+            || suppliedBoundedStringRejected(item, 'postPath', 512)
+            || suppliedBoundedStringRejected(item, 'replacementPath', 512)) {
+            truncated = true;
+        }
+        if (!Object.values(entry).some(Boolean)) {
+            truncated = true;
             continue;
+        }
         redactions.push(entry);
         if (redactions.length >= MAX_RDAP_REDACTIONS) {
             stoppedAt = index + 1;
@@ -231,38 +353,58 @@ function normalizeRedactions(redacted) {
     }
     return {
         redactions,
-        redactionsTruncated: stoppedAt < redacted.length,
+        redactionsTruncated: truncated || stoppedAt < redacted.length,
     };
 }
 function normalizeDomainVariants(value) {
-    if (!Array.isArray(value))
+    if (value === undefined)
         return { variants: [], variantsTruncated: false };
+    if (!Array.isArray(value))
+        return { variants: [], variantsTruncated: true };
     const variants = [];
     let truncated = value.length > MAX_RDAP_VARIANT_GROUPS;
     for (const groupValue of value.slice(0, MAX_RDAP_VARIANT_GROUPS)) {
-        if (!groupValue || typeof groupValue !== 'object' || Array.isArray(groupValue))
+        if (!groupValue || typeof groupValue !== 'object' || Array.isArray(groupValue)) {
+            truncated = true;
             continue;
+        }
         const group = groupValue;
         const sourceNames = Array.isArray(group.variantNames) ? group.variantNames : [];
+        if (group.variantNames !== undefined && !Array.isArray(group.variantNames))
+            truncated = true;
         const variantNames = [];
         for (const nameValue of sourceNames.slice(0, MAX_RDAP_VARIANT_NAMES * 2)) {
-            if (!nameValue || typeof nameValue !== 'object' || Array.isArray(nameValue))
+            if (!nameValue || typeof nameValue !== 'object' || Array.isArray(nameValue)) {
+                truncated = true;
                 continue;
+            }
             const name = nameValue;
             const ldhName = boundedString(name.ldhName, 253);
             const unicodeName = boundedString(name.unicodeName, 253);
-            if (!ldhName && !unicodeName)
+            if (suppliedBoundedStringRejected(name, 'ldhName', 253)
+                || suppliedBoundedStringRejected(name, 'unicodeName', 253))
+                truncated = true;
+            if (!ldhName && !unicodeName) {
+                truncated = true;
                 continue;
+            }
             variantNames.push({ ldhName, unicodeName });
             if (variantNames.length >= MAX_RDAP_VARIANT_NAMES)
                 break;
         }
         if (sourceNames.length > MAX_RDAP_VARIANT_NAMES)
             truncated = true;
-        const relation = normalizeStringList(group.relation, 20, 100, { lower: true });
+        const relationInfo = normalizeStringList(group.relation, 20, 100, { lower: true });
+        if (relationInfo.truncated)
+            truncated = true;
+        const relation = relationInfo.items;
         const idnTable = boundedString(group.idnTable, 300);
-        if (!variantNames.length && !relation.length && !idnTable)
+        if (group.idnTable !== undefined && !idnTable)
+            truncated = true;
+        if (!variantNames.length && !relation.length && !idnTable) {
+            truncated = true;
             continue;
+        }
         variants.push({ relation, idnTable, variantNames });
     }
     return { variants, variantsTruncated: truncated };
@@ -279,36 +421,50 @@ function textWouldTruncate(value, maxLength) {
     return value.replace(/\s+/g, ' ').trim().length > maxLength;
 }
 function summarizeTextBlocks(blocks) {
-    if (!Array.isArray(blocks))
-        return { items: [], truncated: false };
     const output = [];
+    if (blocks === undefined)
+        return { items: output, truncated: false };
+    if (!Array.isArray(blocks))
+        return { items: output, truncated: true };
     let truncated = blocks.length > 50;
     for (const blockValue of blocks.slice(0, 50)) {
-        if (!blockValue || typeof blockValue !== 'object' || Array.isArray(blockValue))
+        if (!blockValue || typeof blockValue !== 'object' || Array.isArray(blockValue)) {
+            truncated = true;
             continue;
+        }
         const block = blockValue;
         const descriptions = [];
         const sourceDescriptions = Array.isArray(block.description) ? block.description : [];
+        if (!Array.isArray(block.description))
+            truncated = true;
         if (sourceDescriptions.length > 20)
             truncated = true;
         for (const text of sourceDescriptions.slice(0, 20)) {
             if (textWouldTruncate(text, 800))
                 truncated = true;
             const description = truncatedText(text, 800);
-            if (!description)
+            if (!description) {
+                truncated = true;
                 continue;
+            }
             if (descriptions.length < 6)
                 descriptions.push(description);
             else
                 truncated = true;
         }
-        if (!descriptions.length)
+        if (!descriptions.length) {
+            truncated = true;
             continue;
+        }
         if (textWouldTruncate(block.title, 160))
             truncated = true;
+        const title = truncatedText(block.title, 160);
+        const type = boundedString(block.type, 160, { lower: true });
+        if (block.title !== undefined && !title || block.type !== undefined && !type)
+            truncated = true;
         const item = {
-            title: truncatedText(block.title, 160) || 'Notice',
-            type: boundedString(block.type, 160, { lower: true }),
+            title: title || 'Notice',
+            type,
             descriptions,
         };
         if (output.length < 12)
@@ -369,9 +525,10 @@ function lifecycleDate(events, action, newest) {
     for (const event of events) {
         if (event.action !== action || !event.date)
             continue;
-        const time = Date.parse(event.date);
-        if (!Number.isFinite(time))
+        const normalized = registryDateIso(event.date);
+        if (!normalized)
             continue;
+        const time = Date.parse(normalized);
         if ((newest && time > selectedTime) || (!newest && time < selectedTime)) {
             selected = event.date;
             selectedTime = time;
@@ -407,16 +564,25 @@ function summarizeEntity(entity) {
         return null;
     const record = entity;
     const roles = [];
+    let rolesTruncated = record.roles !== undefined && !Array.isArray(record.roles);
     if (Array.isArray(record.roles)) {
+        if (record.roles.length > MAX_ENTITY_ROLES)
+            rolesTruncated = true;
         for (const rawRole of record.roles.slice(0, 100)) {
             const role = boundedString(rawRole, 80, { lower: true });
-            if (!role || roles.includes(role))
+            if (!role) {
+                rolesTruncated = true;
+                continue;
+            }
+            if (roles.includes(role))
                 continue;
             roles.push(role);
             if (roles.length >= MAX_ENTITY_ROLES)
                 break;
         }
     }
+    const handle = boundedString(record.handle, 200);
+    const handleTruncated = record.handle !== undefined && handle === null;
     const names = normalizeContactValues(record.vcardArray, 'fn', 300);
     const organizations = normalizeContactValues(record.vcardArray, 'org', 300);
     const emails = normalizeContactValues(record.vcardArray, 'email', 320, { lower: true });
@@ -425,8 +591,10 @@ function summarizeEntity(entity) {
     const vcardEntries = Array.isArray(record.vcardArray) && Array.isArray(record.vcardArray[1])
         ? record.vcardArray[1]
         : [];
+    const publicIds = normalizePublicIds(record.publicIds);
+    const links = normalizeLinks(record.links, MAX_ENTITY_LINKS);
     const summary = {
-        handle: boundedString(record.handle, 200),
+        handle,
         roles,
         name: names[0] || null,
         names,
@@ -438,13 +606,15 @@ function summarizeEntity(entity) {
         phones,
         address: addresses[0] || null,
         addresses,
-        publicIds: normalizePublicIds(record.publicIds),
-        links: normalizeLinks(record.links, MAX_ENTITY_LINKS),
-        truncated: Boolean((Array.isArray(record.roles) && record.roles.length > MAX_ENTITY_ROLES)
+        publicIds: publicIds.items,
+        links: links.items,
+        truncated: Boolean(rolesTruncated
+            || handleTruncated
             || vcardEntries.length > MAX_VCARD_ENTRIES
+            || malformedVcardEvidence(record.vcardArray)
             || contactValuesTruncated(record.vcardArray)
-            || (Array.isArray(record.publicIds) && record.publicIds.length > 20)
-            || (Array.isArray(record.links) && record.links.length > MAX_ENTITY_LINKS)),
+            || publicIds.truncated
+            || links.truncated),
     };
     const hasAny = Boolean(summary.handle || summary.name || summary.org || summary.email
         || summary.phone || summary.address || summary.publicIds.length || summary.links.length);
@@ -453,7 +623,8 @@ function summarizeEntity(entity) {
 function summarizeEntities(entities) {
     const summaries = [];
     const source = Array.isArray(entities) ? entities : [];
-    let truncated = source.length > MAX_RDAP_ENTITIES;
+    let truncated = entities !== undefined && !Array.isArray(entities)
+        || source.length > MAX_RDAP_ENTITIES;
     const stack = source
         .slice(0, MAX_RDAP_ENTITIES)
         .reverse()
@@ -465,15 +636,26 @@ function summarizeEntities(entities) {
         if (!current)
             continue;
         const { entity, depth } = current;
-        if (!entity || typeof entity !== 'object' || Array.isArray(entity) || seen.has(entity))
+        if (!entity || typeof entity !== 'object' || Array.isArray(entity) || seen.has(entity)) {
+            truncated = true;
             continue;
+        }
         seen.add(entity);
         visited += 1;
         const summary = summarizeEntity(entity);
         if (summary)
             summaries.push(summary);
+        else
+            truncated = true;
         const record = entity;
-        if (depth >= MAX_RDAP_ENTITY_DEPTH || !Array.isArray(record.entities))
+        if (depth >= MAX_RDAP_ENTITY_DEPTH) {
+            if (Array.isArray(record.entities) && record.entities.length)
+                truncated = true;
+            continue;
+        }
+        if (record.entities !== undefined && !Array.isArray(record.entities))
+            truncated = true;
+        if (!Array.isArray(record.entities))
             continue;
         const remaining = Math.max(0, MAX_RDAP_ENTITIES - visited - stack.length);
         const nested = record.entities.slice(0, remaining);
@@ -519,6 +701,8 @@ function parseRdapObject(type, data) {
     const redactionInfo = normalizeRedactions(data.redacted);
     const noticesInfo = summarizeTextBlocks(data.notices);
     const remarksInfo = summarizeTextBlocks(data.remarks);
+    const linksInfo = normalizeLinks(data.links);
+    const conformanceInfo = normalizeStringList(data.rdapConformance, 50, 160, { lower: true });
     const serverTruncationReasons = summarizeServerTruncation(data.notices, data.remarks);
     // Preserve the established status-array contract while making it available
     // to every RDAP object type. Unlike set-like fields, status order and
@@ -528,16 +712,18 @@ function parseRdapObject(type, data) {
             .map((status) => boundedString(status, 160))
             .filter((status) => status !== null)
         : [];
+    const inspectedStatusCount = Array.isArray(data.status) ? Math.min(data.status.length, 100) : 0;
+    const inspectedEventCount = Array.isArray(data.events) ? Math.min(data.events.length, 100) : 0;
     const common = {
         objectClassName: boundedString(data.objectClassName, 80, { lower: true }),
         language: boundedString(data.lang, 35, { lower: true }),
-        conformance: normalizeStringList(data.rdapConformance, 50, 160, { lower: true }),
-        conformanceTruncated: Array.isArray(data.rdapConformance) && data.rdapConformance.length > 50,
+        conformance: conformanceInfo.items,
+        conformanceTruncated: conformanceInfo.truncated,
         ...redactionInfo,
         port43: boundedString(data.port43, 300),
         parentHandle: boundedString(data.parentHandle, 300),
-        links: normalizeLinks(data.links),
-        linksTruncated: Array.isArray(data.links) && data.links.length > MAX_RDAP_LINKS,
+        links: linksInfo.items,
+        linksTruncated: linksInfo.truncated,
         notices: noticesInfo.items,
         noticesTruncated: noticesInfo.truncated,
         remarks: remarksInfo.items,
@@ -545,33 +731,70 @@ function parseRdapObject(type, data) {
         serverTruncated: serverTruncationReasons.length > 0,
         serverTruncationReasons,
         statuses,
-        statusesTruncated: Array.isArray(data.status) && data.status.length > 100,
+        statusesTruncated: data.status !== undefined && (!Array.isArray(data.status)
+            || data.status.length > 100
+            || statuses.length < inspectedStatusCount),
         events,
-        eventsTruncated: Array.isArray(data.events) && data.events.length > 100,
+        eventsTruncated: data.events !== undefined && (!Array.isArray(data.events)
+            || data.events.length > 100
+            || events.length < inspectedEventCount),
         lifecycle: summarizeLifecycle(events),
     };
     if (type === 'domain') {
         const { entitiesByRole, entitiesTruncated, truncatedEntityRoles } = entityInventory(data.entities);
         const registrarEntity = entitiesByRole.registrar && entitiesByRole.registrar[0];
         let nameserverAddressesTruncated = false;
+        let invalidNameservers = 0;
         const nameserverDetails = Array.isArray(data.nameservers)
             ? data.nameservers.slice(0, 200).map((ns) => {
-                if (!ns || typeof ns !== 'object' || Array.isArray(ns))
+                if (!ns || typeof ns !== 'object' || Array.isArray(ns)) {
+                    invalidNameservers += 1;
                     return null;
+                }
                 const nameserver = ns;
-                const ipAddresses = nameserver.ipAddresses && typeof nameserver.ipAddresses === 'object' && !Array.isArray(nameserver.ipAddresses)
+                const validIpAddresses = nameserver.ipAddresses !== null
+                    && typeof nameserver.ipAddresses === 'object'
+                    && !Array.isArray(nameserver.ipAddresses);
+                const ipAddresses = validIpAddresses
                     ? nameserver.ipAddresses
                     : {};
+                if (nameserver.ipAddresses !== undefined && !validIpAddresses) {
+                    nameserverAddressesTruncated = true;
+                }
                 const v4 = Array.isArray(ipAddresses.v4) ? ipAddresses.v4 : [];
                 const v6 = Array.isArray(ipAddresses.v6) ? ipAddresses.v6 : [];
-                if (v4.length + v6.length > 20)
+                if (ipAddresses.v4 !== undefined && !Array.isArray(ipAddresses.v4)
+                    || ipAddresses.v6 !== undefined && !Array.isArray(ipAddresses.v6)) {
+                    nameserverAddressesTruncated = true;
+                }
+                const maximumCandidates = 200;
+                const maximumAddresses = 20;
+                const addresses = [];
+                let visited = 0;
+                for (const [candidates, family] of [[v4, 4], [v6, 6]]) {
+                    for (let index = 0; index < candidates.length; index += 1) {
+                        if (visited >= maximumCandidates || addresses.length >= maximumAddresses)
+                            break;
+                        visited += 1;
+                        const address = boundedString(candidates[index], 80);
+                        if (address && net.isIP(address) === family)
+                            addresses.push(address);
+                        else
+                            nameserverAddressesTruncated = true;
+                    }
+                    if (visited >= maximumCandidates || addresses.length >= maximumAddresses)
+                        break;
+                }
+                if (v4.length + v6.length > visited || v4.length + v6.length > maximumAddresses) {
                     nameserverAddressesTruncated = true;
-                const addresses = [
-                    ...v4.map((address) => boundedString(address, 80)).filter((address) => address && net.isIP(address) === 4),
-                    ...v6.map((address) => boundedString(address, 80)).filter((address) => address && net.isIP(address) === 6),
-                ].slice(0, 20);
+                }
+                const name = boundedString(nameserver.ldhName || nameserver.unicodeName, 253);
+                if (!name) {
+                    invalidNameservers += 1;
+                    return null;
+                }
                 return {
-                    name: boundedString(nameserver.ldhName || nameserver.unicodeName, 253),
+                    name,
                     addresses,
                 };
             }).filter((ns) => Boolean(ns?.name))
@@ -582,10 +805,13 @@ function parseRdapObject(type, data) {
             ? data.secureDNS
             : null;
         const variantInfo = normalizeDomainVariants(data.variants);
+        let invalidDsData = 0;
         const dsData = secureDns && Array.isArray(secureDns.dsData)
             ? secureDns.dsData.slice(0, 50).map((ds) => {
-                if (!ds || typeof ds !== 'object' || Array.isArray(ds))
+                if (!ds || typeof ds !== 'object' || Array.isArray(ds)) {
+                    invalidDsData += 1;
                     return null;
+                }
                 const record = ds;
                 const digest = boundedString(record.digest, 512);
                 const normalized = {
@@ -593,9 +819,11 @@ function parseRdapObject(type, data) {
                     digestType: boundedInteger(record.digestType, 0, 255),
                     digest: digest && digest.length % 2 === 0 && /^[0-9a-f]+$/i.test(digest) ? digest : null,
                 };
-                return Object.values(normalized).every((value) => value !== null)
-                    ? normalized
-                    : null;
+                if (Object.values(normalized).every((value) => value !== null)) {
+                    return normalized;
+                }
+                invalidDsData += 1;
+                return null;
             }).filter((value) => value !== null)
             : [];
         return {
@@ -606,7 +834,9 @@ function parseRdapObject(type, data) {
             handle: boundedString(data.handle, 300),
             nameservers: nameserverDetails.map((ns) => ns.name),
             nameserverDetails,
-            nameserversTruncated: Array.isArray(data.nameservers) && data.nameservers.length > 200,
+            nameserversTruncated: data.nameservers !== undefined && (!Array.isArray(data.nameservers)
+                || data.nameservers.length > 200
+                || invalidNameservers > 0),
             nameserverAddressesTruncated,
             dnssec: secureDns && secureDns.delegationSigned === true
                 ? 'Signed' : secureDns && secureDns.delegationSigned === false ? 'Unsigned' : 'Unknown',
@@ -614,7 +844,10 @@ function parseRdapObject(type, data) {
             delegationSigned: secureDns && typeof secureDns.delegationSigned === 'boolean'
                 ? secureDns.delegationSigned : null,
             dsData,
-            dsDataTruncated: Boolean(secureDns && Array.isArray(secureDns.dsData) && secureDns.dsData.length > 50),
+            dsDataTruncated: Boolean(data.secureDNS !== undefined && !secureDns
+                || secureDns && secureDns.dsData !== undefined && (!Array.isArray(secureDns.dsData)
+                    || secureDns.dsData.length > 50
+                    || invalidDsData > 0)),
             ...variantInfo,
             registrarIanaId: publicId(registrarEntity, /iana registrar id/i),
             entitiesByRole,
@@ -630,17 +863,26 @@ function parseRdapObject(type, data) {
     }
     if (type === 'ipv4' || type === 'ipv6') {
         const { entitiesByRole, entitiesTruncated, truncatedEntityRoles } = entityInventory(data.entities);
+        let invalidCidrs = 0;
         const cidrs = Array.isArray(data.cidr0_cidrs)
             ? data.cidr0_cidrs.slice(0, 200)
                 .map((c) => {
-                if (!c || typeof c !== 'object' || Array.isArray(c))
+                if (!c || typeof c !== 'object' || Array.isArray(c)) {
+                    invalidCidrs += 1;
                     return null;
+                }
                 const expectedFamily = type === 'ipv4' ? 4 : 6;
                 const prefix = boundedString(expectedFamily === 4 ? c.v4prefix : c.v6prefix, 80);
-                if (!prefix || net.isIP(prefix) !== expectedFamily)
+                if (!prefix || net.isIP(prefix) !== expectedFamily) {
+                    invalidCidrs += 1;
                     return null;
+                }
                 const length = boundedInteger(c.length, 0, expectedFamily === 4 ? 32 : 128);
-                return prefix && length !== null ? `${prefix}/${length}` : null;
+                if (length === null) {
+                    invalidCidrs += 1;
+                    return null;
+                }
+                return `${prefix}/${length}`;
             })
                 .filter((value) => value !== null)
             : [];
@@ -651,7 +893,9 @@ function parseRdapObject(type, data) {
             startAddress: boundedString(data.startAddress, 80),
             endAddress: boundedString(data.endAddress, 80),
             cidrs,
-            cidrsTruncated: Array.isArray(data.cidr0_cidrs) && data.cidr0_cidrs.length > 200,
+            cidrsTruncated: data.cidr0_cidrs !== undefined && (!Array.isArray(data.cidr0_cidrs)
+                || data.cidr0_cidrs.length > 200
+                || invalidCidrs > 0),
             country: boundedString(data.country, 2),
             networkType: boundedString(data.type, 160),
             entitiesByRole,