@slicedearth/whoisleuth-cli 1.45.0 → 1.47.4

package/lib/evidence-report-markdown.mjs

@@ -63,6 +63,9 @@ function formatLookupEvidenceMarkdown(document, options = {}) {
     lines.push('', '## Limitations', '');
     for (const limitation of report.limitations)
         lines.push(`- ${limitation}`);
+    if (report.attribution) {
+        lines.push('', '---', '', report.attribution);
+    }
     lines.push('');
     return lines.join('\n');
 }

package/lib/evidence-report.mjs

@@ -1,4 +1,5 @@
 import { registryAccessProfileLabel } from "./registry-access.mjs";
+import { buildPortableGeneratorMetadata, portableGeneratorAttribution, } from "./portable-generator.mjs";
 const MAX_REPORT_VALUE_LENGTH = 300;
 const MAX_REPORT_LIST_ITEMS = 50;
 const MAX_REPORT_COMPARISON_FIELDS = 20;
@@ -90,6 +91,7 @@ function reportField(label, value, fallback = 'Not reported') {
 function buildLookupEvidenceReport(document, options = {}) {
     const report = objectOrEmpty(document);
     const application = objectOrEmpty(report.application);
+    const generator = buildPortableGeneratorMetadata(application.version);
     const query = objectOrEmpty(report.query);
     const diagnostics = objectOrEmpty(report.diagnostics);
     const rdapDiagnostics = objectOrEmpty(diagnostics.rdap);
@@ -389,6 +391,9 @@ function buildLookupEvidenceReport(document, options = {}) {
                 'Registry access constraints describe collection reachability only. They do not decide registration, availability, ownership, safety, or maliciousness.',
             ] : []),
         ],
+        attribution: options.includeAttribution === false
+            ? null
+            : portableGeneratorAttribution(generator),
     };
 }
 export { MAX_REPORT_COMPARISON_FIELDS, MAX_REPORT_LIST_ITEMS, MAX_REPORT_RISK_FACTORS, MAX_REPORT_VALUE_LENGTH, buildLookupEvidenceReport, cleanReportText, };

package/lib/favicon.mjs

@@ -73,13 +73,13 @@ function decodeDataUri(uri) {
 }
 // Returns the favicon bytes for one candidate URL (a real fetch, or an inline
 // data: decode), or null if it can't be retrieved/used.
