From 5f05841d4d4a4a67fee5ddc0150309b5ed782069 Mon Sep 17 00:00:00 2001 From: Matt Date: Mon, 16 Nov 2026 15:12:45 -0600 Subject: [PATCH] [wrangler] Add custom CA and mTLS configuration to VPC services (#16450) Co-authored-by: Pete Bacon Darwin --- .changeset/vpc-custom-certificates.md | 56 +++ .../wrangler/src/__tests__/vpc-tls.test.ts | 325 ++++++++++++++++++ packages/wrangler/src/__tests__/vpc.test.ts | 171 --------- packages/wrangler/src/vpc/index.ts | 14 +- packages/wrangler/src/vpc/shared.ts | 11 +- packages/wrangler/src/vpc/tls.ts | 92 +++++ packages/wrangler/src/vpc/validation.ts | 50 ++- 7 files changed, 519 insertions(+), 200 deletions(-) create mode 100644 .changeset/vpc-custom-certificates.md create mode 100644 packages/wrangler/src/__tests__/vpc-tls.test.ts create mode 100644 packages/wrangler/src/vpc/tls.ts diff --git a/.changeset/vpc-custom-certificates.md b/.changeset/vpc-custom-certificates.md new file mode 100644 index 0000000000..c3d3373ae3 --- /dev/null +++ b/.changeset/vpc-custom-certificates.md @@ -0,0 +1,56 @@ +--- +"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/packages/wrangler/src/__tests__/vpc-tls.test.ts b/packages/wrangler/src/__tests__/vpc-tls.test.ts new file mode 100644 index 0000000000..ba6052ff36 --- /dev/null +++ b/packages/wrangler/src/__tests__/vpc-tls.test.ts @@ -0,0 +1,325 @@ +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 0468ab365a..b6099db892 100644 --- a/packages/wrangler/src/__tests__/vpc.test.ts +++ b/packages/wrangler/src/__tests__/vpc.test.ts @@ -573,177 +573,6 @@ 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 942b1cfc05..6d0689f955 100644 --- a/packages/wrangler/src/vpc/index.ts +++ b/packages/wrangler/src/vpc/index.ts @@ -26,6 +26,8 @@ export type CertVerificationMode = "verify_full" | "verify_ca" | "disabled"; export interface TlsSettings { cert_verification_mode: CertVerificationMode; + certificate_authority?: string; + client_certificate?: string; } export interface ServicePortOptions { @@ -167,7 +169,17 @@ export const serviceOptions = { type: "string", choices: ["verify_full", "verify_ca", "disabled"] as const, description: - "TLS certificate verification mode for the connection to the origin", + "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", group: "TLS Options", }, } as const; diff --git a/packages/wrangler/src/vpc/shared.ts b/packages/wrangler/src/vpc/shared.ts index 0a8c7a57ac..8abc8a3f20 100644 --- a/packages/wrangler/src/vpc/shared.ts +++ b/packages/wrangler/src/vpc/shared.ts @@ -23,11 +23,20 @@ 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 new file mode 100644 index 0000000000..b0191bc38c --- /dev/null +++ b/packages/wrangler/src/vpc/tls.ts @@ -0,0 +1,92 @@ +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 aa3db185e2..277f08da85 100644 --- a/packages/wrangler/src/vpc/validation.ts +++ b/packages/wrangler/src/vpc/validation.ts @@ -1,13 +1,11 @@ import net from "node:net"; import { UserError } from "@cloudflare/workers-utils"; +import { tlsSettingsFromArgs, validateTlsArgs } from "./tls"; import { ServiceType } from "./index"; -import type { - CertVerificationMode, - ConnectivityServiceRequest, - ServiceHost, -} from "./index"; +import type { ConnectivityServiceRequest, ServiceHost } from "./index"; +import type { TlsArgs } from "./tls"; -export interface ServiceArgs { +export interface ServiceArgs extends TlsArgs { name: string; type: ServiceType; tcpPort?: number; @@ -19,7 +17,6 @@ export interface ServiceArgs { hostname?: string; tunnelId: string; resolverIps?: string; - certVerificationMode?: string; } export function validateHostname(hostname: string): void { @@ -116,20 +113,21 @@ 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; - certVerificationMode?: string; -}): 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; + } & TlsArgs +): ServiceArgs { const type = args.type as ServiceType; let { hostname } = args; let tcpPort = args.tcpPort; @@ -161,10 +159,13 @@ export function toServiceArgs(args: { 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); @@ -261,12 +262,7 @@ export function buildRequest(args: ServiceArgs): ConnectivityServiceRequest { request.https_port = args.httpsPort; } - // Add TLS settings if specified - if (args.certVerificationMode) { - request.tls_settings = { - cert_verification_mode: args.certVerificationMode as CertVerificationMode, - }; - } + request.tls_settings = tlsSettingsFromArgs(args); return request; }