Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

feat(logger): add comprehensive tests for logger redaction and enhance error handling in Kubernetes authentication

Victor Hugo dos Santos0fcce3906a61
diff --git a/backend/src/lib/logger/logger.test.ts b/backend/src/lib/logger/logger.test.ts
new file mode 100644
index 0000000000..4e7cdf00a5
--- /dev/null
+++ b/backend/src/lib/logger/logger.test.ts
@@ -0,0 +1,128 @@
+import { createServer, Server } from "node:http";
+import { AddressInfo } from "node:net";
+
+import { AxiosError } from "axios";
+import pino from "pino";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+
+import { createRequestClient } from "../config/request";
+import { loggerRedactPaths } from "./logger";
+
+const BEARER_TOKEN = "eyJhbGciOiJSUzI1NiJ9.bearer-secret-payload.bearer-secret-signature";
+const SIGNED_QUERY = "AccessKeyId=ak-secret-value&Signature=signature-secret-value";
+const REDACTED = "[Redacted]";
+
+const valueAt = (obj: unknown, path: string) =>
+ path.split(".").reduce<unknown>((node, key) => (node as Record<string, unknown> | undefined)?.[key], obj);
+
+const createTestLogger = () => {
+ const lines: string[] = [];
+ const testLogger = pino({ redact: loggerRedactPaths }, { write: (line: string) => lines.push(line) });
+ return {
+ testLogger,
+ lastLine: () => ({ raw: lines[lines.length - 1], parsed: JSON.parse(lines[lines.length - 1]) as unknown })
+ };
+};
+
+describe("logger redaction of outgoing request internals", () => {
+ let server: Server;
+ let axiosError: AxiosError;
+
+ beforeAll(async () => {
+ server = createServer((_req, res) => {
+ res.writeHead(401, { "content-type": "application/json" });
+ res.end(JSON.stringify({ kind: "Status", reason: "Unauthorized" }));
+ });
+ await new Promise<void>((resolve) => {
+ server.listen(0, "127.0.0.1", resolve);
+ });
+ const { port } = server.address() as AddressInfo;
+
+ axiosError = await createRequestClient({}, { retries: 0 })
+ .get(`http://127.0.0.1:${port}/apis/review?${SIGNED_QUERY}`, {
+ headers: { Authorization: `Bearer ${BEARER_TOKEN}` }
+ })
+ .then(
+ () => {
+ throw new Error("expected the request to fail");
+ },
+ (err: AxiosError) => err
+ );
+ });
+
+ afterAll(async () => {
+ await new Promise<void>((resolve) => {
+ server.close(() => resolve());
+ });
+ });
+
+ it("gives the tests a real axios error that carries the raw header and signed path", () => {
+ expect(valueAt(axiosError, "request._header")).toContain(`Bearer ${BEARER_TOKEN}`);
+ expect(valueAt(axiosError, "request.path")).toContain(SIGNED_QUERY);
+ });
+
+ it("redacts the error logged directly (err.request and err.response.request)", () => {
+ const { testLogger, lastLine } = createTestLogger();
+ testLogger.error(axiosError, "request failed");
+ const { raw, parsed } = lastLine();
+
+ expect(raw).not.toContain(BEARER_TOKEN);
+ expect(raw).not.toContain("signature-secret-value");
+ expect(valueAt(parsed, "err.request._header")).toBe(REDACTED);
+ expect(valueAt(parsed, "err.request.path")).toBe(REDACTED);
+ expect(valueAt(parsed, "err.response.request._header")).toBe(REDACTED);
+ expect(valueAt(parsed, "err.response.request.path")).toBe(REDACTED);
+ expect(valueAt(parsed, "err.code")).toBe("ERR_BAD_REQUEST");
+ expect(valueAt(parsed, "err.response.status")).toBe(401);
+ expect(valueAt(parsed, "err.request.method")).toBe("GET");
+ expect(valueAt(parsed, "err.request.host")).toBe("127.0.0.1");
+ });
+
+ it("redacts the response nested under a key", () => {
+ const { testLogger, lastLine } = createTestLogger();
+ testLogger.error({ response: axiosError.response }, "request failed");
+ const { raw, parsed } = lastLine();
+
+ expect(raw).not.toContain(BEARER_TOKEN);
+ expect(raw).not.toContain("signature-secret-value");
+ expect(valueAt(parsed, "response.request._header")).toBe(REDACTED);
+ expect(valueAt(parsed, "response.request.path")).toBe(REDACTED);
+ expect(valueAt(parsed, "response.status")).toBe(401);
+ expect(valueAt(parsed, "response.data")).toEqual({ kind: "Status", reason: "Unauthorized" });
+ });
+
+ it("redacts the response logged as the root object", () => {
+ const { testLogger, lastLine } = createTestLogger();
+ testLogger.error(axiosError.response, "request failed");
+ const { raw, parsed } = lastLine();
+
+ expect(raw).not.toContain(BEARER_TOKEN);
+ expect(raw).not.toContain("signature-secret-value");
+ expect(valueAt(parsed, "request._header")).toBe(REDACTED);
+ expect(valueAt(parsed, "request.path")).toBe(REDACTED);
+ expect(valueAt(parsed, "status")).toBe(401);
+ });
+
+ it("redacts _header at the root", () => {
+ const { testLogger, lastLine } = createTestLogger();
+ testLogger.error({ _header: `Authorization: Bearer ${BEARER_TOKEN}`, method: "GET" }, "root");
+ expect(lastLine().parsed).toMatchObject({ _header: REDACTED, method: "GET" });
+ });
+
+ it("keeps the error under an error key free of request internals", () => {
+ const { testLogger, lastLine } = createTestLogger();
+ testLogger.error({ error: axiosError }, "request failed");
+ const { raw, parsed } = lastLine();
+
+ expect(raw).not.toContain(BEARER_TOKEN);
+ expect(raw).not.toContain("signature-secret-value");
+ expect(valueAt(parsed, "error.code")).toBe("ERR_BAD_REQUEST");
+ expect(valueAt(parsed, "error.status")).toBe(401);
+ });
+
+ it("leaves unrelated path fields alone", () => {
+ const { testLogger, lastLine } = createTestLogger();
+ testLogger.info({ path: "/api/v1/secrets", route: { path: "/api/v1/secrets" } }, "route hit");
+ expect(lastLine().parsed).toMatchObject({ path: "/api/v1/secrets", route: { path: "/api/v1/secrets" } });
+ });
+});
diff --git a/backend/src/lib/logger/logger.ts b/backend/src/lib/logger/logger.ts
index ed4da4d440..c306034406 100644
--- a/backend/src/lib/logger/logger.ts
+++ b/backend/src/lib/logger/logger.ts
@@ -96,6 +96,19 @@ const outgoingRequestRedactPaths = [
"*.*.request.path"
];
+// redact until depth of three
+// Keys with special characters (hyphens) need bracket notation for fast-redact
+export const loggerRedactPaths = [
+ ...redactedKeys.flatMap((key) => {
+ if (key.includes("-")) {
+ const k = `["${key}"]`;
+ return [k, `*${k}`, `*.*${k}`];
+ }
+ return [key, `*.${key}`, `*.*.${key}`];
+ }),
+ ...outgoingRequestRedactPaths
+];
+
const UNKNOWN_REQUEST_ID = "UNKNOWN_REQUEST_ID";
const extractReqId = () => {
@@ -171,18 +184,7 @@ export const initLogger = () => {
// node_version: process.version
})
},
- // redact until depth of three
- // Keys with special characters (hyphens) need bracket notation for fast-redact
- redact: [
- ...redactedKeys.flatMap((key) => {
- if (key.includes("-")) {
- const k = `["${key}"]`;
- return [k, `*${k}`, `*.*${k}`];
- }
- return [key, `*.${key}`, `*.*.${key}`];
- }),
- ...outgoingRequestRedactPaths
- ]
+ redact: loggerRedactPaths
},
// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
transport
diff --git a/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-error-handlers.test.ts b/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-error-handlers.test.ts
new file mode 100644
index 0000000000..19a40275bf
--- /dev/null
+++ b/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-error-handlers.test.ts
@@ -0,0 +1,41 @@
+import { AxiosError, AxiosHeaders } from "axios";
+import { describe, expect, it } from "vitest";
+
+import { handleAxiosError, KubernetesAuthErrorContext } from "./identity-kubernetes-auth-error-handlers";
+
+const JWT = "eyJhbGciOiJSUzI1NiJ9.eyJzdWIiOiJyZXZpZXdlciJ9.cmV2aWV3ZXItc2lnbmF0dXJl";
+
+const clusterError = (status: number, data: unknown) =>
+ new AxiosError("Request failed", "ERR_BAD_REQUEST", undefined, undefined, {
+ status,
+ statusText: "",
+ data,
+ headers: {},
+ config: { headers: new AxiosHeaders() }
+ });
+
+describe("handleAxiosError", () => {
+ it("keeps the cluster's message for the caller", () => {
+ const error = handleAxiosError(
+ clusterError(401, { kind: "Status", message: "Unauthorized" }),
+ { host: "https://k8s.example.com" },
+ KubernetesAuthErrorContext.KubernetesApiServer
+ );
+ expect(error.name).toBe("KubernetesTokenReviewerUnauthorized");
+ expect(error.message).toBe("Unauthorized");
+ });
+
+ it.each([
+ ["a 401 Status message", 401, { kind: "Status", message: `rejected credentials: Bearer ${JWT}` }],
+ ["a 400 Status message", 400, { kind: "Status", message: `token ${JWT} is malformed` }],
+ ["a plain-text body", 502, `proxy rejected Bearer ${JWT}`]
+ ])("removes a JWT echoed in %s", (_label, status, data) => {
+ const error = handleAxiosError(
+ clusterError(status, data),
+ { host: "https://k8s.example.com" },
+ KubernetesAuthErrorContext.KubernetesApiServer
+ );
+ expect(error.message).not.toContain(JWT);
+ expect(error.message).toContain("[REDACTED]");
+ });
+});
diff --git a/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-error-handlers.ts b/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-error-handlers.ts
index 76fe179b9f..0a8dfeff77 100644
--- a/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-error-handlers.ts
+++ b/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-error-handlers.ts
@@ -2,6 +2,8 @@ import { AxiosError } from "axios";
import { BadRequestError, NotFoundError, UnauthorizedError } from "@app/lib/errors";
+import { redactCredentialsFromText } from "./identity-kubernetes-auth-fns";
+
type ErrorContext = {
host?: string;
port?: number;
@@ -124,6 +126,10 @@ export const handleAxiosHttpError = (
message = err.response.data;
}
+ if (message) {
+ message = redactCredentialsFromText(message);
+ }
+
if (statusCode === 401) {
return new UnauthorizedError({
message: message || default401Message,
diff --git a/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-fns.test.ts b/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-fns.test.ts
index 7ca487273e..bf5ed7cbcf 100644
--- a/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-fns.test.ts
+++ b/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-fns.test.ts
@@ -39,6 +39,52 @@ describe("getKubernetesStatusForLog", () => {
expect(getKubernetesStatusForLog(undefined)).toEqual({});
expect(getKubernetesStatusForLog(401)).toEqual({});
});
+
+ describe("when the cluster echoes credentials back", () => {
+ const reviewerJwt = "eyJhbGciOiJSUzI1NiJ9.eyJzdWIiOiJyZXZpZXdlciJ9.cmV2aWV3ZXItc2lnbmF0dXJl";
+ const workloadJwt = "eyJhbGciOiJSUzI1NiJ9.eyJzdWIiOiJ3b3JrbG9hZCJ9.d29ya2xvYWQtc2lnbmF0dXJl";
+ const opaqueReviewerToken = "opaque-reviewer-token-0123456789abcdef";
+
+ it("removes both JWTs from message and reason", () => {
+ const result = getKubernetesStatusForLog(
+ { reason: `bad token ${workloadJwt}`, message: `Authorization: Bearer ${reviewerJwt} rejected` },
+ [reviewerJwt, workloadJwt]
+ );
+ expect(JSON.stringify(result)).not.toContain(reviewerJwt);
+ expect(JSON.stringify(result)).not.toContain(workloadJwt);
+ expect(result).toEqual({
+ reason: "bad token [REDACTED]",
+ message: "Authorization: Bearer [REDACTED] rejected"
+ });
+ });
+
+ it("removes an opaque reviewer token that does not look like a JWT", () => {
+ expect(
+ getKubernetesStatusForLog({ message: `token ${opaqueReviewerToken} is invalid` }, [opaqueReviewerToken])
+ ).toEqual({ message: "token [REDACTED] is invalid" });
+ });
+
+ it("removes partial or unknown JWTs from a plain-text body", () => {
+ const partial = reviewerJwt.slice(0, 30);
+ const result = getKubernetesStatusForLog(
+ `rejected ${partial} (cut) and eyJhbGciOiJIUzI1NiJ9.eyJmb28iOiJiYXIifQ.x`
+ );
+ expect(result.message).toBe("rejected [REDACTED] (cut) and [REDACTED]");
+ });
+
+ it("scrubs before truncating so a token cut at the limit cannot survive", () => {
+ const message = `${"m".repeat(1000)}${reviewerJwt}`;
+ const result = getKubernetesStatusForLog({ message }, [reviewerJwt]);
+ expect(result.message).toBe(`${"m".repeat(1000)}[REDACTED]`);
+ expect(result.message).not.toContain(reviewerJwt.slice(0, 24));
+ });
+
+ it("ignores missing secrets", () => {
+ expect(getKubernetesStatusForLog({ message: "plain failure" }, [undefined, ""])).toEqual({
+ message: "plain failure"
+ });
+ });
+ });
});
describe("withKubernetesHostScheme", () => {
diff --git a/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-fns.ts b/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-fns.ts
index 3d925676a1..f8974918ac 100644
--- a/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-fns.ts
+++ b/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-fns.ts
@@ -12,18 +12,29 @@ const JWT_FINGERPRINT_LENGTH = 12;
export const getJwtFingerprintForLog = (jwt?: string) =>
jwt ? crypto.nativeCrypto.createHash("sha256").update(jwt).digest("hex").slice(0, JWT_FINGERPRINT_LENGTH) : undefined;
-const truncateStatusField = (value: unknown) => {
+const JWT_LIKE_REGEX = new RE2("eyJ[A-Za-z0-9_-]{8,}(?:\\.[A-Za-z0-9_-]*){0,2}", "g");
+
+export const redactCredentialsFromText = (text: string, secrets: (string | undefined)[] = []) =>
+ secrets
+ .reduce<string>((acc, secret) => (secret ? acc.split(secret).join("[REDACTED]") : acc), text)
+ .replace(JWT_LIKE_REGEX, "[REDACTED]");
+
+const toStatusFieldForLog = (value: unknown, secrets: (string | undefined)[]) => {
if (typeof value !== "string") return undefined;
- return value.length > MAX_STATUS_FIELD_LOG_LENGTH
- ? `${value.slice(0, MAX_STATUS_FIELD_LOG_LENGTH)}...[truncated]`
- : value;
+ const scrubbed = redactCredentialsFromText(value, secrets);
+ return scrubbed.length > MAX_STATUS_FIELD_LOG_LENGTH
+ ? `${scrubbed.slice(0, MAX_STATUS_FIELD_LOG_LENGTH)}...[truncated]`
+ : scrubbed;
};
-export const getKubernetesStatusForLog = (data: unknown): { reason?: string; message?: string } => {
- if (typeof data === "string") return { message: truncateStatusField(data) };
+export const getKubernetesStatusForLog = (
+ data: unknown,
+ secrets: (string | undefined)[] = []
+): { reason?: string; message?: string } => {
+ if (typeof data === "string") return { message: toStatusFieldForLog(data, secrets) };
if (!data || typeof data !== "object") return {};
const { reason, message } = data as { reason?: unknown; message?: unknown };
- return { reason: truncateStatusField(reason), message: truncateStatusField(message) };
+ return { reason: toStatusFieldForLog(reason, secrets), message: toStatusFieldForLog(message, secrets) };
};
// The stored host may omit a scheme. URL parsing, SSRF validation and Axios all need one.
diff --git a/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-service.ts b/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-service.ts
index 55250a448f..1bd78d357d 100644
--- a/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-service.ts
+++ b/backend/src/services/identity-kubernetes-auth/identity-kubernetes-auth-service.ts
@@ -433,7 +433,7 @@ export const identityKubernetesAuthServiceFactory = ({
port,
status: err.response?.status,
code: err.code,
- ...getKubernetesStatusForLog(err.response?.data),
+ ...getKubernetesStatusForLog(err.response?.data, [tokenReviewerJwt, serviceAccountJwt]),
tokenReviewerJwtFingerprint,
serviceAccountJwtFingerprint
},