@poe-platform/safe-bash 0.1.773 → 0.1.774

package/dist/safe-bash-command-ssh/index.js

@@ -4,7 +4,7 @@ import {
 
 // packages/safe-bash-command-ssh/dist/index.js
 init_buffer();
-import { commandRuntimeIdentity, getCommandArguments, readBytes, writeText } from "../safe-bash-contracts/index.js";
+import { FsError, commandRuntimeIdentity, getCommandArguments, readBytes, writeText } from "../safe-bash-contracts/index.js";
 import { PublicDiagnostic } from "../safe-bash-contracts/diagnostics.js";
 import { writeFileOutput } from "../safe-bash-contracts/filesystem-output-budget.js";
 import { yieldTurn } from "../safe-bash-contracts/yield.js";
@@ -216,6 +216,78 @@ function parseOpenSshEd25519PublicKey(line) {
     comment: parts.slice(idx + 2).join(" ")
   };
 }
+function matchesGlob(value, pattern) {
+  let v = 0;
+  let p = 0;
+  let star = -1;
+  let retry = 0;
+  while (v < value.length) {
+    if (pattern[p] === "?" || pattern[p] === value[v]) {
+      v++;
+      p++;
+    } else if (pattern[p] === "*") {
+      star = p++;
+      retry = v;
+    } else if (star >= 0) {
+      p = star + 1;
+      v = ++retry;
+    } else
+      return false;
+  }
+  while (pattern[p] === "*")
+    p++;
+  return p === pattern.length;
+}
+function matchesPatterns(value, patterns) {
+  let matched = false;
+  for (const pattern of patterns.split(",")) {
+    const negative = pattern.startsWith("!");
+    if (matchesGlob(value, negative ? pattern.slice(1) : pattern)) {
+      if (negative)
+        return false;
+      matched = true;
+    }
+  }
+  return matched;
+}
+function parseAllowedSigner(line) {
+  const text = line.trim();
+  if (!text || text.startsWith("#"))
+    return void 0;
+  const fields = [];
+  let field = "";
+  let quoted = false;
+  for (const char of text) {
+    if (char === '"')
+      quoted = !quoted;
+    if (!quoted && (char === " " || char === "	")) {
+      if (field) {
+        fields.push(field);
+        field = "";
+      }
+    } else
+      field += char;
+  }
+  if (quoted)
+    return void 0;
+  if (field)
+    fields.push(field);
+  const principals = fields[0];
+  let index = 1;
+  let namespaces;
+  if (fields[index] !== "ssh-ed25519") {
+    const options = fields[index++];
+    if (!options?.startsWith('namespaces="') || !options.endsWith('"'))
+      return void 0;
+    namespaces = options.slice(12, -1);
+    if (!namespaces || namespaces.includes('"'))
+      return void 0;
+  }
+  if (!principals || fields[index] !== "ssh-ed25519" || !fields[index + 1])
+    return void 0;
+  const key = parseOpenSshEd25519PublicKey(`${fields[index]} ${fields[index + 1]}`);
+  return key ? { principals, ...namespaces === void 0 ? {} : { namespaces }, pubKey: key.pubKey } : void 0;
+}
 async function computeFingerprintSha256(pubKey) {
   const blob = sshEd25519PubkeyBlob(pubKey);
   const buf = blob.buffer.slice(blob.byteOffset, blob.byteOffset + blob.byteLength);
@@ -262,6 +334,20 @@ async function collectSourceBytes(source, maxBytes, signal) {
   }
   return result;
 }
