add validation for docker TLS fields, encrypt TLS key on create/edit monitor

This commit is contained in:
Alex Holliday committed 2026-09-11 11:10:37 -07:00
1 parent cfb50afe42
commit 2260b4a4d2
5 files changed
+411 -3

No files matched your search

@@ -7,6 +7,8 @@ import type { IIncidentsRepository } from "../../../src/domain/incidents/inciden
import type { IMonitorStatsRepository } from "../../../src/domain/monitor-stats/monitor-stats.repository.interface.ts";
import type { IMonitorsRepository } from "../../../src/domain/monitors/monitor.repository.interface.ts";
import type { IStatusPagesRepository } from "../../../src/domain/status-pages/status-page-repository.interface.ts";
import type { IEncryptionService } from "../../../src/service/encryption/encryptionService.ts";
import { AppError } from "../../../src/utils/AppError.ts";
import { createMockLogger } from "../../helpers/createMockLogger.ts";
const createMonitorsRepositoryMock = () =>
@@ -70,6 +72,17 @@ const createJobQueueMock = () => ({
deleteJob: jest.fn(),
});
const createEncryptionServiceMock = (overrides: Partial<IEncryptionService> = {}) =>
({
isConfigured: jest.fn(() => true),
currentKeyId: jest.fn(() => "key-1"),
keyIdOf: jest.fn(() => "key-1"),
needsReencryption: jest.fn(() => false),
encrypt: jest.fn((plaintext: string) => `enc:${plaintext}`),
decrypt: jest.fn((ciphertext: string) => ciphertext.replace(/^enc:/, "")),
...overrides,
}) as unknown as IEncryptionService;
const TEAM_ID = "team-1";
const MONITOR_ID = "monitor-1";
const USER_ID = "user-1";
@@ -98,6 +111,7 @@ const createService = (
geoChecksRepository?: IGeoChecksRepository;
dockerLogsRepository?: IDockerLogsRepository;
incidentsRepository?: IIncidentsRepository;
encryptionService?: IEncryptionService;
jobQueue?: ReturnType<typeof createJobQueueMock>;
logger?: ReturnType<typeof createMockLogger>;
games?: Record<string, unknown>;
@@ -116,6 +130,7 @@ const createService = (
monitorStatsRepository: overrides.monitorStatsRepository ?? createMonitorStatsRepositoryMock(),
statusPagesRepository: overrides.statusPagesRepository ?? createStatusPagesRepositoryMock(),
incidentsRepository: overrides.incidentsRepository ?? createIncidentsRepositoryMock(),
encryptionService: overrides.encryptionService ?? createEncryptionServiceMock(),
});
return { service, jobQueue, logger };
};
@@ -1893,6 +1908,7 @@ describe("MonitorService", () => {
monitorStatsRepository,
statusPagesRepository,
incidentsRepository,
encryptionService: createEncryptionServiceMock(),
});
const result = await service.deleteAllMonitors({ teamId: TEAM_ID });
@@ -1981,3 +1997,167 @@ describe("MonitorService", () => {
});
});
});
describe("MonitorService — Docker TLS credentials", () => {
const KEY_PEM = "-----BEGIN PRIVATE KEY-----\nkey\n-----END PRIVATE KEY-----";
const tlsBody = { type: "docker" as const, url: "tcp://host:2376", dockerTlsCa: "ca-pem", dockerTlsCert: "cert-pem", dockerTlsKey: KEY_PEM };
const expectAppError = async (fn: () => Promise<unknown>, status: number, message: string | RegExp) => {
let caught: unknown;
try {
await fn();
} catch (error) {
caught = error;
}
expect(caught).toBeInstanceOf(AppError);
expect((caught as AppError).status).toBe(status);
expect((caught as AppError).message).toMatch(message);
};
describe("createMonitor", () => {
it("encrypts the key and sets dockerTlsKeySet for a TLS url", async () => {
const monitorsRepository = createMonitorsRepositoryMock();
(monitorsRepository.create as jest.Mock).mockResolvedValue(makeMonitor({ type: "docker" }));
const encryptionService = createEncryptionServiceMock();
const { service } = createService({ monitorsRepository, encryptionService });
await service.createMonitor(TEAM_ID, USER_ID, makeMonitor(tlsBody) as any);
expect(encryptionService.encrypt).toHaveBeenCalledWith(KEY_PEM);
expect(monitorsRepository.create).toHaveBeenCalledWith(
expect.objectContaining({ dockerTlsCa: "ca-pem", dockerTlsCert: "cert-pem", dockerTlsKey: `enc:${KEY_PEM}`, dockerTlsKeySet: true }),
TEAM_ID,
USER_ID
);
});
it("does not encrypt anything for a socket url and leaves dockerTlsKeySet false", async () => {
const monitorsRepository = createMonitorsRepositoryMock();
(monitorsRepository.create as jest.Mock).mockResolvedValue(makeMonitor({ type: "docker" }));
const encryptionService = createEncryptionServiceMock();
const { service } = createService({ monitorsRepository, encryptionService });
await service.createMonitor(TEAM_ID, USER_ID, makeMonitor({ type: "docker", url: "unix:///var/run/docker.sock" }) as any);
expect(encryptionService.encrypt).not.toHaveBeenCalled();
const [created] = (monitorsRepository.create as jest.Mock).mock.calls[0] as [Record<string, unknown>];
expect(created.dockerTlsKeySet).toBe(false);
expect(created.dockerTlsKey).toBeUndefined();
});
it("ignores TLS fields on non-docker monitors", async () => {
const monitorsRepository = createMonitorsRepositoryMock();
(monitorsRepository.create as jest.Mock).mockResolvedValue(makeMonitor());
const encryptionService = createEncryptionServiceMock();
const { service } = createService({ monitorsRepository, encryptionService });
await service.createMonitor(TEAM_ID, USER_ID, makeMonitor({ dockerTlsKey: KEY_PEM }) as any);
expect(encryptionService.encrypt).not.toHaveBeenCalled();
expect(monitorsRepository.create).toHaveBeenCalledWith(expect.objectContaining({ dockerTlsKey: KEY_PEM }), TEAM_ID, USER_ID);
});
it("rejects with a 422 naming ENCRYPTION_KEY when encryption is not configured", async () => {
const monitorsRepository = createMonitorsRepositoryMock();
const encryptionService = createEncryptionServiceMock({ isConfigured: jest.fn(() => false) as any });
const { service } = createService({ monitorsRepository, encryptionService });
await expectAppError(() => service.createMonitor(TEAM_ID, USER_ID, makeMonitor(tlsBody) as any), 422, /ENCRYPTION_KEY/);
expect(encryptionService.encrypt).not.toHaveBeenCalled();
expect(monitorsRepository.create).not.toHaveBeenCalled();
});
});
describe("editMonitor", () => {
it("keeps the stored key when the key field is blank", async () => {
const monitorsRepository = createMonitorsRepositoryMock();
(monitorsRepository.findById as jest.Mock).mockResolvedValue(makeMonitor({ type: "docker", dockerTlsKeySet: true }));
(monitorsRepository.updateById as jest.Mock).mockResolvedValue(makeMonitor({ type: "docker" }));
const encryptionService = createEncryptionServiceMock();
const { service } = createService({ monitorsRepository, encryptionService });
await service.editMonitor({ teamId: TEAM_ID, monitorId: MONITOR_ID, body: { ...tlsBody, dockerTlsKey: "" } });
expect(encryptionService.encrypt).not.toHaveBeenCalled();
const [, , patch] = (monitorsRepository.updateById as jest.Mock).mock.calls[0] as [string, string, Record<string, unknown>];
expect(patch).not.toHaveProperty("dockerTlsKey");
expect(patch).not.toHaveProperty("dockerTlsKeySet");
expect(patch).toMatchObject({ dockerTlsCa: "ca-pem", dockerTlsCert: "cert-pem" });
});
it("rejects a blank key with a 422 when no key is stored", async () => {
const monitorsRepository = createMonitorsRepositoryMock();
(monitorsRepository.findById as jest.Mock).mockResolvedValue(makeMonitor({ type: "docker", dockerTlsKeySet: false }));
const { service } = createService({ monitorsRepository });
await expectAppError(
() => service.editMonitor({ teamId: TEAM_ID, monitorId: MONITOR_ID, body: { ...tlsBody, dockerTlsKey: "" } }),
422,
/required for a TLS Docker host/
);
expect(monitorsRepository.updateById).not.toHaveBeenCalled();
});
it("encrypts a replacement key without reading the stored monitor", async () => {
const monitorsRepository = createMonitorsRepositoryMock();
(monitorsRepository.updateById as jest.Mock).mockResolvedValue(makeMonitor({ type: "docker" }));
const encryptionService = createEncryptionServiceMock();
const { service } = createService({ monitorsRepository, encryptionService });
await service.editMonitor({ teamId: TEAM_ID, monitorId: MONITOR_ID, body: tlsBody });
expect(monitorsRepository.findById).not.toHaveBeenCalled();
expect(monitorsRepository.updateById).toHaveBeenCalledWith(
MONITOR_ID,
TEAM_ID,
expect.objectContaining({ dockerTlsKey: `enc:${KEY_PEM}`, dockerTlsKeySet: true }),
{ unsetProxyId: false }
);
});
it("encrypts a replacement key when the body omits the url", async () => {
const monitorsRepository = createMonitorsRepositoryMock();
(monitorsRepository.updateById as jest.Mock).mockResolvedValue(makeMonitor({ type: "docker" }));
const encryptionService = createEncryptionServiceMock();
const { service } = createService({ monitorsRepository, encryptionService });
await service.editMonitor({ teamId: TEAM_ID, monitorId: MONITOR_ID, body: { type: "docker", dockerTlsKey: KEY_PEM } });
expect(encryptionService.encrypt).toHaveBeenCalledWith(KEY_PEM);
expect(monitorsRepository.updateById).toHaveBeenCalledWith(
MONITOR_ID,
TEAM_ID,
expect.objectContaining({ dockerTlsKey: `enc:${KEY_PEM}`, dockerTlsKeySet: true }),
{ unsetProxyId: false }
);
});
it("clears dockerTlsKeySet when the url changes back to a socket", async () => {
const monitorsRepository = createMonitorsRepositoryMock();
(monitorsRepository.updateById as jest.Mock).mockResolvedValue(makeMonitor({ type: "docker" }));
const encryptionService = createEncryptionServiceMock();
const { service } = createService({ monitorsRepository, encryptionService });
await service.editMonitor({
teamId: TEAM_ID,
monitorId: MONITOR_ID,
body: { type: "docker", url: "unix:///var/run/docker.sock", dockerTlsKey: KEY_PEM },
});
expect(encryptionService.encrypt).not.toHaveBeenCalled();
expect(monitorsRepository.findById).not.toHaveBeenCalled();
const [, , patch] = (monitorsRepository.updateById as jest.Mock).mock.calls[0] as [string, string, Record<string, unknown>];
expect(patch.dockerTlsKeySet).toBe(false);
expect(patch.dockerTlsKey).toBeUndefined();
});
it("rejects with a 422 naming ENCRYPTION_KEY when encryption is not configured", async () => {
const monitorsRepository = createMonitorsRepositoryMock();
const encryptionService = createEncryptionServiceMock({ isConfigured: jest.fn(() => false) as any });
const { service } = createService({ monitorsRepository, encryptionService });
await expectAppError(() => service.editMonitor({ teamId: TEAM_ID, monitorId: MONITOR_ID, body: tlsBody }), 422, /ENCRYPTION_KEY/);
expect(monitorsRepository.updateById).not.toHaveBeenCalled();
});
});
});