diff --git a/.changeset/miniflare-email-can-be-forwarded.md b/.changeset/miniflare-email-can-be-forwarded.md deleted file mode 100644 index 0f1c772ee5..0000000000 --- a/.changeset/miniflare-email-can-be-forwarded.md +++ /dev/null @@ -1,7 +0,0 @@ ---- -"miniflare": patch ---- - -Expose `canBeForwarded` boolean property on `ForwardableEmailMessage` in email handler - -Previously, in `wrangler dev`, the `ForwardableEmailMessage` passed to a Worker's `email()` handler did not expose the documented `canBeForwarded` property, causing it to read as `undefined` locally while production exposes it as a read-only boolean. `canBeForwarded: true` is now set on the incoming message object in Miniflare, matching production behavior. diff --git a/.changeset/vpc-custom-certificates.md b/.changeset/vpc-custom-certificates.md deleted file mode 100644 index c3d3373ae3..0000000000 --- a/.changeset/vpc-custom-certificates.md +++ /dev/null @@ -1,56 +0,0 @@ ---- -"wrangler": minor ---- - -Add custom CA and client certificate references to Workers VPC service TLS settings - -Workers VPC (open beta) service create and update commands accept `--certificate-authority` and `--client-certificate` UUIDs. Use either flag alone or both together. Whenever you supply either reference, explicitly choose `--cert-verification-mode`: - -- `verify_full`: verify the origin certificate chain and hostname (the platform default). -- `verify_ca`: verify the chain but skip hostname verification, weakening origin identity checks. -- `disabled`: do not verify the origin certificate; this allows connections to impersonated origins and is unsafe for production. - -For HTTP services, these settings apply to HTTPS connections, not plaintext HTTP. TCP services can use them for upstream TLS, including PostgreSQL. - -TLS settings are per-service only: host and resolver networks have no TLS settings or inheritance. Omitting TLS settings uses platform defaults (certificate chain and hostname verification). Explicit mode-only configuration, including `verify_full`, is accepted. A custom CA cannot be combined with `disabled`; a client certificate without a custom CA can. - -Upload certificates using the existing commands, then use the returned IDs below. Replace ``, ``, ``, and service IDs with your own values; certificate references must be valid UUIDs. Upload replacement certificates the same way before rotating their references. - -```sh -pnpm exec wrangler cert upload certificate-authority --ca-cert ./ca.pem --name private-ca -pnpm exec wrangler cert upload mtls-certificate --cert ./client.pem --key ./client-key.pem --name private-client -``` - -Create an HTTPS service with both a custom trust chain and an mTLS client certificate, or a PostgreSQL TCP service with only a custom CA: - -```sh -pnpm exec wrangler vpc service create private-web \ - --type http --https-port 443 --ipv4 10.0.0.10 --tunnel-id \ - --certificate-authority --client-certificate \ - --cert-verification-mode verify_full - -pnpm exec wrangler vpc service create private-db \ - --type tcp --tcp-port 5432 --app-protocol postgresql \ - --hostname db.internal.example --resolver-ips 10.0.0.53 --tunnel-id \ - --certificate-authority --cert-verification-mode verify_full -``` - -For client-certificate-only configuration, use `--client-certificate --cert-verification-mode verify_full` instead of the certificate flags in either create command. - -Updates replace the complete service configuration, including TLS settings, in a single request, the same as `cf workers-vpc services update`. Pass every TLS option the service should keep: certificate references and the verification mode that you omit are cleared, and an update without TLS options returns the service to the platform defaults. Removing a reference releases its backend certificate binding but does not delete the uploaded account certificate. For example, rotate the web service's client certificate while keeping its CA: - -```sh -pnpm exec wrangler vpc service update \ - --name private-web --type http --https-port 443 \ - --ipv4 10.0.0.10 --tunnel-id \ - --certificate-authority --client-certificate \ - --cert-verification-mode verify_full -``` - -To remove the CA while keeping the client certificate, repeat the update with only `--client-certificate ` and a verification mode. - -Inspect the service's verification mode and CA/client certificate UUIDs (or `None`), without exposing certificate or private-key contents: - -```sh -pnpm exec wrangler vpc service get -``` diff --git a/fixtures/get-platform-proxy-remote-bindings/tests/index.test.ts b/fixtures/get-platform-proxy-remote-bindings/tests/index.test.ts index 6c1453683c..2cdfaa8f3c 100644 --- a/fixtures/get-platform-proxy-remote-bindings/tests/index.test.ts +++ b/fixtures/get-platform-proxy-remote-bindings/tests/index.test.ts @@ -1,4 +1,5 @@ import { execSync } from "node:child_process"; +import { randomUUID } from "node:crypto"; import { mkdirSync, rmSync, writeFileSync } from "node:fs"; import { afterAll, @@ -26,13 +27,7 @@ const execOptions = { } as const; const remoteWorkerName = `preserve-e2e-get-platform-proxy-remote`; const remoteStagingWorkerName = `preserve-e2e-get-platform-proxy-remote-staging`; -// Shared across runs like the Workers above, and kept out of the scheduled -// cleanup by its `preserve-e2e-` prefix. A brand-new namespace can reject -// writes with "namespace not found" for longer than setup can wait, so reusing -// one means only the very first run ever has to wait for that. -const remoteKvName = "preserve-e2e-get-platform-proxy-kv"; -const remoteKvKey = "test-key"; -const remoteKvValue = "remote-kv-value"; +const remoteKvName = `tmp-e2e-kv${Date.now()}-test-remote-bindings-${randomUUID().split("-")[0]}`; if (auth) { describe("getPlatformProxy - remote bindings", { timeout: 50_000 }, () => { @@ -74,27 +69,39 @@ if (auth) { ); } - remoteKvId = ensureKvNamespace(remoteKvName); + const kvAddOut = execSync( + `pnpm wrangler kv namespace create ${remoteKvName}`, + execOptions + ); - // Only a newly created (or emptied) namespace needs the write. Brand-new - // namespaces may not be available to the KV write API yet. - if (readKvValue(remoteKvId, remoteKvKey) !== remoteKvValue) { - await vi.waitFor( - () => { - execSync( - `pnpm wrangler kv key put ${remoteKvKey} ${remoteKvValue} --namespace-id=${remoteKvId} --remote`, - { ...execOptions, timeout: 10_000 } - ); - }, - { timeout: 45_000, interval: 2_000 } - ); - } + const createdKvRegexMatch = kvAddOut.match(/"id": "(?[^"]*?)"/); + const maybeRemoteKvId = createdKvRegexMatch?.groups?.["id"]; + assert(maybeRemoteKvId, `Failed to create remote kv ${remoteKvName}`); + remoteKvId = maybeRemoteKvId; + + // Newly created namespaces may not be available to the KV write API yet. + await vi.waitFor( + () => { + execSync( + `pnpm wrangler kv key put test-key remote-kv-value --namespace-id=${remoteKvId} --remote`, + { ...execOptions, timeout: 10_000 } + ); + }, + { timeout: 15_000, interval: 1_000 } + ); rmSync("./.tmp", { recursive: true, force: true }); mkdirSync("./.tmp"); - }, 90_000); + }, 60_000); afterAll(() => { + try { + execSync( + `pnpm wrangler kv namespace delete --namespace-id=${remoteKvId}`, + execOptions + ); + } catch {} + try { rmSync("./.tmp", { recursive: true, @@ -348,52 +355,3 @@ function getAuthenticatedEnv() { "Skipping vitest-plugin remote bindings tests because the environment is not authenticated with Cloudflare." ); } - -/** - * Lists the account's KV namespaces through Wrangler. - */ -function listKvNamespaces(): { id: string; title: string }[] { - const out = execSync("pnpm wrangler kv namespace list", execOptions); - return JSON.parse(out.slice(out.search(/^\[/m))); -} - -/** - * Returns the ID of the KV namespace with the given title, creating it if it - * doesn't exist yet. - */ -function ensureKvNamespace(title: string): string { - const existing = listKvNamespaces().find((ns) => ns.title === title); - if (existing) { - return existing.id; - } - try { - const out = execSync( - `pnpm wrangler kv namespace create ${title}`, - execOptions - ); - const id = out.match(/"id": "(?[^"]*?)"/)?.groups?.["id"]; - if (id) { - return id; - } - } catch { - // Another CI job may have created it at the same time; look it up below. - } - const created = listKvNamespaces().find((ns) => ns.title === title); - assert(created, `Failed to find or create KV namespace ${title}`); - return created.id; -} - -/** - * Reads a KV value as text, or returns `undefined` if the key is missing or the - * read fails. - */ -function readKvValue(namespaceId: string, key: string): string | undefined { - try { - return execSync( - `pnpm wrangler kv key get ${key} --namespace-id=${namespaceId} --remote --text`, - { ...execOptions, timeout: 10_000, stdio: ["ignore", "pipe", "ignore"] } - ).trim(); - } catch { - return undefined; - } -} diff --git a/fixtures/get-platform-proxy-remote-bindings/vitest.config.e2e.mts b/fixtures/get-platform-proxy-remote-bindings/vitest.config.e2e.mts index 600b3d2398..b362bc404f 100644 --- a/fixtures/get-platform-proxy-remote-bindings/vitest.config.e2e.mts +++ b/fixtures/get-platform-proxy-remote-bindings/vitest.config.e2e.mts @@ -5,9 +5,8 @@ export default mergeConfig( configShared, defineProject({ test: { - // Preview API failures can outlast the short per-request retry window, - // sometimes for 40s or more, so space the retries out to ride that out. - retry: { count: 2, delay: 15_000 }, + // Preview API failures can outlast the short per-request retry window. + retry: { count: 1, delay: 5_000 }, }, }) ); diff --git a/packages/miniflare/src/workers/core/email.ts b/packages/miniflare/src/workers/core/email.ts index 44f341f916..1776b9e32a 100644 --- a/packages/miniflare/src/workers/core/email.ts +++ b/packages/miniflare/src/workers/core/email.ts @@ -259,7 +259,6 @@ export async function handleEmail( raw: deliveredEmailBody, rawSize: deliveredEmailRaw.byteLength, headers: incomingEmailHeaders, - canBeForwarded: true, setReject: (reason: string): void => { ctx.waitUntil( logEmailToLoopback( @@ -380,7 +379,7 @@ export async function handleEmail( }); return result; }, - } satisfies ForwardableEmailMessage + } satisfies Omit ); if (params.get("format") !== "json") { diff --git a/packages/miniflare/test/index.spec.ts b/packages/miniflare/test/index.spec.ts index 3fddcd9659..550fbe0e68 100644 --- a/packages/miniflare/test/index.spec.ts +++ b/packages/miniflare/test/index.spec.ts @@ -2584,70 +2584,6 @@ This is a random email body. expect(await res.text()).toBe("true"); }); -test("Miniflare: manually triggered email handler - exposes canBeForwarded on ForwardableEmailMessage", async ({ - expect, -}) => { - const log = new TestLog(); - - const mf = new Miniflare({ - log, - unsafeTriggerHandlers: true, - workers: [ - { - config: { - name: "", - compatibilityDate: "2025-05-01", - manifest: singleModuleManifest(` - let messageDetails = null; - export default { - fetch() { - return Response.json(messageDetails); - }, - async email(emailMessage) { - messageDetails = { - canBeForwarded: emailMessage.canBeForwarded, - hasCanBeForwarded: "canBeForwarded" in emailMessage, - rawSize: emailMessage.rawSize, - }; - } - }`), - }, - }, - ], - }); - useDispose(mf); - - let res = await mf.dispatchFetch("http://localhost"); - expect(await res.json()).toBe(null); - - res = await mf.dispatchFetch( - "http://localhost/cdn-cgi/local/email?from=someone@example.com&to=someone-else@example.com", - { - body: `From: someone -To: someone else -Message-ID: -MIME-Version: 1.0 -Content-Type: text/plain - -This is a random email body. -`, - method: "POST", - } - ); - expect(await res.text()).toBe("Worker successfully processed email"); - expect(res.status).toBe(200); - - res = await mf.dispatchFetch("http://localhost"); - const details = (await res.json()) as { - canBeForwarded: boolean; - hasCanBeForwarded: boolean; - rawSize: number; - }; - expect(details.canBeForwarded).toBe(true); - expect(details.hasCanBeForwarded).toBe(true); - expect(details.rawSize).toBeGreaterThan(0); -}); - test("Miniflare: manually triggered email handler - invalid email, no message id", async ({ expect, }) => { diff --git a/packages/wrangler/src/__tests__/vpc-tls.test.ts b/packages/wrangler/src/__tests__/vpc-tls.test.ts deleted file mode 100644 index ba6052ff36..0000000000 --- a/packages/wrangler/src/__tests__/vpc-tls.test.ts +++ /dev/null @@ -1,325 +0,0 @@ -import { runInTempDir } from "@cloudflare/workers-utils/test-helpers"; -import { http, HttpResponse } from "msw"; -import { beforeEach, describe, it, vi } from "vitest"; -import { ServiceType } from "../vpc/index"; -import { mockAccountId, mockApiToken } from "./helpers/mock-account-id"; -import { mockConsoleMethods } from "./helpers/mock-console"; -import { createFetchResult, msw } from "./helpers/msw"; -import { runWrangler } from "./helpers/run-wrangler"; -import type { - ConnectivityService, - ConnectivityServiceRequest, - TlsSettings, -} from "../vpc/index"; - -const servicesUrl = "*/accounts/:accountId/connectivity/directory/services"; -const serviceUrl = `${servicesUrl}/:serviceId`; -const tunnelId = "550e8400-e29b-41d4-a716-446655440000"; -const caId = "550e8400-e29b-41d4-a716-446655440001"; -const clientId = "550e8400-e29b-41d4-a716-446655440002"; -const serviceTls: TlsSettings = { - certificate_authority: caId, - client_certificate: clientId, - cert_verification_mode: "verify_ca", -}; - -function fixture( - hostname = false, - type = ServiceType.Tcp -): ConnectivityService { - return { - service_id: "service-uuid", - name: "database", - type, - ...(type === ServiceType.Tcp ? { tcp_port: 5432 } : { https_port: 443 }), - host: hostname - ? { - hostname: "db.example.com", - resolver_network: { - tunnel_id: tunnelId, - resolver_ips: ["10.0.0.53"], - }, - } - : { - ipv4: "10.0.0.1", - network: { - tunnel_id: tunnelId, - }, - }, - tls_settings: { ...serviceTls }, - created_at: "2024-01-01T00:00:00Z", - updated_at: "2024-01-01T00:00:00Z", - }; -} - -function command( - operation: "create" | "update", - hostname = false, - port = 5432, - type = ServiceType.Tcp -) { - return `vpc service ${operation} ${operation === "create" ? "database" : "service-uuid --name database"} --type ${type} --${type === ServiceType.Tcp ? "tcp" : "https"}-port ${port} --tunnel-id ${tunnelId} ${hostname ? "--hostname db.example.com --resolver-ips 10.0.0.53" : "--ipv4 10.0.0.1"}`; -} - -/** Simulate the replacement API: each write replaces the saved service. */ -function savedService(initial = fixture()) { - let saved = initial; - const calls: string[] = []; - const writes: ConnectivityServiceRequest[] = []; - function replace(body: ConnectivityServiceRequest) { - writes.push(body); - saved = { - ...body, - service_id: initial.service_id, - created_at: initial.created_at, - updated_at: "2024-01-02T00:00:00Z", - }; - return HttpResponse.json(createFetchResult(saved, true)); - } - msw.use( - http.post(servicesUrl, async ({ request }) => { - calls.push("POST"); - return replace((await request.json()) as ConnectivityServiceRequest); - }), - http.get(serviceUrl, () => { - calls.push("GET"); - return HttpResponse.json(createFetchResult(saved, true)); - }), - http.put(serviceUrl, async ({ request }) => { - calls.push("PUT"); - return replace((await request.json()) as ConnectivityServiceRequest); - }) - ); - return { calls, writes, current: () => saved }; -} - -function rejectAllApiCalls() { - const requests = vi.fn(() => - HttpResponse.json(createFetchResult(null, false), { status: 500 }) - ); - msw.use(http.all("*", requests)); - return requests; -} - -describe("VPC TLS configuration", () => { - mockAccountId(); - mockApiToken(); - runInTempDir(); - const std = mockConsoleMethods(); - - beforeEach(() => { - // Avoid the command banner's artificial delay. - // @ts-expect-error this mock only needs to schedule the callback - vi.spyOn(global, "setTimeout").mockImplementation((fn, _period) => { - setImmediate(fn); - }); - }); - - describe.each(["create", "update"] as const)("%s validation", (operation) => { - it.for([ - ["certificate-authority", caId], - ["client-certificate", clientId], - ])( - "requires an explicit mode for --%s before any API call", - async ([flag, id], { expect }) => { - const requests = rejectAllApiCalls(); - await expect( - runWrangler(`${command(operation)} --${flag} ${id}`) - ).rejects.toThrow( - "--cert-verification-mode is required when providing --certificate-authority or --client-certificate. Choose verify_full, verify_ca, or disabled." - ); - expect(requests).not.toHaveBeenCalled(); - } - ); - - it.for(["certificate-authority", "client-certificate"])( - "rejects invalid --%s UUIDs before any API call", - async (flag, { expect }) => { - const requests = rejectAllApiCalls(); - await expect( - runWrangler( - `${command(operation)} --${flag} not-a-uuid --cert-verification-mode verify_ca` - ) - ).rejects.toThrow(); - expect(requests).not.toHaveBeenCalled(); - expect(std.err).toContain(flag); - } - ); - - it("rejects an invalid verification mode before any API call", async ({ - expect, - }) => { - const requests = rejectAllApiCalls(); - await expect( - runWrangler(`${command(operation)} --cert-verification-mode not-a-mode`) - ).rejects.toThrow(); - expect(requests).not.toHaveBeenCalled(); - expect(std.err).toContain("cert-verification-mode"); - }); - - it("rejects a CA with disabled verification before any API call", async ({ - expect, - }) => { - const requests = rejectAllApiCalls(); - await expect( - runWrangler( - `${command(operation)} --certificate-authority ${caId} --cert-verification-mode disabled` - ) - ).rejects.toThrow(/certificate.authority/i); - expect(requests).not.toHaveBeenCalled(); - expect(std.out).not.toContain("Created VPC service"); - expect(std.out).not.toContain("Updated VPC service"); - }); - - it.for([ - `--network-certificate-authority ${caId}`, - `--network-client-certificate ${clientId}`, - "--network-cert-verification-mode verify_ca", - "--remove-network-certificate-authority", - "--remove-network-client-certificate", - "--remove-network-tls-settings", - "--use-network-tls-settings", - "--remove-certificate-authority", - "--remove-client-certificate", - ])( - "rejects unsupported TLS flags rather than silently ignoring them: %s", - async (flags, { expect }) => { - const requests = rejectAllApiCalls(); - await expect( - runWrangler(`${command(operation)} ${flags}`) - ).rejects.toThrow(/Unknown argument/); - expect(requests).not.toHaveBeenCalled(); - } - ); - }); - - const tlsCases = [ - ["no TLS options", "", undefined], - [ - "mode-only verify_full", - "--cert-verification-mode verify_full", - { cert_verification_mode: "verify_full" }, - ], - [ - "mode-only disabled", - "--cert-verification-mode disabled", - { cert_verification_mode: "disabled" }, - ], - [ - "a custom CA", - `--certificate-authority ${caId} --cert-verification-mode verify_full`, - { certificate_authority: caId, cert_verification_mode: "verify_full" }, - ], - [ - "a client certificate with verification disabled", - `--client-certificate ${clientId} --cert-verification-mode disabled`, - { client_certificate: clientId, cert_verification_mode: "disabled" }, - ], - [ - "both certificates", - `--certificate-authority ${caId} --client-certificate ${clientId} --cert-verification-mode verify_ca`, - serviceTls, - ], - ] as const; - - describe.each([ServiceType.Tcp, ServiceType.Http])("%s services", (type) => { - it.for(tlsCases)( - "creates a service with %s", - async ([_label, flags, tls], { expect }) => { - const api = savedService(fixture(false, type)); - await runWrangler(`${command("create", false, 443, type)} ${flags}`); - expect(api.calls).toEqual(["POST"]); - expect(api.writes[0].tls_settings).toEqual(tls); - } - ); - }); - - it.for(tlsCases)( - "replaces the service TLS settings with %s in a single PUT", - async ([_label, flags, tls], { expect }) => { - const api = savedService(); - await runWrangler(`${command("update")} ${flags}`); - expect(api.calls).toEqual(["PUT"]); - expect(api.writes[0].tls_settings).toEqual(tls); - expect(api.current().tls_settings).toEqual(tls); - } - ); - - it.for([false, true])( - "reports configured service TLS without private data (hostname=%s)", - async (hostname, { expect }) => { - const service = { - ...fixture(hostname), - internal_id: "internal-secret-marker", - private_key: "private-key-marker", - certificate: "certificate-pem-marker", - }; - msw.use( - http.get(serviceUrl, () => - HttpResponse.json(createFetchResult(service, true)) - ) - ); - await runWrangler("vpc service get service-uuid"); - for (const id of [caId, clientId]) { - expect(std.out).toContain(id); - } - expect(std.out).toContain("verify_ca"); - for (const secret of [ - "internal-secret-marker", - "private-key-marker", - "certificate-pem-marker", - ]) { - expect(std.out).not.toContain(secret); - } - } - ); - - it.for([ - ["disabled", "None"], - ["verify_ca", "None (system trust store)"], - ["verify_full", "None (system trust store)"], - ] as const)( - "reports the default certificate authority for %s verification", - async ([mode, authority], { expect }) => { - const service = fixture(); - service.tls_settings = { cert_verification_mode: mode }; - savedService(service); - await runWrangler("vpc service get service-uuid"); - expect(std.out).toContain(`Certificate Authority: ${authority}\n`); - } - ); - - it.for(["create", "update"] as const)( - "surfaces certificate API errors on %s without reporting success", - async (operation, { expect }) => { - const writes: ConnectivityServiceRequest[] = []; - const failure = HttpResponse.json( - { - success: false, - errors: [{ code: 1000, message: "Certificate not found" }], - messages: [], - result: null, - }, - { status: 400 } - ); - msw.use( - http.post(servicesUrl, async ({ request }) => { - writes.push((await request.json()) as ConnectivityServiceRequest); - return failure; - }), - http.put(serviceUrl, async ({ request }) => { - writes.push((await request.json()) as ConnectivityServiceRequest); - return failure; - }) - ); - await expect( - runWrangler( - `${command(operation)} --certificate-authority ${caId} --cert-verification-mode verify_ca` - ) - ).rejects.toThrow(); - expect(writes).toHaveLength(1); - expect(std.out).not.toContain("Created VPC service"); - expect(std.out).not.toContain("Updated VPC service"); - } - ); -}); diff --git a/packages/wrangler/src/__tests__/vpc.test.ts b/packages/wrangler/src/__tests__/vpc.test.ts index b6099db892..0468ab365a 100644 --- a/packages/wrangler/src/__tests__/vpc.test.ts +++ b/packages/wrangler/src/__tests__/vpc.test.ts @@ -573,6 +573,177 @@ describe("vpc service commands", () => { `); }); + it("should handle creating a TCP service with --cert-verification-mode verify_ca", async ({ + expect, + }) => { + const reqProm = mockWvpcServiceCreate(); + await runWrangler( + "vpc service create test-tcp-tls --type tcp --tcp-port 5432 --ipv4 10.0.0.5 --tunnel-id 550e8400-e29b-41d4-a716-446655440000 --cert-verification-mode verify_ca" + ); + + await expect(reqProm).resolves.toMatchInlineSnapshot(` + { + "host": { + "ipv4": "10.0.0.5", + "network": { + "tunnel_id": "550e8400-e29b-41d4-a716-446655440000", + }, + }, + "name": "test-tcp-tls", + "tcp_port": 5432, + "tls_settings": { + "cert_verification_mode": "verify_ca", + }, + "type": "tcp", + } + `); + + expect(std.out).toMatchInlineSnapshot(` + " + ⛅️ wrangler x.x.x + ────────────────── + 🚧 Creating VPC service 'test-tcp-tls' + ✅ Created VPC service: service-uuid + Name: test-tcp-tls + Type: tcp + TCP Port: 5432 + Cert Verification Mode: verify_ca + IPv4: 10.0.0.5 + Tunnel ID: 550e8400-e29b-41d4-a716-446655440000" + `); + }); + + it("should handle creating an HTTP service with --cert-verification-mode disabled", async ({ + expect, + }) => { + const reqProm = mockWvpcServiceCreate(); + await runWrangler( + "vpc service create test-http-tls --type http --http-port 80 --ipv4 10.0.0.1 --tunnel-id 550e8400-e29b-41d4-a716-446655440000 --cert-verification-mode disabled" + ); + + await expect(reqProm).resolves.toMatchInlineSnapshot(` + { + "host": { + "ipv4": "10.0.0.1", + "network": { + "tunnel_id": "550e8400-e29b-41d4-a716-446655440000", + }, + }, + "http_port": 80, + "name": "test-http-tls", + "tls_settings": { + "cert_verification_mode": "disabled", + }, + "type": "http", + } + `); + + expect(std.out).toMatchInlineSnapshot(` + " + ⛅️ wrangler x.x.x + ────────────────── + 🚧 Creating VPC service 'test-http-tls' + ✅ Created VPC service: service-uuid + Name: test-http-tls + Type: http + HTTP Port: 80 + Cert Verification Mode: disabled + IPv4: 10.0.0.1 + Tunnel ID: 550e8400-e29b-41d4-a716-446655440000" + `); + }); + + it("should not include tls_settings when --cert-verification-mode is not specified", async ({ + expect, + }) => { + const reqProm = mockWvpcServiceCreate(); + await runWrangler( + "vpc service create test-no-tls --type tcp --tcp-port 5432 --ipv4 10.0.0.5 --tunnel-id 550e8400-e29b-41d4-a716-446655440000" + ); + + const reqBody = await reqProm; + expect(reqBody.tls_settings).toBeUndefined(); + }); + + it("should handle getting a service with tls_settings", async ({ + expect, + }) => { + const serviceWithTls: ConnectivityService = { + ...mockTcpService, + tls_settings: { + cert_verification_mode: "verify_ca", + }, + }; + + msw.use( + http.get( + "*/accounts/:accountId/connectivity/directory/services/:serviceId", + () => { + return HttpResponse.json(createFetchResult(serviceWithTls, true)); + }, + { once: true } + ) + ); + + await runWrangler("vpc service get tcp-service-uuid"); + + expect(std.out).toMatchInlineSnapshot(` + " + ⛅️ wrangler x.x.x + ────────────────── + 🔍 Getting VPC service 'tcp-service-uuid' + ✅ Retrieved VPC service: tcp-service-uuid + Name: test-tcp-service + Type: tcp + TCP Port: 5432 + App Protocol: postgresql + Cert Verification Mode: verify_ca + IPv4: 10.0.0.5 + Tunnel ID: 550e8400-e29b-41d4-a716-446655440000 + Created: 1/1/2024, 12:00:00 AM + Modified: 1/1/2024, 12:00:00 AM" + `); + }); + + it("should handle updating a service with --cert-verification-mode", async ({ + expect, + }) => { + const reqProm = mockWvpcServiceUpdate(); + await runWrangler( + "vpc service update service-uuid --name test-updated --type http --http-port 80 --ipv4 10.0.0.2 --tunnel-id 550e8400-e29b-41d4-a716-446655440001 --cert-verification-mode verify_full" + ); + + await expect(reqProm).resolves.toMatchInlineSnapshot(` + { + "host": { + "ipv4": "10.0.0.2", + "network": { + "tunnel_id": "550e8400-e29b-41d4-a716-446655440001", + }, + }, + "http_port": 80, + "name": "test-updated", + "tls_settings": { + "cert_verification_mode": "verify_full", + }, + "type": "http", + } + `); + }); + + it("should reject --cert-verification-mode with invalid value", async ({ + expect, + }) => { + await expect(() => + runWrangler( + "vpc service create test-bad-tls --type tcp --tcp-port 5432 --ipv4 10.0.0.1 --tunnel-id 550e8400-e29b-41d4-a716-446655440000 --cert-verification-mode invalid" + ) + ).rejects.toThrow(); + expect(std.err).toContain("Invalid values"); + expect(std.err).toContain("cert-verification-mode"); + expect(std.err).toContain('"invalid"'); + }); + it("should extract port from hostname for TCP services", async ({ expect, }) => { diff --git a/packages/wrangler/src/vpc/index.ts b/packages/wrangler/src/vpc/index.ts index 6d0689f955..942b1cfc05 100644 --- a/packages/wrangler/src/vpc/index.ts +++ b/packages/wrangler/src/vpc/index.ts @@ -26,8 +26,6 @@ export type CertVerificationMode = "verify_full" | "verify_ca" | "disabled"; export interface TlsSettings { cert_verification_mode: CertVerificationMode; - certificate_authority?: string; - client_certificate?: string; } export interface ServicePortOptions { @@ -169,17 +167,7 @@ export const serviceOptions = { type: "string", choices: ["verify_full", "verify_ca", "disabled"] as const, description: - "Origin verification: verify_full checks chain and hostname; verify_ca checks chain only; disabled skips verification and cannot be used with a custom CA. Required when providing certificates. On update, TLS options you omit are cleared", - group: "TLS Options", - }, - "certificate-authority": { - type: "string", - description: "UUID returned by wrangler cert upload certificate-authority", - group: "TLS Options", - }, - "client-certificate": { - type: "string", - description: "UUID returned by wrangler cert upload mtls-certificate", + "TLS certificate verification mode for the connection to the origin", group: "TLS Options", }, } as const; diff --git a/packages/wrangler/src/vpc/shared.ts b/packages/wrangler/src/vpc/shared.ts index 8abc8a3f20..0a8c7a57ac 100644 --- a/packages/wrangler/src/vpc/shared.ts +++ b/packages/wrangler/src/vpc/shared.ts @@ -23,20 +23,11 @@ export function displayServiceDetails(service: ConnectivityService) { } } + // Display TLS settings if (service.tls_settings) { - const defaultCertificateAuthority = - service.tls_settings.cert_verification_mode === "disabled" - ? "None" - : "None (system trust store)"; logger.log( ` Cert Verification Mode: ${service.tls_settings.cert_verification_mode}` ); - logger.log( - ` Certificate Authority: ${service.tls_settings.certificate_authority ?? defaultCertificateAuthority}` - ); - logger.log( - ` Client Certificate: ${service.tls_settings.client_certificate ?? "None"}` - ); } // Display host details diff --git a/packages/wrangler/src/vpc/tls.ts b/packages/wrangler/src/vpc/tls.ts deleted file mode 100644 index b0191bc38c..0000000000 --- a/packages/wrangler/src/vpc/tls.ts +++ /dev/null @@ -1,92 +0,0 @@ -import { UserError } from "@cloudflare/workers-utils"; -import type { CertVerificationMode, TlsSettings } from "./index"; - -export interface TlsArgs { - certificateAuthority?: string; - clientCertificate?: string; - certVerificationMode?: string; -} - -/** - * Validates the TLS flags of `vpc service create` and `vpc service update` - * before any API call. - * - * A certificate reference requires an explicit verification mode, and a custom - * CA cannot be combined with `disabled`, because it is used only to verify the - * origin certificate. - * - * @param args - The TLS flags supplied on the command line. - * @throws {UserError} If the flags describe invalid TLS settings. - */ -export function validateTlsArgs(args: TlsArgs): void { - if ( - (args.certificateAuthority !== undefined || - args.clientCertificate !== undefined) && - args.certVerificationMode === undefined - ) { - throw new UserError( - "--cert-verification-mode is required when providing --certificate-authority or --client-certificate. Choose verify_full, verify_ca, or disabled.", - { telemetryMessage: "vpc tls missing cert verification mode" } - ); - } - if ( - args.certVerificationMode !== undefined && - !["verify_full", "verify_ca", "disabled"].includes( - args.certVerificationMode - ) - ) { - throw new UserError( - "Invalid --cert-verification-mode. Choose verify_full, verify_ca, or disabled.", - { telemetryMessage: "vpc tls invalid cert verification mode" } - ); - } - for (const [flag, id] of [ - ["certificate-authority", args.certificateAuthority], - ["client-certificate", args.clientCertificate], - ] as const) { - if ( - id !== undefined && - !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test( - id - ) - ) { - throw new UserError( - `Invalid --${flag}: '${id}'. Provide the certificate UUID returned by wrangler cert upload.`, - { telemetryMessage: `vpc tls invalid ${flag}` } - ); - } - } - if ( - args.certificateAuthority !== undefined && - args.certVerificationMode === "disabled" - ) { - throw new UserError( - "--certificate-authority requires --cert-verification-mode verify_ca or verify_full; disabled cannot verify a custom CA.", - { - telemetryMessage: - "vpc tls certificate authority with disabled verification", - } - ); - } -} - -/** - * Builds the service TLS settings from the command-line flags alone. - * - * Service updates replace the whole configuration, so settings omitted here are - * not carried over from the existing service. - * - * @param args - TLS flags that have passed {@link validateTlsArgs}. - * @returns The TLS settings to send, or `undefined` when no TLS flags were - * supplied, which leaves the service on the platform defaults. - */ -export function tlsSettingsFromArgs(args: TlsArgs): TlsSettings | undefined { - if (args.certVerificationMode === undefined) { - return undefined; - } - return { - cert_verification_mode: args.certVerificationMode as CertVerificationMode, - certificate_authority: args.certificateAuthority, - client_certificate: args.clientCertificate, - }; -} diff --git a/packages/wrangler/src/vpc/validation.ts b/packages/wrangler/src/vpc/validation.ts index 277f08da85..aa3db185e2 100644 --- a/packages/wrangler/src/vpc/validation.ts +++ b/packages/wrangler/src/vpc/validation.ts @@ -1,11 +1,13 @@ import net from "node:net"; import { UserError } from "@cloudflare/workers-utils"; -import { tlsSettingsFromArgs, validateTlsArgs } from "./tls"; import { ServiceType } from "./index"; -import type { ConnectivityServiceRequest, ServiceHost } from "./index"; -import type { TlsArgs } from "./tls"; +import type { + CertVerificationMode, + ConnectivityServiceRequest, + ServiceHost, +} from "./index"; -export interface ServiceArgs extends TlsArgs { +export interface ServiceArgs { name: string; type: ServiceType; tcpPort?: number; @@ -17,6 +19,7 @@ export interface ServiceArgs extends TlsArgs { hostname?: string; tunnelId: string; resolverIps?: string; + certVerificationMode?: string; } export function validateHostname(hostname: string): void { @@ -113,21 +116,20 @@ export function extractPortFromHostname(hostname: string): { * `--hostname db.internal:5432` is equivalent to * `--hostname db.internal --tcp-port 5432`. */ -export function toServiceArgs( - args: { - name: string; - type: string; - tcpPort?: number; - appProtocol?: string; - httpPort?: number; - httpsPort?: number; - ipv4?: string; - ipv6?: string; - hostname?: string; - tunnelId: string; - resolverIps?: string; - } & TlsArgs -): ServiceArgs { +export function toServiceArgs(args: { + name: string; + type: string; + tcpPort?: number; + appProtocol?: string; + httpPort?: number; + httpsPort?: number; + ipv4?: string; + ipv6?: string; + hostname?: string; + tunnelId: string; + resolverIps?: string; + certVerificationMode?: string; +}): ServiceArgs { const type = args.type as ServiceType; let { hostname } = args; let tcpPort = args.tcpPort; @@ -159,13 +161,10 @@ export function toServiceArgs( tunnelId: args.tunnelId, resolverIps: args.resolverIps, certVerificationMode: args.certVerificationMode, - certificateAuthority: args.certificateAuthority, - clientCertificate: args.clientCertificate, }; } export function validateRequest(args: ServiceArgs) { - validateTlsArgs(args); // Validate host configuration - must have either IP addresses or hostname, not both const hasIpAddresses = Boolean(args.ipv4 || args.ipv6); const hasHostname = Boolean(args.hostname); @@ -262,7 +261,12 @@ export function buildRequest(args: ServiceArgs): ConnectivityServiceRequest { request.https_port = args.httpsPort; } - request.tls_settings = tlsSettingsFromArgs(args); + // Add TLS settings if specified + if (args.certVerificationMode) { + request.tls_settings = { + cert_verification_mode: args.certVerificationMode as CertVerificationMode, + }; + } return request; }