+async function readLimitedFile(context, path, maxBytes) {
+  try {
+    const bytes = await context.fs.readFile(path, { ...maxBytes === Infinity ? {} : { maxBytes }, signal: context.signal });
+    if (bytes.byteLength > maxBytes) {
+      throw new PublicDiagnostic(`input exceeds maximum buffered size of ${maxBytes} bytes`);
+    }
+    return bytes;
+  } catch (error) {
+    if (error instanceof FsError && error.code === "EFBIG") {
+      throw new PublicDiagnostic(`input exceeds maximum buffered size of ${maxBytes} bytes`);
+    }
+    throw error;
+  }
+}
 function createSshKeygenCommand(options = {}) {
   const limits = settings(options);
   return {
@@ -280,6 +366,7 @@ function createSshKeygenCommand(options = {}) {
       let removeHost;
       let yAction;
       let namespace = "file";
+      let namespaceProvided = false;
       let allowedSignersFile;
       let signerIdentity;
       let signatureFile;
@@ -304,9 +391,10 @@ function createSshKeygenCommand(options = {}) {
           removeHost = args[++i];
         else if (a === "-Y" && i + 1 < args.length)
           yAction = args[++i];
-        else if (a === "-n" && i + 1 < args.length)
+        else if (a === "-n" && i + 1 < args.length) {
           namespace = args[++i];
-        else if (a === "-I" && i + 1 < args.length)
+          namespaceProvided = true;
+        } else if (a === "-I" && i + 1 < args.length)
           signerIdentity = args[++i];
         else if (a === "-s" && i + 1 < args.length)
           signatureFile = args[++i];
@@ -318,7 +406,11 @@ function createSshKeygenCommand(options = {}) {
       try {
         if (findHost !== void 0) {
           const khPath = pathPosix.resolve(context.cwd, fileArg ?? "/home/user/.ssh/known_hosts");
-          const khText = textDecoder.decode(await context.fs.readFile(khPath).catch(() => new Uint8Array(0)));
+          const khText = textDecoder.decode(await readLimitedFile(context, khPath, maxBytes).catch((error) => {
+            if (error instanceof FsError && error.code === "ENOENT")
+              return new Uint8Array(0);
+            throw error;
+          }));
           const matches = khText.split("\n").filter((l) => l.trim().length > 0 && !l.startsWith("#") && l.split(/\s+/)[0]?.split(",").includes(findHost));
           if (matches.length === 0)
             return { exitCode: 1 };
@@ -328,7 +420,11 @@ function createSshKeygenCommand(options = {}) {
         }
         if (removeHost !== void 0) {
           const khPath = pathPosix.resolve(context.cwd, fileArg ?? "/home/user/.ssh/known_hosts");
-          const khText = textDecoder.decode(await context.fs.readFile(khPath).catch(() => new Uint8Array(0)));
+          const khText = textDecoder.decode(await readLimitedFile(context, khPath, maxBytes).catch((error) => {
+            if (error instanceof FsError && error.code === "ENOENT")
+              return new Uint8Array(0);
+            throw error;
+          }));
           const remaining = khText.split("\n").filter((l) => l.trim().length === 0 || l.startsWith("#") || !l.split(/\s+/)[0]?.split(",").includes(removeHost));
           const outBytes = textEncoder.encode(`${remaining.join("\n")}
 `);
@@ -341,13 +437,13 @@ ${khPath} updated.
         if (yAction !== void 0) {
           if (yAction === "sign") {
             const keyPath = pathPosix.resolve(context.cwd, fileArg ?? "/home/user/.ssh/id_ed25519");
-            const keyPem = textDecoder.decode(await context.fs.readFile(keyPath));
+            const keyPem = textDecoder.decode(await readLimitedFile(context, keyPath, maxBytes));
             const parsed = parseOpenSshEd25519PrivateKey(keyPem);
             if (!parsed)
               throw new PublicDiagnostic(`invalid OpenSSH Ed25519 key: ${keyPath}`);
             const { privateKey } = await importEd25519FromSeedAndPub(parsed.seed, parsed.pubKey);
             const targetFile = positionalFiles[0];
-            const payload = targetFile ? await context.fs.readFile(pathPosix.resolve(context.cwd, targetFile)) : await collectSourceBytes(context.stdin, maxBytes, context.signal);
+            const payload = targetFile ? await readLimitedFile(context, pathPosix.resolve(context.cwd, targetFile), maxBytes) : await collectSourceBytes(context.stdin, maxBytes, context.signal);
             const payloadBuf = payload.buffer.slice(payload.byteOffset, payload.byteOffset + payload.byteLength);
             const msgHash = new Uint8Array(await globalThis.crypto.subtle.digest("SHA-512", payloadBuf));
             const toSign = [];
@@ -389,7 +485,7 @@ Write signature to ${targetFile}.sig
           }
           if (yAction === "verify" || yAction === "check-novalidate" || yAction === "find-principals") {
             const sigPath = pathPosix.resolve(context.cwd, signatureFile ?? positionalFiles[0] ?? "");
-            const sigPem = textDecoder.decode(await context.fs.readFile(sigPath));
+            const sigPem = textDecoder.decode(await readLimitedFile(context, sigPath, maxBytes));
             const b64 = sigPem.split("\n").map((l) => l.trim()).filter((l) => !l.startsWith("-----") && l.length > 0).join("");
             const raw = base64ToBytes(b64);
             if (raw.byteLength < 10 || textDecoder.decode(raw.slice(0, 6)) !== "SSHSIG") {
@@ -412,22 +508,27 @@ Write signature to ${targetFile}.sig
             const rawSig = readSshString(sigBlob, spos);
             if (!pubKey2 || !rawSig)
               throw new PublicDiagnostic("invalid SSHSIG key/signature");
-            if (yAction === "find-principals") {
+            if (yAction !== "find-principals" && (!namespaceProvided || textDecoder.decode(sigNs) !== namespace)) {
+              throw new PublicDiagnostic("signature namespace does not match requested namespace");
+            }
+            if (yAction === "verify" || yAction === "find-principals") {
               allowedSignersFile = fileArg;
-              if (allowedSignersFile) {
-                const asText = textDecoder.decode(await context.fs.readFile(pathPosix.resolve(context.cwd, allowedSignersFile)));
-                const fp3 = await computeFingerprintSha256(pubKey2);
-                for (const line of asText.split("\n")) {
-                  const p = parseOpenSshEd25519PublicKey(line);
-                  if (p && await computeFingerprintSha256(p.pubKey) === fp3) {
-                    const principal = line.trim().split(/\s+/)[0];
-                    await writeText(context.stdout, `${principal}
+              if (!allowedSignersFile || yAction === "verify" && !signerIdentity) {
+                throw new PublicDiagnostic("allowed signers file and signer identity are required for verification");
+              }
+              const asText = textDecoder.decode(await readLimitedFile(context, pathPosix.resolve(context.cwd, allowedSignersFile), maxBytes));
+              const entries = asText.split("\n").map(parseAllowedSigner).filter((entry) => entry !== void 0);
+              const matching = entries.filter((entry) => entry.pubKey.every((byte, index) => byte === pubKey2[index]) && (yAction === "find-principals" || matchesPatterns(namespace, entry.namespaces ?? "*")));
+              if (yAction === "find-principals") {
+                if (matching.length === 0)
+                  return { exitCode: 1 };
+                await writeText(context.stdout, `${matching.map((entry) => entry.principals).join("\n")}
 `);
-                    return { exitCode: 0 };
-                  }
-                }
+                return { exitCode: 0 };
+              }
+              if (!matching.some((entry) => matchesPatterns(signerIdentity, entry.principals))) {
+                throw new PublicDiagnostic("signer is not authorized by allowed signers");
               }
-              return { exitCode: 1 };
             }
             const payload = await collectSourceBytes(context.stdin, maxBytes, context.signal);
             const payloadBuf = payload.buffer.slice(payload.byteOffset, payload.byteOffset + payload.byteLength);
@@ -457,7 +558,7 @@ Write signature to ${targetFile}.sig
         }
         if (derivePub) {
           const keyPath = pathPosix.resolve(context.cwd, fileArg ?? "/home/user/.ssh/id_ed25519");
-          const pem = textDecoder.decode(await context.fs.readFile(keyPath));
+          const pem = textDecoder.decode(await readLimitedFile(context, keyPath, maxBytes));
           const parsed = parseOpenSshEd25519PrivateKey(pem);
           if (!parsed)
             throw new PublicDiagnostic(`invalid OpenSSH private key: ${keyPath}`);
@@ -468,7 +569,7 @@ Write signature to ${targetFile}.sig
         }
         if (showFingerprint) {
           const keyPath = pathPosix.resolve(context.cwd, fileArg ?? "/home/user/.ssh/id_ed25519.pub");
-          const content = textDecoder.decode(await context.fs.readFile(keyPath));
+          const content = textDecoder.decode(await readLimitedFile(context, keyPath, maxBytes));
           const privParsed = parseOpenSshEd25519PrivateKey(content);
           const pubParsed = privParsed ?? parseOpenSshEd25519PublicKey(content);
           if (!pubParsed)