@memrov2/pentcloud-metasploit 0.0.0-stage → 0.1.1-dev.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PentCloud contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,11 @@
-# Temporary Holding Version
+# PentCloud metasploit
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Official Metasploit HTTP MCP in a separate native Cloudflare runtime. **Version 0.1.0 SDK.** The npm package contains adapter code only. Vendor image redistribution requires a separate component-license review. No PostgreSQL or public callback/listener endpoint is configured.
+
+```sh
+npm install @memrov2/pentcloud-metasploit@0.1.0
+```
+
+Use an existing MCP client with `runner.fetch(request)` through a private binding. Call `runner.stop()` when the owned run ends.
+
+Configure the matching named Container image. See [interfaces, build instructions, verification and limits](https://github.com/Memrov/PentCloud-tools/blob/main/docs/remaining-bundles.md) before integration. This package does not deploy or modify PentCloud.

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,8 @@
+# Third-party notices
+
+The original PentCloud adapter source and type declarations in this npm SDK are MIT licensed. The tarball includes pin metadata, but no third-party tool executables, source archives, datasets or container images.
+
+- Metasploit Framework core: [BSD-3-Clause](https://github.com/rapid7/metasploit-framework/blob/master/LICENSE), with third-party component exceptions listed in that file.
+- The pinned vendor image includes Nmap and other separately licensed components. Its digest in `tools.lock.json` identifies the upstream image; the adapter license does not license that image or its contents.
+
+Upstream programs, data and image dependencies retain their own licenses and notices. Image builders preserve those notices. Building or distributing a separate image requires compliance with its components' terms; this adapter SDK grants no additional rights to them. Image-specific cautions in `tools.lock.json` remain in effect.

package/package.json

@@ -1,6 +1,38 @@
 {
   "name": "@memrov2/pentcloud-metasploit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.1-dev.0",
+  "type": "module",
+  "license": "MIT",
+  "description": "Cloudflare-native metasploit tool pack",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Memrov/PentCloud-tools.git",
+    "directory": "packages/metasploit"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/index.d.mts",
+      "import": "./src/index.mjs"
+    },
+    "./worker": {
+      "types": "./src/worker.d.mts",
+      "import": "./src/worker.mjs"
+    },
+    "./tools.lock.json": "./tools.lock.json"
+  },
+  "files": [
+    "src",
+    "tools.lock.json",
+    "LICENSE",
+    "THIRD_PARTY_NOTICES.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@memrov2/pentcloud-tool-runtime": "0.1.1-dev.0"
+  }
+}

package/src/index.d.mts

@@ -0,0 +1,2 @@
+import type { PackLock } from "@memrov2/pentcloud-tool-runtime";
+export declare const lock: PackLock;

package/src/index.mjs

@@ -0,0 +1,2 @@
+import lock from "../tools.lock.json" with { type: "json" };
+export { lock };

package/src/worker.d.mts

@@ -0,0 +1,7 @@
+import { DurableObject } from "cloudflare:workers";
+export declare class MetasploitRunner extends DurableObject {
+  ready(): Promise<{ image: string; instance: "standard-2" }>;
+  fetch(request: Request): Promise<Response>;
+  retire(): Promise<{ stopped: boolean; retired: true }>;
+  stop(): Promise<{ stopped: boolean }>;
+}

package/src/worker.mjs

