@orangecheck/sdk 0.1.1 → 0.1.3

package/dist/index.js

@@ -3,6 +3,9 @@
 var buffer = require('buffer');
 var bip322Js = require('bip322-js');
 var bitcoinMessage = require('bitcoinjs-message');
+var secp256k1_js = require('@noble/curves/secp256k1.js');
+var sha2_js = require('@noble/hashes/sha2.js');
+var base = require('@scure/base');
 
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -37,15 +40,27 @@ function randomNonce16BHexLower() {
     }
   } catch {
   }
-  for (let i = 0; i < arr.length; i++) {
-    arr[i] = Math.floor(Math.random() * 256);
+  throw new Error("crypto.getRandomValues unavailable \u2014 refusing to mint a weak nonce");
+}
+var IDENTITY_PROTOCOL_RE = /^[a-z][a-z0-9_-]*$/;
+var IDENTITY_FORBIDDEN_CHARS = /[\r\n,]/;
+function assertSafeIdentity({ protocol, identifier }) {
+  if (!IDENTITY_PROTOCOL_RE.test(protocol)) {
+    throw new Error(
+      `invalid identity protocol: ${JSON.stringify(protocol)} \u2014 must match /^[a-z][a-z0-9_-]*$/`
+    );
+  }
+  if (!identifier || IDENTITY_FORBIDDEN_CHARS.test(identifier)) {
+    throw new Error(
+      `invalid identity identifier: ${JSON.stringify(identifier)} \u2014 must be non-empty and contain no newlines or commas`
+    );
   }
-  return toLowerHex(arr);
 }
 function formatIdentities(identities = []) {
   if (identities.length === 0) {
     return "";
   }
+  for (const id of identities) assertSafeIdentity(id);
   const formatted = identities.map(({ protocol, identifier }) => `${protocol}:${identifier}`).sort();
   return formatted.join(",");
 }
