@orangecheck/sdk 0.1.1 → 0.1.2

package/dist/index.js

@@ -3,6 +3,9 @@
 var buffer = require('buffer');
 var bip322Js = require('bip322-js');
 var bitcoinMessage = require('bitcoinjs-message');
+var secp256k1 = require('@noble/curves/secp256k1');
+var sha2 = require('@noble/hashes/sha2');
+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();
@@ -799,7 +824,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 +885,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}`);
@@ -960,13 +990,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({
@@ -1044,7 +1079,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 };
     }
@@ -1294,9 +1329,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 +1359,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 +1456,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 +1496,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 +1505,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 +1518,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 +1606,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`);
+  }
+  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}`);
   }
-  log7.warn({ npub }, "npub to hex conversion not fully implemented");
-  return npub;
+  return toHex(Uint8Array.from(bytes));
 }
 async function queryNostrEvents(options) {
   const { authors, kinds, search, relays = DEFAULT_RELAYS, limit = 100 } = options;
@@ -1613,11 +1708,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.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.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");