@orangecheck/sdk 0.1.0 → 0.1.2

package/dist/identity.js

@@ -1,5 +1,9 @@
 'use strict';
 
+var secp256k1 = require('@noble/curves/secp256k1');
+var sha2 = require('@noble/hashes/sha2');
+var base = require('@scure/base');
+
 // src/utils/logger.ts
 function createLogger(namespace) {
   const shouldLog = (level) => {
@@ -93,9 +97,25 @@ var identityVerificationLimiter = createRateLimiter(5, 6e4);
 
 // src/identity/dns.ts
 var log = 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) {
   log.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;
@@ -107,38 +127,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 {
-      log.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)) {
-          log.info({ domain, url }, "Found attestation ID in well-known file");
-          return {
-            verified: true,
-            method: "well-known",
-            url
-          };
-        } else {
-          log.info({ domain, url }, "Well-known file exists but no attestation ID found");
-        }
+  const url = `https://${domain}/.well-known/orangecheck.txt`;
+  try {
+    log.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)) {
+        log.info({ domain, url }, "Found attestation ID in well-known file");
+        return {
+          verified: true,
+          method: "well-known",
+          url
+        };
+      } else {
+        log.info({ domain, url }, "Well-known file exists but no attestation ID found");
       }
-    } catch (err) {
-      log.warn({ error: err, url }, "Failed to fetch well-known file");
     }
+  } catch (err) {
+    log.warn({ error: err, url }, "Failed to fetch well-known file");
   }
   return {
     verified: false,
@@ -211,14 +224,32 @@ function isDnsIdentityVerified(attestationId, _domain, cachedContent) {
 
 // src/identity/github.ts
 var log2 = 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) {
   log2.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 {
@@ -233,7 +264,7 @@ async function verifyGitHubIdentity(attestationId, username) {
     }
     const gists = await response.json();
     log2.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)) {
         log2.info({ username, gistId: gist.id }, "Found attestation ID in gist description");
         return {
@@ -242,7 +273,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)) {
           log2.info(
             { username, gistId: gist.id, filename },
@@ -254,8 +286,17 @@ async function verifyGitHubIdentity(attestationId, username) {
             gistId: gist.id
           };
         }
+        if (!isSafeGistRawUrl(file.raw_url)) {
+          log2.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)) {
@@ -342,12 +383,37 @@ var DEFAULT_RELAYS = [
 
 // src/identity/nostr.ts
 var log4 = 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}`);
   }
-  log4.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;
@@ -418,11 +484,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()) {
+      log4.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) {
+    log4.warn({ err }, "schnorr verify threw");
     return false;
   }
-  log4.warn("Nostr signature verification not fully implemented");
-  return true;
 }
 async function verifyNostrIdentity(attestationId, npub, relays) {
   log4.info({ attestationId, npub }, "Verifying Nostr identity");