altweb-context 1.0.2 → 1.1.0

package/dist/altweb-context.mjs

@@ -6920,12 +6920,33 @@ if (typeof globalThis.window === "undefined") {
 }
 
 // ../core/src/crypto/encoding.ts
+var BASE64URL_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
 function base64urlDecode(str) {
+  if (!/^[A-Za-z0-9_-]*$/.test(str)) {
+    throw new Error("invalid base64url charset");
+  }
+  const rem = str.length % 4;
+  if (rem === 1) {
+    throw new Error("invalid base64url length");
+  }
+  if (rem !== 0) {
+    const lastValue = BASE64URL_ALPHABET.indexOf(str[str.length - 1]);
+    const unusedBits = rem === 2 ? 15 : 3;
+    if ((lastValue & unusedBits) !== 0) {
+      throw new Error("non-canonical base64url encoding");
+    }
+  }
   let base644 = str.replace(/-/g, "+").replace(/_/g, "/");
   while (base644.length % 4) base644 += "=";
   const binary = atob(base644);
   return Uint8Array.from(binary, (c) => c.charCodeAt(0));
 }
+function concatBytes(a, b2) {
+  const out = new Uint8Array(a.length + b2.length);
+  out.set(a, 0);
+  out.set(b2, a.length);
+  return out;
+}
 
 // ../core/src/crypto/key-derivation.ts
 var PBKDF2_ITERATIONS = 6e5;
@@ -6966,10 +6987,25 @@ async function decrypt(payload, password) {
 }
 
 // ../core/src/crypto/signing.ts