@@ -0,0 +1,151 @@
+import { DurableObject } from "cloudflare:workers";
+import { lock } from "./index.mjs";
+const decode = (x) => new TextDecoder().decode(x);
+const digest = async () =>
+  [
+    ...new Uint8Array(
+      await crypto.subtle.digest(
+        "SHA-256",
+        new TextEncoder().encode(JSON.stringify(lock)),
+      ),
+    ),
+  ]
+    .map((v) => v.toString(16).padStart(2, "0"))
+    .join("");
+/** Private binding only. The upstream MCP server owns RPC processes and tools. */
+export class MetasploitRunner extends DurableObject {
+  #queue = Promise.resolve();
+  #serial(action) {
+    const result = this.#queue.then(action);
+    this.#queue = result.catch(() => {});
+    return result;
+  }
+  async #ready() {
+      if (await this.ctx.storage.get("retired")) throw new Error("Owned tool runtime is retired");
+    const c = this.ctx.container,
+      image = c.images.metasploit;
+    if (!image) throw new Error("Configure the metasploit named image");
+    let token = await this.ctx.storage.get("mcp-token");
+    if (!token) {
+      if (c.running)
+        throw new Error(
+          "RPC authentication state missing; stop this owned runtime before restarting",
+        );
+      token = crypto.randomUUID() + crypto.randomUUID();
+      await this.ctx.storage.put("mcp-token", token);
+    }
+    if (c.running) {
+      if ((await c.inspect())?.image !== image)
+        throw new Error(
+          "Image changed; stop the current runtime before upgrading",
+        );
+    } else
+      c.start({
+        image,
+        entrypoint: [
+          "/usr/src/metasploit-framework/msfmcpd",
+          "--mcp-transport",
+          "http",
+          "--enable-dangerous-actions",
+        ],
+        env: {
+          MSF_MCP_HOST: "0.0.0.0",
+          MSF_MCP_PORT: "3000",
+          MSF_MCP_AUTH_TOKEN: token,
+          MSF_API_TYPE: "messagepack",
+          MSF_API_SSL: "false",
+          MSF_AUTO_START_RPC: "true",
+          MSF_MCP_WORKERS: "1",
+          MSF_MCP_MIN_THREADS: "1",
+          MSF_MCP_MAX_THREADS: "4",
+        },
+        instance: "standard-2",
+        enableInternet: true,
+        labels: { pack: "metasploit", version: lock.packVersion },
+      });
+    await c.setInactivityTimeout(240000);
+    const deadline = Date.now() + 180000;
+    let verified = false;
+    while (Date.now() < deadline) {
+      try {
+        if (!verified) {
+          const p = await c.exec(
+            ["/bin/cat", "/opt/pentcloud-metasploit/pack.json"],
+            { signal: AbortSignal.timeout(5000) },
+          );
+          const r = await p.output();
+          if (
+            r.exitCode !== 0 ||
+            JSON.parse(decode(r.stdout)).lockSha256 !== (await digest())
+          )
+            throw new Error("Pack image and SDK pins do not match");
+          verified = true;
+        }
+        const r = await c
+          .getTcpPort(3000)
+          .fetch("http://localhost:3000/", {
+            headers: {
+              Authorization: "Bearer " + token,
+              Accept: "application/json, text/event-stream",
+            },
+            signal: AbortSignal.timeout(5000),
+          });
+        await r.body?.cancel();
+        if ([200, 400, 405, 406].includes(r.status)) {await c.setInactivityTimeout(120000);return token;}
+        if (r.status === 401)
+          throw new Error("Internal MCP authentication failed");
+      } catch (error) {
+        if (/pins do not match|authentication/.test(error.message)) throw error;
+      }
+      await new Promise((r) => setTimeout(r, 1000));
+    }
+    throw new Error(
+      "Official Metasploit MCP server did not become ready within 180 seconds",
+    );
+  }
+  ready() {
+    return this.#serial(async () => {
+      await this.#ready();
+      return { image: this.ctx.container.images.metasploit, instance: "standard-2" };
+    });
+  }
+  async fetch(request) {
+    const url = new URL(request.url);
+    if (
+      !["/", "/mcp"].includes(url.pathname) ||
+      url.search ||
+      !["GET", "POST", "DELETE"].includes(request.method)
+    )
+      return new Response("Unsupported MCP request", { status: 400 });
+    const token = await this.#serial(() => this.#ready());
+    const headers = new Headers(request.headers);
+    headers.set("Authorization", "Bearer " + token);
+    headers.delete("Cookie");
+    headers.delete("Host");
+    return this.ctx.container
+      .getTcpPort(3000)
+      .fetch(
+        new Request("http://localhost:3000/", {
+          method: request.method,
+          headers,
+          body: request.method === "GET" ? undefined : request.body,
+          duplex: "half",
+        }),
+      );
+  }
+  retire() {
+    return this.#serial(async () => {
+      await this.ctx.storage.put("retired", true);
+      if (this.ctx.container.running) await this.ctx.container.destroy();
+      await this.ctx.storage.delete("mcp-token");
+      return { stopped: !this.ctx.container.running, retired: true };
+    });
+  }
+  stop() {
+    return this.#serial(async () => {
+      if (this.ctx.container.running) await this.ctx.container.destroy();
+      await this.ctx.storage.delete("mcp-token");
+      return { stopped: !this.ctx.container.running };
+    });
+  }
+}

package/tools.lock.json

@@ -0,0 +1,24 @@
+{
+  "schemaVersion": 1,
+  "packId": "metasploit",
+  "packVersion": "0.1.0",
+  "platform": "linux/amd64",
+  "baseImage": "docker.io/metasploitframework/metasploit-framework@sha256:8096709486bce8b5f35980f2aea42dc7cd83e34ebbeb4d56eab3339847de258d",
+  "tools": [
+    {
+      "tool": "metasploit",
+      "version": "image-8096709486bc"
+    }
+  ],
+  "assets": [],
+  "executables": [],
+  "runtime": {
+    "vcpu": 2,
+    "memoryMib": 2048,
+    "diskMb": 8000,
+    "enableInternet": true
+  },
+  "privateOnlyReasons": [
+    "Vendor image includes Nmap; public image redistribution requires review."
+  ]
+}