mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-16 03:50:52 +00:00
155 lines
8.4 KiB
JavaScript
155 lines
8.4 KiB
JavaScript
"use strict";
|
|
|
|
const { createHmac, randomBytes } = require("node:crypto");
|
|
const { createDefinitionValidator } = require("./contractValidator.cjs");
|
|
const { PluginRpcError, RPC_ERRORS } = require("./rpcRouter.cjs");
|
|
const fail = (code, message) => new PluginRpcError(RPC_ERRORS[code], message);
|
|
const METHODS = ["vault.selectHosts", "vault.requestHostDraft", "vault.requestConnect"];
|
|
const MAX_SELECTED = 50;
|
|
const MAX_REFERENCES = 500;
|
|
const TARGET_LIFETIME_MS = 5 * 60_000;
|
|
|
|
/** Typed host selection only. Selection references identify a reviewed target;
|
|
* the interaction service owns separate operation-specific commit authority. */
|
|
class PluginHostVaultService {
|
|
constructor({ sourceBinding, interactionService, clock = Date.now }) {
|
|
this.sourceBinding = sourceBinding;
|
|
this.interactionService = interactionService;
|
|
this.clock = clock;
|
|
this.key = randomBytes(32);
|
|
this.targets = new Map();
|
|
this.admissions = new WeakMap();
|
|
this.validators = Object.fromEntries([
|
|
"VaultSelectHostsParams", "VaultHostDraftParams", "VaultHostConnectParams",
|
|
"VaultHostSelectedResources", "VaultHostCreateFields", "VaultHostEditFields",
|
|
].map((name) => [name, createDefinitionValidator(name)]));
|
|
interactionService.vaultService = this;
|
|
}
|
|
|
|
isRequest(params) { return METHODS.includes(params?.kind); }
|
|
|
|
#validate(name, value) {
|
|
if (!this.validators[name](value)) throw fail("invalidArgument", "Host action parameters are invalid");
|
|
if (Buffer.byteLength(JSON.stringify(value)) > 65_536) throw fail("resourceExhausted", "Host action exceeds its size limit");
|
|
return structuredClone(value);
|
|
}
|
|
|
|
registerRpcCapabilities(registry) {
|
|
const definitions = ["VaultSelectHostsParams", "VaultHostDraftParams", "VaultHostConnectParams"];
|
|
for (const [index, method] of METHODS.entries()) {
|
|
registry.registerRequest(method, (params, context) => this.request(params, context), {
|
|
metadata: { capability: "vault", mutating: method !== "vault.selectHosts" },
|
|
validateParams: (params) => Object.freeze({ ...this.#validate(definitions[index], params), kind: method }),
|
|
authorization: async (params, context) => {
|
|
const binding = await this.sourceBinding.resolve(context);
|
|
if (params.target) this.#resolveTarget(params.target, params.expectedRevision, binding);
|
|
this.interactionService.admitRequest(params, context);
|
|
this.admissions.set(params, binding);
|
|
return {
|
|
permission: method === "vault.requestHostDraft" ? "vault.write" : method === "vault.selectHosts" ? "vault.metadata" : "ui.interact",
|
|
resources: ["*"], allowedScopes: ["once"], deferDecision: true,
|
|
reason: method === "vault.selectHosts" ? "Choose the current host metadata to share" : method === "vault.requestHostDraft" ? "Review a host draft before saving" : "Review a saved host connection and its script disclosure",
|
|
operationId: method,
|
|
};
|
|
},
|
|
});
|
|
}
|
|
}
|
|
|
|
async request(params, originalContext) {
|
|
const binding = await this.sourceBinding.resolve(originalContext);
|
|
if (this.admissions.get(params) !== binding) throw fail("permissionDenied", "Host action admission is unavailable");
|
|
this.admissions.delete(params);
|
|
const assertActive = async () => {
|
|
await originalContext.assertActive();
|
|
if (await this.sourceBinding.resolve(originalContext) !== binding) throw fail("permissionDenied", "Host action source changed");
|
|
if (params.target) this.#resolveTarget(params.target, params.expectedRevision, binding);
|
|
};
|
|
await assertActive();
|
|
return this.interactionService.request(params, Object.freeze({ ...originalContext, assertActive, vaultBinding: binding }));
|
|
}
|
|
|
|
#resolveTarget(ref, expectedRevision, binding) {
|
|
const entry = this.targets.get(ref?.handle);
|
|
if (!entry || ref.kind !== "host.selection" || ref.scope !== "metadata" || entry.binding !== binding
|
|
|| ref.revision !== entry.revision || expectedRevision !== entry.revision || ref.expiresAt !== entry.expiresAt
|
|
|| this.clock() >= entry.expiresAt || entry.owner !== this.interactionService.owner
|
|
|| entry.generation !== this.interactionService.ownerGeneration) {
|
|
throw fail("permissionDenied", "Host selection expired or changed; select the host again");
|
|
}
|
|
return entry;
|
|
}
|
|
|
|
#issueTarget(resource, context) {
|
|
const entry = {
|
|
binding: context.vaultBinding, resourceId: resource.resourceId, revision: resource.revision,
|
|
owner: this.interactionService.owner, generation: this.interactionService.ownerGeneration,
|
|
expiresAt: this.clock() + TARGET_LIFETIME_MS,
|
|
};
|
|
const nonce = randomBytes(24).toString("base64url");
|
|
const signature = createHmac("sha256", this.key).update(JSON.stringify([
|
|
nonce, entry.binding, entry.owner.id, entry.generation, entry.resourceId,
|
|
entry.revision, entry.expiresAt, "host.selection", "metadata",
|
|
])).digest("base64url");
|
|
const handle = `${nonce}.${signature}`;
|
|
this.targets.set(handle, entry);
|
|
return { kind: "host.selection", scope: "metadata", handle, revision: entry.revision, expiresAt: entry.expiresAt };
|
|
}
|
|
|
|
describePrompt(entry) {
|
|
if (!entry.params.target) return {};
|
|
const target = this.#resolveTarget(entry.params.target, entry.params.expectedRevision, entry.context.vaultBinding);
|
|
return { vaultTarget: { resourceId: target.resourceId, revision: target.revision } };
|
|
}
|
|
|
|
async respond(entry, response) {
|
|
await entry.context.assertActive();
|
|
if (response.action === "fail") throw fail("cancelled", "Host resource changed or the action could not complete");
|
|
if (entry.phase === "request" && response.action === "submit") {
|
|
if (entry.params.kind === "vault.selectHosts") {
|
|
const resources = this.#validate("VaultHostSelectedResources", response.resources);
|
|
if (resources.length > MAX_SELECTED || new Set(resources.map((resource) => resource.resourceId)).size !== resources.length) {
|
|
throw fail("invalidArgument", "Host selection is invalid");
|
|
}
|
|
this.releaseSelections(entry.context.vaultBinding);
|
|
this.pruneExpired();
|
|
if (this.targets.size + resources.length > MAX_REFERENCES) throw fail("resourceExhausted", "Too many host selections");
|
|
const hosts = resources.map(({ resourceId, revision, ...metadata }) => ({
|
|
target: this.#issueTarget({ resourceId, revision }, entry.context), metadata,
|
|
}));
|
|
const groups = [...new Set(hosts.map((host) => host.metadata.group).filter(Boolean))].map((path) => ({
|
|
path, members: hosts.filter((host) => host.metadata.group === path).map((host) => host.target),
|
|
}));
|
|
return { result: { cancelled: false, hosts, groups } };
|
|
}
|
|
if (entry.params.kind === "vault.requestHostDraft") {
|
|
const draft = this.#validate(entry.params.target ? "VaultHostEditFields" : "VaultHostCreateFields", response.draft);
|
|
return { phase: "commit", reviewedDraft: draft };
|
|
}
|
|
if (typeof response.scriptsRun !== "boolean") throw fail("invalidArgument", "Connection script disclosure is required");
|
|
return { phase: "commit" };
|
|
}
|
|
if (entry.phase === "commit" && response.action === "commit") return { phase: "executing" };
|
|
if (entry.phase === "executing" && response.action === "complete") {
|
|
return { result: { cancelled: false, status: entry.params.kind === "vault.requestConnect" ? "requested" : "saved" } };
|
|
}
|
|
throw fail("invalidArgument", "Host action phase is invalid");
|
|
}
|
|
|
|
pruneExpired() { for (const [handle, entry] of this.targets) if (this.clock() >= entry.expiresAt) this.targets.delete(handle); }
|
|
releaseSelections(binding) { for (const [handle, entry] of this.targets) if (entry.binding === binding) this.targets.delete(handle); }
|
|
releaseRuntime(runtimeId) {
|
|
for (const [handle, entry] of this.targets) if (entry.binding.runtimeId === runtimeId) this.targets.delete(handle);
|
|
this.sourceBinding.releaseRuntime(runtimeId);
|
|
}
|
|
releasePlugin(pluginId) {
|
|
for (const [handle, entry] of this.targets) if (entry.binding.pluginId === pluginId) this.targets.delete(handle);
|
|
// Keep the source helper's pinned runtime binding until runtime stop. A
|
|
// revoked old runtime must never rebind itself to a replacement source.
|
|
}
|
|
clearSelections() { this.targets.clear(); }
|
|
shutdown() { this.targets.clear(); this.sourceBinding.shutdown(); this.key.fill(0); }
|
|
}
|
|
|
|
module.exports = { PluginHostVaultService, METHODS, MAX_SELECTED, TARGET_LIFETIME_MS };
|