-async function fetchFaviconBytes(url, headers) {
+async function fetchFaviconBytes(url, headers, fetcher, timeoutMs) {
     if (/^data:/i.test(url))
         return decodeDataUri(url);
     const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), FAVICON_FETCH_TIMEOUT_MS);
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
     try {
-        const res = await safeFetch(url, { signal: controller.signal, headers });
+        const res = await fetcher(url, { signal: controller.signal, headers });
         if (!res.ok) {
             // Not reading this body - release it explicitly instead of leaving an
             // unconsumed stream (and the connection it's tied to) open until
@@ -123,12 +123,15 @@ function buildFaviconCandidates(domain, html = '') {
     add(`http://${domain}/favicon.svg`);
     return candidates.slice(0, MAX_FAVICON_CANDIDATES);
 }
-async function fetchFaviconHash(domain, { html = '' } = {}) {
+async function fetchFaviconHash(domain, { html = '', fetcher = safeFetch, timeoutMs = FAVICON_FETCH_TIMEOUT_MS } = {}) {
     const headers = whoisleuthRequestHeaders();
     const candidates = buildFaviconCandidates(domain, html);
+    const requestTimeoutMs = Number.isInteger(timeoutMs) && timeoutMs >= 10 && timeoutMs <= FAVICON_FETCH_TIMEOUT_MS
+        ? timeoutMs
+        : FAVICON_FETCH_TIMEOUT_MS;
     for (const url of candidates) {
         // eslint-disable-next-line no-await-in-loop
-        const bytes = await fetchFaviconBytes(url, headers);
+        const bytes = await fetchFaviconBytes(url, headers, fetcher, requestTimeoutMs);
         if (bytes) {
             return {
                 hash: crypto.createHash('sha256').update(bytes).digest('hex'),

package/lib/http-evidence-bounds.mjs

@@ -2,3 +2,6 @@
 // browser-local projection. Both producers and consumers import these values
 // so valid retained evidence is not rejected by a stale projection.
 export const MAX_HTTP_EVIDENCE_REDIRECTS = 5;
+export const MAX_HTTP_ATTEMPTS = 2;
+export const MAX_HTTP_PROVENANCE_URL = 2_048;
+export const MAX_HTTP_ERROR_LENGTH = 180;

package/lib/http-intelligence.mjs

@@ -3,11 +3,8 @@
 // converts the shared safe-fetch trace and selected response metadata into an
 // additive evidence object suitable for API responses and exports.
 import { createObservation } from "./observation.mjs";
-import { MAX_HTTP_EVIDENCE_REDIRECTS } from "./http-evidence-bounds.mjs";
-const MAX_HTTP_PROVENANCE_URL = 2048;
+import { MAX_HTTP_ATTEMPTS, MAX_HTTP_ERROR_LENGTH, MAX_HTTP_EVIDENCE_REDIRECTS, MAX_HTTP_PROVENANCE_URL, } from "./http-evidence-bounds.mjs";
 const MAX_HTTP_REDIRECTS = MAX_HTTP_EVIDENCE_REDIRECTS;
-const MAX_HTTP_ATTEMPTS = 2;
-const MAX_HTTP_ERROR_LENGTH = 180;
 const MAX_HTTP_HEADER_LENGTH = 1024;
 const MAX_CAPTURED_BODY_BYTES = 5 * 1024 * 1024;
 const OBSERVED_HEADER_MARKER = 'observed';
@@ -230,4 +227,4 @@ function skippedHttpObservation() {
         response: null,
     };
 }
-export { MAX_HTTP_PROVENANCE_URL, MAX_HTTP_REDIRECTS, MAX_HTTP_ATTEMPTS, normalizeProvenanceUrl, buildHttpObservation, failedHttpObservation, skippedHttpObservation, };
+export { MAX_HTTP_ERROR_LENGTH, MAX_HTTP_PROVENANCE_URL, MAX_HTTP_REDIRECTS, MAX_HTTP_ATTEMPTS, normalizeProvenanceUrl, buildHttpObservation, failedHttpObservation, skippedHttpObservation, };

package/lib/interchange-fidelity-registry.mjs

@@ -0,0 +1,122 @@
+const exact = Object.freeze(['domain_identity', 'dns_control_expectations', 'certificate_control_expectations', 'registrar_control_expectations', 'renewal_review']);
+export const INTERCHANGE_ARTIFACT_CONTRACTS = Object.freeze([
+    Object.freeze({
+        id: 'lookup_claim_passport',
+        schema: 'whoisleuth.lookup-claim-passport',
+        versions: Object.freeze([1]),
+        versionField: 'version',
+        nestedSchemaPath: Object.freeze([]),
+        browser: Object.freeze({ import: 'unsupported', export: 'supported' }),
+        cli: Object.freeze({ read: 'supported', write: 'unsupported', verify: 'supported' }),
+        fidelity: 'semantic_exact_after_normalisation',
+        requiredAssurance: 'whole_integrity',
+        preservedFieldGroups: Object.freeze(['target_identity', 'claim_identity', 'evidence_requirement_ids', 'source_states', 'observation_times', 'model_versions', 'limitations']),
+        excludedFieldGroups: Object.freeze(['raw_registry_payloads', 'contacts', 'page_values', 'request_paths', 'credentials', 'browser_local_records', 'signer_authentication']),
+        futureVersionBehaviour: 'reject',
+    }),
+    Object.freeze({
+        id: 'lookup_evidence',
+        schema: LOOKUP_EVIDENCE_SCHEMA,
+        versions: Object.freeze([...SUPPORTED_LOOKUP_EVIDENCE_SCHEMA_VERSIONS]),
+        versionField: 'schemaVersion',
+        nestedSchemaPath: Object.freeze([]),
+        browser: Object.freeze({ import: 'supported', export: 'supported' }),
+        cli: Object.freeze({ read: 'supported', write: 'supported', verify: 'supported' }),
+        fidelity: 'lossy_by_design',
+        requiredAssurance: 'structure',
+        preservedFieldGroups: Object.freeze(['query_context', 'generator_metadata', 'source_health', 'normalised_registration_evidence', 'bounded_replay_facts', 'observation_times', 'limitations']),
+        excludedFieldGroups: Object.freeze(['browser_local_records', 'case_context', 'brand_profiles', 'credentials', 'session_material', 'request_headers', 'cookies', 'signer_authentication', 'raw_payload_rendering_during_replay']),
+        futureVersionBehaviour: 'reject',
+    }),
+    Object.freeze({
+        id: 'domain_control_passport',
+        schema: 'whoisleuth.domain-control-manifest',
+        versions: Object.freeze([1, 2]),
+        versionField: 'version',
+        nestedSchemaPath: Object.freeze([]),
+        browser: Object.freeze({ import: 'supported', export: 'supported' }),
+        cli: Object.freeze({ read: 'supported', write: 'supported', verify: 'supported' }),
+        fidelity: 'semantic_exact_after_normalisation',
+        requiredAssurance: 'whole_integrity',
+        preservedFieldGroups: exact,
+        excludedFieldGroups: Object.freeze(['profile_identity', 'brand_context', 'contacts', 'notes', 'observations', 'planning_context', 'suppression_context']),
+        futureVersionBehaviour: 'reject',
+    }),
+    Object.freeze({
+        id: 'brand_profiles',
+        schema: 'whoisleuth.brand-profiles',
+        versions: Object.freeze([2, 3, 4, 5, 6]),
+        versionField: 'version',
+        nestedSchemaPath: Object.freeze([]),
+        browser: Object.freeze({ import: 'supported', export: 'supported' }),
+        cli: Object.freeze({ read: 'supported', write: 'unsupported', verify: 'verification_only' }),
+        fidelity: 'normalised_merge',
+        requiredAssurance: 'structure',
+        preservedFieldGroups: Object.freeze(['profile_identity', 'brand_context', 'domain_scope', 'mail_posture', 'desired_posture', 'reviewed_planning', 'retained_observations']),
+        excludedFieldGroups: Object.freeze(['login_sessions', 'credentials', 'raw_upstream_payloads']),
+        futureVersionBehaviour: 'reject',
+    }),
+    Object.freeze({
+        id: 'workspace',
+        schema: 'whoisleuth.workspace-archive',
+        versions: Object.freeze([1, 2, 3, 4, 5]),
+        versionField: 'version',
+        nestedSchemaPath: Object.freeze([]),
+        browser: Object.freeze({ import: 'supported', export: 'supported' }),
+        cli: Object.freeze({ read: 'verification_only', write: 'unsupported', verify: 'supported' }),
+        fidelity: 'normalised_merge',
+        requiredAssurance: 'whole_integrity',
+        preservedFieldGroups: Object.freeze(['supported_workspace_sections', 'section_versions', 'section_checksums', 'merge_metadata']),
+        excludedFieldGroups: Object.freeze(['login_sessions', 'credentials', 'hosted_monitor_keys', 'raw_upstream_payloads', 'tab_state']),
+        futureVersionBehaviour: 'reject',
+    }),
+    Object.freeze({
+        id: 'encrypted_workspace',
+        schema: 'whoisleuth.encrypted-workspace-archive',
+        versions: Object.freeze([1]),
+        versionField: 'version',
+        nestedSchemaPath: Object.freeze([]),
+        browser: Object.freeze({ import: 'supported', export: 'supported' }),
+        cli: Object.freeze({ read: 'verification_only', write: 'unsupported', verify: 'supported' }),
+        fidelity: 'verification_only',
+        requiredAssurance: 'authenticated_whole_integrity',
+        preservedFieldGroups: Object.freeze(['encrypted_workspace_envelope', 'authenticated_ciphertext', 'inner_workspace_after_decryption']),
+        excludedFieldGroups: Object.freeze(['passphrase', 'derived_key']),
+        futureVersionBehaviour: 'reject',
+    }),
+    Object.freeze({
+        id: 'case_pack',
+        schema: 'whoisleuth.cli.case-pack',
+        versions: Object.freeze([1, 2]),
+        versionField: 'version',
+        nestedSchemaPath: Object.freeze(['packet']),
+        browser: Object.freeze({ import: 'supported', export: 'unsupported' }),
+        cli: Object.freeze({ read: 'supported', write: 'supported', verify: 'supported' }),
+        fidelity: 'lossy_by_design',
+        requiredAssurance: 'whole_integrity',
+        preservedFieldGroups: Object.freeze(['redacted_case_collection', 'case_schema_version', 'trusted_internal_case_brand_profile_references']),
+        excludedFieldGroups: Object.freeze(['package_reports', 'package_redaction_manifest', 'package_integrity_envelope', 'audience_excluded_case_fields', 'public_audience_case_brand_profile_references']),
+        futureVersionBehaviour: 'reject',
+    }),
+    Object.freeze({
+        id: 'legacy_desired_baseline',
+        schema: 'whoisleuth.desired-posture-baseline',
+        versions: Object.freeze([1]),
+        versionField: 'schemaVersion',
+        nestedSchemaPath: Object.freeze([]),
+        browser: Object.freeze({ import: 'unsupported', export: 'unsupported' }),
+        cli: Object.freeze({ read: 'unsupported', write: 'unsupported', verify: 'unsupported' }),
+        fidelity: 'unsupported',
+        requiredAssurance: 'unsupported',
+        preservedFieldGroups: Object.freeze([]),
+        excludedFieldGroups: Object.freeze(['entire_legacy_document']),
+        futureVersionBehaviour: 'reject',
+    }),
+]);
+export function interchangeContractFor(id) {
+    const contract = INTERCHANGE_ARTIFACT_CONTRACTS.find((item) => item.id === id);
+    if (!contract)
+        throw new TypeError('Interchange contract is not registered.');
+    return contract;
+}
+import { LOOKUP_EVIDENCE_SCHEMA, SUPPORTED_LOOKUP_EVIDENCE_SCHEMA_VERSIONS, } from "./evidence-export.mjs";

package/lib/local-geoip-evidence.mjs

@@ -64,8 +64,9 @@ function lookupLocalGeoIp(database, address) {
         return Object.freeze({ state: 'invalid', address: null, match: null, source: null, limitations: Object.freeze([]) });
     }
     const match = database.records.find((item) => prefixContains(item.parsedNetwork, target)) ?? null;
+    const incomplete = database.truncated || database.rejectedCount > 0;
     return Object.freeze({
-        state: match ? database.truncated || database.rejectedCount > 0 ? 'partial' : 'matched' : 'not_found',
+        state: match ? incomplete ? 'partial' : 'matched' : incomplete ? 'partial' : 'not_found',
         address: normalized,
         match: match ? Object.freeze({
             network: match.network,

package/lib/lookup-network-evidence-bounds.mjs

@@ -0,0 +1,9 @@
+// Browser-safe collection bounds shared by the network evidence producers,
+// the Lookup response trust boundary, and the display projection.
+export const MAX_LOOKUP_DNS_RECORDS_PER_TYPE = 16;
+export const MAX_LOOKUP_REVERSE_DNS_PTR_RECORDS = 8;
+export const MAX_LOOKUP_TLS_CHAIN_CERTIFICATES = 8;
+export const MAX_LOOKUP_TLS_ALT_NAMES = 50;
+export const MAX_LOOKUP_TLS_NAME_VALUES = 4;
+export const MAX_LOOKUP_TLS_FINDINGS = 5;
+export const MAX_LOOKUP_TLS_CERTIFICATE_POLICIES = 16;