+var P256_N = BigInt(
+  "0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551"
+);
+var P256_HALF_N = P256_N >> 1n;
+function isLowS(signature) {
+  if (signature.length !== 64) return true;
+  let s = 0n;
+  for (let i = 32; i < 64; i++) {
+    s = s << 8n | BigInt(signature[i]);
+  }
+  return s <= P256_HALF_N;
+}
 async function verify(data, signatureBase64, publicKeyBase64) {
   try {
     const signature = base64urlDecode(signatureBase64);
     const publicKeyData = base64urlDecode(publicKeyBase64);
+    if (!isLowS(signature)) {
+      return false;
+    }
     const publicKey = await crypto.subtle.importKey(
       "spki",
       publicKeyData,
@@ -11190,30 +11226,39 @@ var pako = {
 
 // ../core/src/compression/compress.ts
 var MAX_DECOMPRESSED_BYTES = 16 * 1024 * 1024;
+var MAX_COMPRESSED_BYTES = 17 * 1024 * 1024;
+var INFLATE_SLICE_BYTES = 64 * 1024;
 function decompress(data) {
+  if (data.length > MAX_COMPRESSED_BYTES) {
+    throw new Error(
+      `Compressed payload exceeds the ${MAX_COMPRESSED_BYTES} byte limit`
+    );
+  }
   const inflator = new pako.Inflate();
   const chunks = [];
   let total = 0;
-  let bombed = false;
   inflator.onData = (chunk) => {
     const bytes = typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk instanceof Uint8Array ? chunk : new Uint8Array(chunk);
     total += bytes.length;
-    if (total > MAX_DECOMPRESSED_BYTES) {
-      bombed = true;
-      inflator.err = -2;
-      return;
-    }
     chunks.push(bytes);
   };
-  inflator.onEnd = () => {
-  };
-  inflator.push(data, true);
-  if (bombed) {
-    throw new Error(
-      `Decompressed payload exceeds the ${MAX_DECOMPRESSED_BYTES} byte limit`
-    );
+  if (data.length === 0) {
+    inflator.push(data, true);
   }
-  if (inflator.err) {
+  for (let offset2 = 0; offset2 < data.length; offset2 += INFLATE_SLICE_BYTES) {
+    const last = offset2 + INFLATE_SLICE_BYTES >= data.length;
+    inflator.push(data.subarray(offset2, offset2 + INFLATE_SLICE_BYTES), last);
+    if (total > MAX_DECOMPRESSED_BYTES) {
+      throw new Error(
+        `Decompressed payload exceeds the ${MAX_DECOMPRESSED_BYTES} byte limit`
+      );
+    }
+    if (inflator.err) {
+      throw new Error(inflator.msg || "invalid deflate stream");
+    }
+    if (inflator.ended) break;
+  }
+  if (inflator.err || !inflator.ended) {
     throw new Error(inflator.msg || "invalid deflate stream");
   }
   const result = new Uint8Array(total);
@@ -12769,12 +12814,45 @@ function sanitizePage(page) {
       ...page.meta,
       title: purify.sanitize(page.meta.title, { ALLOWED_TAGS: [] }),
       description: page.meta.description ? purify.sanitize(page.meta.description, { ALLOWED_TAGS: [] }) : void 0,
-      author: page.meta.author ? purify.sanitize(page.meta.author, { ALLOWED_TAGS: [] }) : void 0
+      author: page.meta.author ? purify.sanitize(page.meta.author, { ALLOWED_TAGS: [] }) : void 0,
+      header: page.meta.header ? sanitizeHeader(page.meta.header) : void 0,
+      footer: page.meta.footer ? sanitizeFooter(page.meta.footer) : void 0
     },
     blocks: page.blocks.map(sanitizeBlock),
     style: sanitizeStyle(page.style)
   };
 }
+function sanitizeHeader(header) {
+  return {
+    ...header,
+    logo: header.logo ? sanitizeImageSrc(header.logo) : void 0,
+    customText: header.customText ? purify.sanitize(header.customText, { ALLOWED_TAGS: [] }) : void 0
+  };
+}
+function sanitizeFooter(footer) {
+  return {
+    ...footer,
+    copyright: footer.copyright ? purify.sanitize(footer.copyright, { ALLOWED_TAGS: [] }) : void 0,
+    customText: footer.customText ? purify.sanitize(footer.customText, { ALLOWED_TAGS: [] }) : void 0,
+    links: footer.links ? footer.links.map((link) => ({
+      label: purify.sanitize(link.label, { ALLOWED_TAGS: [] }),
+      url: sanitizeUrl(link.url)
+    })) : void 0
+  };
+}
+function sanitizeImageSrc(src) {
+  if (src.startsWith("data:")) {
+    return validateDataUri(src);
+  }
+  try {
+    const parsed = new URL(src);
+    if (["http:", "https:"].includes(parsed.protocol)) {
+      return src;
+    }
+  } catch {
+  }
+  return "";
+}
 function sanitizeBlock(block) {
   switch (block.t) {
     case "h":
@@ -27584,6 +27662,14 @@ function validatePageStructure(data) {
 }
 
 // ../core/src/codec/decoder.ts
+var MAX_ENVELOPE_CHARS = 24 * 1024 * 1024;
+function assertEnvelopeSize(hash2) {
+  if (hash2.length > MAX_ENVELOPE_CHARS) {
+    throw new ValidationError(
+      `Envelope exceeds the ${MAX_ENVELOPE_CHARS} character limit`
+    );
+  }
+}
 var DecryptionError = class extends Error {
   constructor(message) {
     super(message);
@@ -27597,6 +27683,7 @@ var ValidationError = class extends Error {
   }
 };
 async function decodePage(hash2, password) {
+  assertEnvelopeSize(hash2);
   const envelopeBytes = base64urlDecode(hash2);
   const envelopeJson = new TextDecoder().decode(envelopeBytes);
   let envelope;
@@ -27632,7 +27719,8 @@ async function decodePage(hash2, password) {
       let verified2 = false;
       let fingerprint2;
       if (envelope.s && envelope.pk) {
-        verified2 = await verify(blocksCompressed, envelope.s, envelope.pk);
+        const signedBytes = concatBytes(metaCompressed, blocksCompressed);
+        verified2 = await verify(signedBytes, envelope.s, envelope.pk);
         if (verified2) {
           fingerprint2 = await computeFingerprint(envelope.pk);
         }
@@ -27706,6 +27794,7 @@ async function decodePage(hash2, password) {
 }
 function isEncryptedContent(hash2) {
   try {
+    assertEnvelopeSize(hash2);
     const envelopeBytes = base64urlDecode(hash2);
     const envelopeJson = new TextDecoder().decode(envelopeBytes);
     const envelope = JSON.parse(envelopeJson);
@@ -27717,6 +27806,9 @@ function isEncryptedContent(hash2) {
 
 // ../core/src/codec/inspect.ts
 async function inspectArtifact(hash2) {
+  if (hash2.length > MAX_ENVELOPE_CHARS) {
+    throw new ValidationError("Invalid artifact format");
+  }
   let envelope;
   try {
     envelope = JSON.parse(new TextDecoder().decode(base64urlDecode(hash2)));
@@ -29082,10 +29174,28 @@ var HTML_ENTITIES = {
 function decodeHtmlEntities(text2) {
   return text2.replace(/&(?:amp|lt|gt|quot|#39|apos|nbsp);/g, (match) => HTML_ENTITIES[match] || match);
 }
+function stripTags(html2) {
+  let out = "";
+  let i = 0;
+  while (i < html2.length) {
+    const lt = html2.indexOf("<", i);
+    if (lt === -1) {
+      out += html2.slice(i);
+      break;
+    }
+    out += html2.slice(i, lt);
+    const gt = html2.indexOf(">", lt + 1);
+    if (gt === -1) {
+      out += html2.slice(lt);
+      break;
+    }
+    i = gt + 1;
+  }
+  return out;
+}
 function stripHtml(html2) {
   if (!html2) return "";
-  const stripped = html2.replace(/<[^>]*>/g, "");
-  return decodeHtmlEntities(stripped);
+  return decodeHtmlEntities(stripTags(html2));
 }
 function htmlToMarkdown(html2) {
   if (!html2) return "";
@@ -29094,7 +29204,7 @@ function htmlToMarkdown(html2) {
   md = md.replace(/<(?:em|i)>(.*?)<\/(?:em|i)>/gi, "*$1*");
   md = md.replace(/<code>(.*?)<\/code>/gi, "`$1`");
   md = md.replace(/<a\s+href="([^"]*)"[^>]*>(.*?)<\/a>/gi, "[$2]($1)");
-  md = md.replace(/<[^>]*>/g, "");
+  md = stripTags(md);
   return decodeHtmlEntities(md);
 }
 
@@ -47378,16 +47488,52 @@ function isPrivateV4(addr) {
   a === 169 && b2 === 254 || // link-local / cloud metadata
   a === 172 && b2 >= 16 && b2 <= 31 || a === 192 && b2 === 168;
 }
+function parseHextets(addr) {
+  let s = addr;
+  const lastColon = s.lastIndexOf(":");
+  const tail = s.slice(lastColon + 1);
+  if (tail.includes(".")) {
+    if (isIP(tail) !== 4) return null;
+    const [a, b2, c, d] = tail.split(".").map(Number);
+    s = s.slice(0, lastColon + 1) + (a << 8 | b2).toString(16) + ":" + (c << 8 | d).toString(16);
+  }
+  const doubleColons = s.split("::");
+  if (doubleColons.length > 2) return null;
+  const parseGroups = (part) => {
+    if (part === "") return [];
+    const groups = [];
+    for (const g2 of part.split(":")) {
+      if (!/^[0-9a-fA-F]{1,4}$/.test(g2)) return null;
+      groups.push(parseInt(g2, 16));
+    }
+    return groups;
+  };
+  const head = parseGroups(doubleColons[0]);
+  const tailGroups = doubleColons.length === 2 ? parseGroups(doubleColons[1]) : [];
+  if (head === null || tailGroups === null) return null;
+  if (doubleColons.length === 2) {
+    const fill = 8 - head.length - tailGroups.length;
+    if (fill < 1) return null;
+    return [...head, ...new Array(fill).fill(0), ...tailGroups];
+  }
+  return head.length === 8 ? head : null;
+}
+function embeddedV4(hi, lo) {
+  return `${hi >> 8}.${hi & 255}.${lo >> 8}.${lo & 255}`;
+}
 function isPrivateAddress(addr) {
-  const lower = addr.toLowerCase();
-  if (lower.startsWith("::ffff:")) {
-    const embedded = lower.slice(7);
-    return isIP(embedded) === 4 ? isPrivateV4(embedded) : true;
-  }
   if (isIP(addr) === 4) return isPrivateV4(addr);
-  return lower === "::1" || lower === "::" || lower.startsWith("fe80:") || // link-local
-  lower.startsWith("fc") || // ULA fc00::/7
-  lower.startsWith("fd");
+  const h = parseHextets(addr);
+  if (h === null) return true;
+  if (h.slice(0, 6).every((x2) => x2 === 0)) return true;
+  if (h.slice(0, 5).every((x2) => x2 === 0) && h[5] === 65535) {
+    return isPrivateV4(embeddedV4(h[6], h[7]));
+  }
+  if ((h[0] & 65472) === 65152) return true;
+  if ((h[0] & 65024) === 64512) return true;
+  if (h[0] === 100 && h[1] === 65435) return true;
+  if (h[0] === 8194) return true;
+  return false;
 }
 function guardedLookup(hostname4, options, callback) {
   lookup(hostname4, { ...options, all: true }, (err2, addresses) => {

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "altweb-context",
   "mcpName": "software.altweb/altweb-context",
-  "version": "1.0.2",
-  "description": "MCP server that loads ALTWEB signed context capsules into AI agents — verifies first, refuses unsigned, tampered, or untrusted context by default. Verify before you inject.",
+  "version": "1.1.0",
+  "description": "MCP server that loads ALTWEB signed context capsules into AI agents \u2014 verifies first, refuses unsigned, tampered, or untrusted context by default. Verify before you inject.",
   "type": "module",
   "license": "AGPL-3.0-or-later",
-  "author": "Daniel C. ȘOIMU",
+  "author": "Daniel C. \u0218OIMU",
   "homepage": "https://altweb.software",
   "repository": {
     "type": "git",