@@ -53,7 +68,10 @@ function parseIdentities(identitiesStr) {
   if (!identitiesStr || identitiesStr.trim() === "") {
     return [];
   }
-  return identitiesStr.split(",").map((binding) => {
+  if (IDENTITY_FORBIDDEN_CHARS.test(identitiesStr.replace(/,/g, ""))) {
+    throw new Error("identities field contains forbidden characters (newline)");
+  }
+  const bindings = identitiesStr.split(",").map((binding) => {
     const colonIndex = binding.indexOf(":");
     if (colonIndex === -1) {
       throw new Error(`Invalid identity binding format: ${binding}`);
@@ -62,7 +80,14 @@ function parseIdentities(identitiesStr) {
       protocol: binding.substring(0, colonIndex).trim(),
       identifier: binding.substring(colonIndex + 1).trim()
     };
-  }).filter((binding) => binding.protocol && binding.identifier);
+  });
+  for (const b of bindings) {
+    if (!b.protocol || !b.identifier) {
+      throw new Error(`Invalid identity binding: ${b.protocol}:${b.identifier}`);
+    }
+    assertSafeIdentity(b);
+  }
+  return bindings;
 }
 function buildCanonicalMessage({ address, identities }, extensions = {}) {
   const nonce = randomNonce16BHexLower();
@@ -230,16 +255,15 @@ async function publishToRelays(event, relays = DEFAULT_RELAYS) {
       ws = new WebSocket(relayUrl);
       const wsRef = ws;
       await new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
+        const deadline = setTimeout(() => {
           wsRef.close();
-          reject(new Error("Connection timeout"));
-        }, 5e3);
+          reject(new Error("Relay publish timeout"));
+        }, 1e4);
         const cleanup = () => {
-          clearTimeout(timeout);
+          clearTimeout(deadline);
           wsRef.close();
         };
         wsRef.onopen = () => {
-          clearTimeout(timeout);
           wsRef.send(JSON.stringify(["EVENT", event]));
         };
         wsRef.onmessage = (msg) => {
@@ -277,7 +301,7 @@ async function publishToRelays(event, relays = DEFAULT_RELAYS) {
           reject(err);
         };
         wsRef.onclose = () => {
-          clearTimeout(timeout);
+          clearTimeout(deadline);
         };
       });
     } catch (err) {
@@ -655,6 +679,24 @@ async function getAttestationsForIdentity(protocol, identifier, relays = DEFAULT
   log3.info({ protocol, identifier }, "Getting all attestations for identity");
   return discoverAttestations({ identity: { protocol, identifier }, relays });
 }
+function formatIdentitiesForDisplay(identities) {
+  return identities.map((id) => `${id.protocol}:${id.identifier}`).join(", ");
+}
+function getVerificationUrl(attestationId, baseUrl = "https://ochk.io") {
+  return `${baseUrl}/attest/${attestationId}`;
+}
+function extractAttestationIdFromUrl(url) {
+  try {
+    const u = new URL(url);
+    const m = u.pathname.match(/^\/attest\/([0-9a-f]{64})\/?$/i);
+    if (m) return m[1].toLowerCase();
+    const q = u.searchParams.get("id");
+    if (q && /^[0-9a-f]{64}$/i.test(q)) return q.toLowerCase();
+    return null;
+  } catch {
+    return null;
+  }
+}
 
 // src/scoring.ts
 function scoreV0(sats, days) {
@@ -681,9 +723,6 @@ function computeScore(sats, days, config) {
 
 // src/verify.ts
 var log4 = createLogger("ocp/verify");
-function scoreV02(sats, days) {
-  return computeScore(sats, days, { algorithm: "v0" });
-}
 function looksLikeHex(s) {
   return /^[0-9a-fA-F]+$/.test(s) && s.length % 2 === 0;
 }
@@ -799,7 +838,13 @@ async function verifySignature({
 }
 function parseCanonicalMessage(msg) {
   const lines = msg.split("\n").map((l) => l.trim());
-  const getVal = (prefix) => lines.find((l) => l.toLowerCase().startsWith(prefix + ":"))?.split(":", 2)[1]?.trim();
+  const getVal = (prefix) => {
+    const needle = prefix + ":";
+    const hit = lines.find((l) => l.toLowerCase().startsWith(needle));
+    if (!hit) return void 0;
+    const idx = hit.indexOf(":");
+    return hit.slice(idx + 1).trim();
+  };
   const address = getVal("address") || "";
   const identitiesStr = getVal("identities") || "";
   let identities = [];
@@ -854,8 +899,7 @@ async function getAddressUtxos(address, network, opts) {
       const resp = await fetch(url, {
         method: "GET",
         headers: { Accept: "application/json" },
-        signal: AbortSignal.timeout(1e4)
-        // 10s timeout
+        signal: AbortSignal.timeout(5e3)
       });
       if (!resp.ok) {
         throw new Error(`HTTP ${resp.status}`);
@@ -942,7 +986,7 @@ async function verify2(input, opts = {}) {
       const metrics = {
         sats_bonded,
         days_unspent,
-        score: scoreV02(sats_bonded, days_unspent)
+        score: computeScore(sats_bonded, days_unspent, { algorithm: "v0" })
         // ≈ 55.26
       };
       codes.push("sig_ok_bip322");
@@ -960,13 +1004,18 @@ async function verify2(input, opts = {}) {
       codes.push("network_testmode");
       return { ok: false, codes, network, attestation_id };
     }
-    if (opts.expectedAud && parsed.extensions["aud"] && parsed.extensions["aud"] !== opts.expectedAud) {
-      codes.push("aud_mismatch");
+    if (opts.expectedAud) {
+      const aud = parsed.extensions["aud"];
+      if (!aud || aud !== opts.expectedAud) {
+        codes.push("aud_mismatch");
+        return { ok: false, codes, network, attestation_id };
+      }
     }
     if (parsed.extensions["expires"]) {
       const exp = Date.parse(parsed.extensions["expires"]);
       if (!Number.isNaN(exp) && exp < Date.now()) {
         codes.push("expired");
+        return { ok: false, codes, network, attestation_id };
       }
     }
     const sigCode = await verifySignature({
@@ -1033,7 +1082,7 @@ async function verify2(input, opts = {}) {
       const metrics = {
         sats_bonded,
         days_unspent,
-        score: scoreV02(sats_bonded, days_unspent)
+        score: computeScore(sats_bonded, days_unspent, { algorithm: "v0" })
       };
       return {
         ok: true,
@@ -1044,7 +1093,7 @@ async function verify2(input, opts = {}) {
         metrics
       };
     } catch (utxoError) {
-      console.error("UTXO fetch failed:", utxoError);
+      log4.error({ err: utxoError }, "UTXO fetch failed");
       codes.push("bad_request");
       return { ok: false, codes, network, attestation_id };
     }
@@ -1171,16 +1220,20 @@ function parseChallenge(message) {
     throw new Error("not an orangecheck-auth challenge");
   }
   const out = { extensions: [] };
-  const coreKeys = /* @__PURE__ */ new Set(["address", "nonce", "issued_at", "expires_at", "ack"]);
-  let seenCore = 0;
+  const coreKeys = ["address", "nonce", "issued_at", "expires_at", "ack"];
+  const coreKeySet = new Set(coreKeys);
+  const seenCore = /* @__PURE__ */ new Set();
   for (let i = 1; i < lines.length; i++) {
     const line = lines[i] ?? "";
     const sep = line.indexOf(": ");
     if (sep === -1) continue;
     const key = line.slice(0, sep);
     const val = line.slice(sep + 2);
-    if (coreKeys.has(key)) {
-      seenCore++;
+    if (coreKeySet.has(key)) {
+      if (seenCore.has(key)) {
+        throw new Error(`duplicate core key in challenge: ${key}`);
+      }
+      seenCore.add(key);
       if (key === "address") out.address = val;
       else if (key === "nonce") out.nonce = val;
       else if (key === "issued_at") out.issuedAt = new Date(val);
@@ -1192,8 +1245,8 @@ function parseChallenge(message) {
       if (key === "purpose") out.purpose = val;
     }
   }
-  if (seenCore !== 5) {
-    throw new Error(`challenge missing core lines (${seenCore}/5)`);
+  if (seenCore.size !== coreKeys.length) {
+    throw new Error(`challenge missing core lines (${seenCore.size}/${coreKeys.length})`);
   }
   return out;
 }
@@ -1294,9 +1347,25 @@ var identityVerificationLimiter = createRateLimiter(5, 6e4);
 
 // src/identity/dns.ts
 var log5 = createLogger("identity-verification/dns");
+var PRIVATE_HOST_RE = /^(?:localhost|.*\.local|.*\.internal|.*\.localhost|.*\.lan|.*\.home|.*\.arpa|\[?::1\]?|\[?::\]?)$/i;
+var PRIVATE_IPV4_RE = /^(?:10\.|127\.|169\.254\.|192\.168\.|172\.(?:1[6-9]|2\d|3[01])\.|0\.|100\.(?:6[4-9]|[7-9]\d|1[01]\d|12[0-7])\.|22[4-9]\.|23\d\.|24\d\.|25[0-5]\.)/;
+var WELL_KNOWN_TIMEOUT_MS = 5e3;
+function isSafePublicHost(host) {
+  const h = host.toLowerCase();
+  if (PRIVATE_HOST_RE.test(h)) return false;
+  if (PRIVATE_IPV4_RE.test(h)) return false;
+  if (h.startsWith("[") || /^[0-9a-f:]+$/.test(h)) return false;
+  return true;
+}
 async function verifyDnsIdentity(attestationId, domain) {
   log5.info({ attestationId, domain }, "Verifying DNS identity");
   const cleanDomain = domain.replace(/^https?:\/\//, "").replace(/\/$/, "");
+  if (!isValidDomain(cleanDomain)) {
+    return { verified: false, error: `invalid domain format: ${cleanDomain}` };
+  }
+  if (!isSafePublicHost(cleanDomain)) {
+    return { verified: false, error: "domain resolves to a disallowed private host" };
+  }
   const wellKnownResult = await checkWellKnownFile(attestationId, cleanDomain);
   if (wellKnownResult.verified) {
     return wellKnownResult;
@@ -1308,38 +1377,31 @@ async function verifyDnsIdentity(attestationId, domain) {
   };
 }
 async function checkWellKnownFile(attestationId, domain) {
-  const urls = [
-    `https://${domain}/.well-known/orangecheck.txt`,
-    `http://${domain}/.well-known/orangecheck.txt`
-    // Fallback to HTTP
-  ];
-  for (const url of urls) {
-    try {
-      log5.info({ url }, "Checking well-known file");
-      const response = await fetch(url, {
-        method: "GET",
-        headers: {
-          Accept: "text/plain"
-        },
-        // Don't follow redirects to other domains
-        redirect: "manual"
-      });
-      if (response.ok) {
-        const content = await response.text();
-        if (content.includes(attestationId)) {
-          log5.info({ domain, url }, "Found attestation ID in well-known file");
-          return {
-            verified: true,
-            method: "well-known",
-            url
-          };
-        } else {
-          log5.info({ domain, url }, "Well-known file exists but no attestation ID found");
-        }
+  const url = `https://${domain}/.well-known/orangecheck.txt`;
+  try {
+    log5.info({ url }, "Checking well-known file");
+    const response = await fetch(url, {
+      method: "GET",
+      headers: { Accept: "text/plain" },
+      // Don't follow redirects to other domains
+      redirect: "manual",
+      signal: AbortSignal.timeout(WELL_KNOWN_TIMEOUT_MS)
+    });
+    if (response.ok) {
+      const content = await response.text();
+      if (content.includes(attestationId)) {
+        log5.info({ domain, url }, "Found attestation ID in well-known file");
+        return {
+          verified: true,
+          method: "well-known",
+          url
+        };
+      } else {
+        log5.info({ domain, url }, "Well-known file exists but no attestation ID found");
       }
-    } catch (err) {
-      log5.warn({ error: err, url }, "Failed to fetch well-known file");
     }
+  } catch (err) {
+    log5.warn({ error: err, url }, "Failed to fetch well-known file");
   }
   return {
     verified: false,
@@ -1412,14 +1474,32 @@ function isDnsIdentityVerified(attestationId, _domain, cachedContent) {
 
 // src/identity/github.ts
 var log6 = createLogger("identity-verification/github");
+var GITHUB_GIST_RAW_HOST = "gist.githubusercontent.com";
+var MAX_GISTS_SCANNED = 30;
+var MAX_FILES_PER_GIST = 10;
+var FETCH_TIMEOUT_MS = 5e3;
+var GITHUB_USERNAME_RE = /^[a-zA-Z0-9](?:[a-zA-Z0-9]|-(?=[a-zA-Z0-9])){0,38}$/;
+function isSafeGistRawUrl(raw) {
+  try {
+    const u = new URL(raw);
+    return u.protocol === "https:" && u.hostname === GITHUB_GIST_RAW_HOST;
+  } catch {
+    return false;
+  }
+}
 async function verifyGitHubIdentity(attestationId, username) {
   log6.info({ attestationId, username }, "Verifying GitHub identity");
+  if (!GITHUB_USERNAME_RE.test(username)) {
+    return { verified: false, error: "invalid GitHub username format" };
+  }
   try {
-    const response = await fetch(`https://api.github.com/users/${username}/gists`, {
-      headers: {
-        Accept: "application/vnd.github.v3+json"
+    const response = await fetch(
+      `https://api.github.com/users/${encodeURIComponent(username)}/gists?per_page=${MAX_GISTS_SCANNED}`,
+      {
+        headers: { Accept: "application/vnd.github.v3+json" },
+        signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
       }
-    });
+    );
     if (!response.ok) {
       if (response.status === 404) {
         return {
@@ -1434,7 +1514,7 @@ async function verifyGitHubIdentity(attestationId, username) {
     }
     const gists = await response.json();
     log6.info({ username, gistCount: gists.length }, "Fetched GitHub gists");
-    for (const gist of gists) {
+    for (const gist of gists.slice(0, MAX_GISTS_SCANNED)) {
       if (gist.description?.includes(attestationId)) {
         log6.info({ username, gistId: gist.id }, "Found attestation ID in gist description");
         return {
@@ -1443,7 +1523,8 @@ async function verifyGitHubIdentity(attestationId, username) {
           gistId: gist.id
         };
       }
-      for (const [filename, file] of Object.entries(gist.files)) {
+      const files = Object.entries(gist.files).slice(0, MAX_FILES_PER_GIST);
+      for (const [filename, file] of files) {
         if (file.content && file.content.includes(attestationId)) {
           log6.info(
             { username, gistId: gist.id, filename },
@@ -1455,8 +1536,17 @@ async function verifyGitHubIdentity(attestationId, username) {
             gistId: gist.id
           };
         }
+        if (!isSafeGistRawUrl(file.raw_url)) {
+          log6.warn(
+            { filename, rawUrl: file.raw_url },
+            "skipping gist file: raw_url failed allow-list"
+          );
+          continue;
+        }
         try {
-          const fileResponse = await fetch(file.raw_url);
+          const fileResponse = await fetch(file.raw_url, {
+            signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+          });
           if (fileResponse.ok) {
             const content = await fileResponse.text();
             if (content.includes(attestationId)) {
@@ -1534,15 +1624,38 @@ function isGitHubIdentityVerified(attestationId, _username, cachedGists) {
 function getGistCreationUrl() {
   return "https://gist.github.com/";
 }
-
-// src/identity/nostr.ts
 var log7 = createLogger("identity-verification/nostr");
+var HEX_64_RE = /^[0-9a-f]{64}$/;
+function toHex(bytes) {
+  let out = "";
+  for (const b of bytes) out += b.toString(16).padStart(2, "0");
+  return out;
+}
+function fromHex(hex) {
+  if (hex.length % 2 !== 0) throw new Error("odd-length hex");
+  const out = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    out[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return out;
+}
 function npubToHex(npub) {
-  if (npub.match(/^[0-9a-f]{64}$/i)) {
-    return npub.toLowerCase();
+  const trimmed = npub.trim();
+  if (HEX_64_RE.test(trimmed.toLowerCase())) {
+    return trimmed.toLowerCase();
+  }
+  if (!trimmed.toLowerCase().startsWith("npub1")) {
+    throw new Error(`not an npub: ${trimmed.slice(0, 12)}\u2026`);
   }
-  log7.warn({ npub }, "npub to hex conversion not fully implemented");
-  return npub;
+  const decoded = base.bech32.decode(trimmed.toLowerCase(), 1023);
+  if (decoded.prefix !== "npub") {
+    throw new Error(`bech32 prefix mismatch: expected npub, got ${decoded.prefix}`);
+  }
+  const bytes = base.bech32.fromWords(decoded.words);
+  if (bytes.length !== 32) {
+    throw new Error(`invalid npub payload length: ${bytes.length}`);
+  }
+  return toHex(Uint8Array.from(bytes));
 }
 async function queryNostrEvents(options) {
   const { authors, kinds, search, relays = DEFAULT_RELAYS, limit = 100 } = options;
@@ -1613,11 +1726,31 @@ async function queryNostrEvents(options) {
   return events;
 }
 async function verifyNostrEventSignature(event) {
-  if (!event.sig || event.sig.length !== 128) {
+  try {
+    if (!event.id || !event.sig || !event.pubkey || typeof event.id !== "string" || typeof event.sig !== "string" || typeof event.pubkey !== "string" || event.sig.length !== 128 || !HEX_64_RE.test(event.id) || !HEX_64_RE.test(event.pubkey)) {
+      return false;
+    }
+    const preimage = JSON.stringify([
+      0,
+      event.pubkey,
+      event.created_at,
+      event.kind,
+      event.tags ?? [],
+      event.content ?? ""
+    ]);
+    const computedId = toHex(sha2_js.sha256(new TextEncoder().encode(preimage)));
+    if (computedId !== event.id.toLowerCase()) {
+      log7.warn(
+        { eventId: event.id, computedId },
+        "nostr event id does not match its content"
+      );
+      return false;
+    }
+    return secp256k1_js.schnorr.verify(fromHex(event.sig), fromHex(event.id), fromHex(event.pubkey));
+  } catch (err) {
+    log7.warn({ err }, "schnorr verify threw");
     return false;
   }
-  log7.warn("Nostr signature verification not fully implemented");
-  return true;
 }
 async function verifyNostrIdentity(attestationId, npub, relays) {
   log7.info({ attestationId, npub }, "Verifying Nostr identity");
@@ -1982,7 +2115,9 @@ exports.createAttestation = createAttestation;
 exports.createAttestationEnvelope = createAttestationEnvelope;
 exports.createAttestationEvent = createAttestationEvent;
 exports.discoverAttestations = discoverAttestations;
+exports.extractAttestationIdFromUrl = extractAttestationIdFromUrl;
 exports.formatIdentities = formatIdentities;
+exports.formatIdentitiesForDisplay = formatIdentitiesForDisplay;
 exports.generateAttestationId = generateAttestationId;
 exports.generateGistTemplate = generateGistTemplate;
 exports.generateTweetText = generateTweetText;
@@ -2001,6 +2136,7 @@ exports.getTwitterComposeUrl = getTwitterComposeUrl;
 exports.getTwitterVerificationInstructions = getTwitterVerificationInstructions;
 exports.getVerificationInstructions = getVerificationInstructions;
 exports.getVerificationSummary = getVerificationSummary;
+exports.getVerificationUrl = getVerificationUrl;
 exports.getWellKnownUrl = getWellKnownUrl;
 exports.isDnsIdentityVerified = isDnsIdentityVerified;
 exports.isGitHubIdentityVerified = isGitHubIdentityVerified;