Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.
TypeScript acmeagentsai-agentscertificate-managementdevsecopsenvironment-variableskubernetesopen-sourcepampkipostgresprivate-caprivileged-access-managementsecret-managementsecret-managersecretssecrets-managementsecuritysecurity-toolsvault
import picomatch from "picomatch";
import { TWebhooks } from "@app/db/schemas";
import { EventType, TAuditLogServiceFactory, WebhookTriggeredEvent } from "@app/ee/services/audit-log/audit-log-types";
import { RequestState } from "@app/ee/services/secret-approval-request/secret-approval-request-types";
import { haveDisjointLiteralPrefixes } from "@app/lib/casl/glob-subset";
import { crypto } from "@app/lib/crypto/cryptography";
import { NotFoundError } from "@app/lib/errors";
import { logger } from "@app/lib/logger";
import { requestMemoKeys } from "@app/lib/request-context/memo-keys";
import { requestMemoize } from "@app/lib/request-context/request-memoizer";
import { safeRequest } from "@app/lib/validator";
import { ActorType } from "@app/services/auth/auth-type";
import { TProjectEnvDALFactory } from "../project-env/project-env-dal";
import { TProjectDALFactory } from "../project/project-dal";
import { TWebhookDALFactory } from "./webhook-dal";
import { TWebhookPayloads, WebhookEvents, WebhookType } from "./webhook-types";
const WEBHOOK_TRIGGER_TIMEOUT = 30 * 1000;
const CHANGE_REQUEST_STATUS_LABEL: Record<string, string> = {
[RequestState.Open]: "Open",
[RequestState.Closed]: "Closed"
};
// The stored status is a database enum, not copy. Slack and Teams render it into a channel a
// whole team reads, so it is mapped here; the general payload keeps the raw column value.
const formatChangeRequestStatus = (request: { hasMerged: boolean; status: string }) =>
request.hasMerged ? "Merged" : (CHANGE_REQUEST_STATUS_LABEL[request.status] ?? request.status);
export const decryptWebhookDetails = (webhook: TWebhooks, decryptor: (value: Buffer) => string) => {
const { encryptedPassKey, encryptedUrl } = webhook;
const decryptedUrl = decryptor(encryptedUrl);
let decryptedSecretKey = "";
if (encryptedPassKey) {
decryptedSecretKey = decryptor(encryptedPassKey);
}
return {
secretKey: decryptedSecretKey,
url: decryptedUrl
};
};
export const triggerWebhookRequest = async (
webhook: TWebhooks,
decryptor: (value: Buffer) => string,
data: Record<string, unknown>
) => {
const headers: Record<string, string> = {};
const payload = { ...data, timestamp: Date.now() };
const { secretKey, url } = decryptWebhookDetails(webhook, decryptor);
if (secretKey) {
const webhookSign = crypto.nativeCrypto
.createHmac("sha256", secretKey)
.update(JSON.stringify(payload))
.digest("hex");
headers["x-infisical-signature"] = `t=${payload.timestamp};${webhookSign}`;
}
const req = await safeRequest.post(url, payload, {
headers,
timeout: WEBHOOK_TRIGGER_TIMEOUT,
signal: AbortSignal.timeout(WEBHOOK_TRIGGER_TIMEOUT)
});
return req;
};
type TTestEventFields = {
projectId: string;
projectName?: string;
environment: string;
environmentName: string;
secretPath?: string;
};
const TEST_EVENT_MESSAGE = "This is a test message from Infisical webhooks.";
// Keyed by webhook type rather than switched on, so a new WebhookType fails the type check here
// until it has a body its provider accepts. Slack rejects a body without `text` with 400 no_text.
export const TEST_EVENT_PAYLOAD_BUILDERS: Record<WebhookType, (fields: TTestEventFields) => Record<string, unknown>> = {
[WebhookType.SLACK]: ({ projectName, environment, environmentName, secretPath }) => ({
text: TEST_EVENT_MESSAGE,
attachments: [
{
color: "#E7F256",
fields: [
{
title: "Project",
value: projectName,
short: false
},
{
title: "Environment",
value: environment,
short: false
},
{
title: "Environment Name",
value: environmentName,
short: false
},
{
title: "Secret Path",
value: secretPath,
short: false
}
]
}
]
}),
[WebhookType.MICROSOFT_TEAMS]: ({ projectName, environment, environmentName, secretPath }) => ({
type: "message",
attachments: [
{
contentType: "application/vnd.microsoft.card.adaptive",
content: {
type: "AdaptiveCard",
version: "1.2",
body: [
{
type: "TextBlock",
size: "Medium",
weight: "Bolder",
text: TEST_EVENT_MESSAGE
},
{
type: "FactSet",
facts: [
{ title: "Project", value: projectName || "" },
{ title: "Environment", value: environment },
{ title: "Environment Name", value: environmentName || "" },
{ title: "Secret Path", value: secretPath || "" }
]
}
]
}
}
]
}),
[WebhookType.GENERAL]: ({ projectName, projectId, environment, environmentName, secretPath }) => ({
event: WebhookEvents.TestEvent,
project: {
workspaceId: projectId,
projectId,
projectName,
environment,
environmentName,
secretPath
}
})
};
export const getWebhookPayload = (event: TWebhookPayloads) => {
if (event.type === WebhookEvents.SecretModified) {
const { projectName, projectId, environment, environmentName, secretPath, type, changedBy, changedByActorType } =
event.payload;
switch (type) {
case WebhookType.SLACK:
return {
text: "A secret value has been added or modified.",
attachments: [
{
color: "#E7F256",
fields: [
{
title: "Project",
value: projectName,
short: false
},
{
title: "Environment",
value: environment,
short: false
},
{
title: "Environment Name",
value: environmentName,
short: false
},
{
title: "Secret Path",
value: secretPath,
short: false
},
{
title: "Modified By",
value: changedBy,
short: false
},
{
title: "Modified By Actor Type",
value: changedByActorType?.toString() || "Unknown Actor Type",
short: false
}
]
}
]
};
case WebhookType.MICROSOFT_TEAMS:
return {
type: "message",
attachments: [
{
contentType: "application/vnd.microsoft.card.adaptive",
content: {
type: "AdaptiveCard",
version: "1.2",
body: [
{
type: "TextBlock",
size: "Medium",
weight: "Bolder",
text: "A secret value has been added or modified."
},
{
type: "FactSet",
facts: [
{ title: "Project", value: projectName || "" },
{ title: "Environment", value: environment },
{ title: "Environment Name", value: environmentName || "" },
{ title: "Secret Path", value: secretPath || "" },
{ title: "Modified By", value: changedBy || "" },
{
title: "Actor Type",
value: changedByActorType?.toString() || "Unknown Actor Type"
}
]
}
]
}
}
]
};
case WebhookType.GENERAL:
default:
return {
event: event.type,
project: {
workspaceId: projectId,
projectId,
projectName,
environment,
environmentName,
secretPath,
changedBy,
changedByActorType
}
};
}
}
if (event.type === WebhookEvents.SecretRotationFailed) {
const {
projectName,
projectId,
environment,
environmentName,
secretPath,
type,
rotationName,
errorMessage,
triggeredManually
} = event.payload;
switch (type) {
case WebhookType.SLACK:
return {
text: "A secret rotation has failed.",
attachments: [
{
color: "#E7F256",
fields: [
{
title: "Rotation Name",
value: rotationName,
short: false
},
{
title: "Project",
value: projectName,
short: false
},
{
title: "Environment",
value: environment,
short: false
},
{
title: "Environment Name",
value: environmentName,
short: false
},
{
title: "Secret Path",
value: secretPath,
short: false
},
{
title: "Error Message",
value: errorMessage,
short: false
},
{
title: "Triggered Manually",
value: triggeredManually ? "Yes" : "No",
short: false
}
]
}
]
};
case WebhookType.MICROSOFT_TEAMS:
return {
type: "message",
attachments: [
{
contentType: "application/vnd.microsoft.card.adaptive",
contentUrl: null,
content: {
type: "AdaptiveCard",
version: "1.2",
body: [
{
type: "TextBlock",
size: "Medium",
weight: "Bolder",
text: "A secret rotation has failed."
},
{
type: "FactSet",
facts: [
{ title: "Rotation Name", value: rotationName || "" },
{ title: "Project", value: projectName || "" },
{ title: "Environment", value: environment },
{ title: "Environment Name", value: environmentName || "" },
{ title: "Secret Path", value: secretPath || "" },
{ title: "Error Message", value: errorMessage || "" },
{ title: "Triggered Manually", value: triggeredManually ? "Yes" : "No" }
]
}
]
}
}
]
};
case WebhookType.GENERAL:
default:
return {
event: event.type,
project: {
projectId,
projectName,
environment,
environmentName,
secretPath,
rotationName,
errorMessage,
triggeredManually
}
};
}
}
if (event.type === WebhookEvents.HoneyTokenTriggered) {
const {
honeyTokenName,
projectName,
projectId,
environment,
environmentName,
secretPath,
type,
eventName,
sourceIp,
awsRegion
} = event.payload;
switch (type) {
case WebhookType.SLACK:
return {
text: "A honey token has been triggered!",
attachments: [
{
color: "#FF0000",
fields: [
{
title: "Honey Token",
value: honeyTokenName,
short: false
},
{
title: "Project",
value: projectName,
short: false
},
{
title: "Environment",
value: environment,
short: false
},
{
title: "Environment Name",
value: environmentName,
short: false
},
{
title: "Secret Path",
value: secretPath,
short: false
},
{
title: "AWS Event",
value: eventName,
short: false
},
{
title: "Source IP",
value: sourceIp || "Unknown",
short: false
},
{
title: "AWS Region",
value: awsRegion,
short: false
}
]
}
]
};
case WebhookType.MICROSOFT_TEAMS:
return {
type: "message",
attachments: [
{
contentType: "application/vnd.microsoft.card.adaptive",
content: {
type: "AdaptiveCard",
version: "1.2",
body: [
{
type: "TextBlock",
size: "Medium",
weight: "Bolder",
text: "A honey token has been triggered!"
},
{
type: "FactSet",
facts: [
{ title: "Honey Token", value: honeyTokenName || "" },
{ title: "Project", value: projectName || "" },
{ title: "Environment", value: environment },
{ title: "Environment Name", value: environmentName || "" },
{ title: "Secret Path", value: secretPath || "" },
{ title: "AWS Event", value: eventName || "" },
{ title: "Source IP", value: sourceIp || "Unknown" },
{ title: "AWS Region", value: awsRegion || "" }
]
}
]
}
}
]
};
case WebhookType.GENERAL:
default:
return {
event: event.type,
project: {
projectId,
projectName,
environment,
environmentName,
secretPath
},
honeyToken: {
name: honeyTokenName,
eventName,
sourceIp: sourceIp || "Unknown",
awsRegion
}
};
}
}
if (event.type === WebhookEvents.ChangeRequestModified) {
const { projectId, projectName, environment, environmentName, secretPath, type, action, request } = event.payload;
switch (type) {
case WebhookType.SLACK:
return {
text: `A secret change request was ${action}.`,
attachments: [
{
color: "#E7F256",
fields: [
{ title: "Project", value: projectName, short: false },
{ title: "Environment", value: environmentName || environment, short: false },
{ title: "Secret Path", value: secretPath, short: false },
{ title: "Policy", value: request.policy.name, short: false },
{ title: "Status", value: formatChangeRequestStatus(request), short: false },
{ title: "Requested By", value: request.requestedBy?.name || "Unknown", short: false },
{ title: "Bypassed", value: request.isBypassed ? "Yes" : "No", short: false }
]
}
]
};
case WebhookType.MICROSOFT_TEAMS:
return {
type: "message",
attachments: [
{
contentType: "application/vnd.microsoft.card.adaptive",
content: {
type: "AdaptiveCard",
version: "1.2",
body: [
{
type: "TextBlock",
size: "Medium",
weight: "Bolder",
text: `A secret change request was ${action}.`
},
{
type: "FactSet",
facts: [
{ title: "Project", value: projectName || "" },
{ title: "Environment", value: environmentName || environment },
{ title: "Secret Path", value: secretPath || "" },
{ title: "Policy", value: request.policy.name },
{ title: "Status", value: formatChangeRequestStatus(request) },
{ title: "Requested By", value: request.requestedBy?.name || "Unknown" },
{ title: "Bypassed", value: request.isBypassed ? "Yes" : "No" }
]
}
]
}
}
]
};
case WebhookType.GENERAL:
default:
return {
event: event.type,
action,
project: { id: projectId, name: projectName },
request: {
id: request.id,
slug: request.slug,
url: request.url,
target: {
environment: { name: environmentName, slug: environment },
secretPath
},
status: request.status,
hasMerged: request.hasMerged,
isBypassed: request.isBypassed,
policy: request.policy,
requestedBy: request.requestedBy,
createdAt: request.createdAt,
updatedAt: request.updatedAt
}
};
}
}
if (event.type === WebhookEvents.AccessRequestModified) {
const { projectId, projectName, environment, environmentName, secretPath, type, action, request } = event.payload;
const formattedPermissions = request.requestedAccess.permissions
.map(({ subject, actions }) => `${subject} (${actions.join(", ")})`)
.join(", ");
switch (type) {
case WebhookType.SLACK:
return {
text: `An access request was ${action}.`,
attachments: [
{
color: "#E7F256",
fields: [
{ title: "Project", value: projectName, short: false },
{ title: "Environment", value: environmentName || environment, short: false },
{ title: "Secret Path", value: secretPath, short: false },
{ title: "Policy", value: request.policy.name, short: false },
{ title: "Status", value: request.status, short: false },
{ title: "Requested By", value: request.requestedBy?.name || "Unknown", short: false },
{ title: "Requested Access", value: formattedPermissions, short: false },
{ title: "Bypassed", value: request.isBypassed ? "Yes" : "No", short: false }
]
}
]
};
case WebhookType.MICROSOFT_TEAMS:
return {
type: "message",
attachments: [
{
contentType: "application/vnd.microsoft.card.adaptive",
content: {
type: "AdaptiveCard",
version: "1.2",
body: [
{
type: "TextBlock",
size: "Medium",
weight: "Bolder",
text: `An access request was ${action}.`
},
{
type: "FactSet",
facts: [
{ title: "Project", value: projectName || "" },
{ title: "Environment", value: environmentName || environment },
{ title: "Secret Path", value: secretPath || "" },
{ title: "Policy", value: request.policy.name },
{ title: "Status", value: request.status },
{ title: "Requested By", value: request.requestedBy?.name || "Unknown" },
{ title: "Requested Access", value: formattedPermissions },
{ title: "Bypassed", value: request.isBypassed ? "Yes" : "No" }
]
}
]
}
}
]
};
case WebhookType.GENERAL:
default:
return {
event: event.type,
action,
project: { id: projectId, name: projectName },
request: {
id: request.id,
url: request.url,
status: request.status,
isBypassed: request.isBypassed,
policy: request.policy,
requestedAccess: {
target: {
environment: { name: environmentName, slug: environment },
secretPath
},
isTemporary: request.requestedAccess.isTemporary,
temporaryRange: request.requestedAccess.temporaryRange,
permissions: request.requestedAccess.permissions
},
requestedBy: request.requestedBy,
expiresAt: request.expiresAt,
approvedAt: request.approvedAt,
revokedAt: request.revokedAt,
createdAt: request.createdAt,
updatedAt: request.updatedAt
}
};
}
}
if (event.type === WebhookEvents.TestEvent) {
const { type, ...fields } = event.payload;
const buildPayload =
TEST_EVENT_PAYLOAD_BUILDERS[type as WebhookType] ?? TEST_EVENT_PAYLOAD_BUILDERS[WebhookType.GENERAL];
return buildPayload(fields);
}
logger.warn({ event }, "Unhandled webhook event");
return null;
};
export type TFnTriggerWebhookDTO = {
projectId: string;
secretPath: string;
environment: string;
event: TWebhookPayloads;
webhookDAL: Pick<TWebhookDALFactory, "findAllWebhooks" | "transaction" | "update" | "bulkUpdate">;
projectEnvDAL: Pick<TProjectEnvDALFactory, "findOne">;
projectDAL: Pick<TProjectDALFactory, "findById">;
secretManagerDecryptor: (value: Buffer) => string;
auditLogService: Pick<TAuditLogServiceFactory, "createAuditLog">;
};
// An access request's path is a glob, not a folder, so hook and event are both patterns.
// haveDisjointLiteralPrefixes only proves disjointness when it is certain, so negating it
// delivers whenever overlap is possible rather than dropping the event silently.
export const isWebhookPathSubscribed = (eventType: WebhookEvents, eventPath: string, hookPath: string) =>
eventType === WebhookEvents.AccessRequestModified
? !haveDisjointLiteralPrefixes(eventPath, hookPath)
: picomatch.isMatch(eventPath, hookPath, { strictSlashes: false });
// this is reusable function
// used in secret queue to trigger webhook and update status when secrets changes
export const fnTriggerWebhook = async ({
environment,
secretPath,
projectId,
webhookDAL,
projectEnvDAL,
event,
secretManagerDecryptor,
projectDAL,
auditLogService
}: TFnTriggerWebhookDTO) => {
const webhooks = await webhookDAL.findAllWebhooks(projectId, environment);
const toBeTriggeredHooks = webhooks.filter(({ secretPath: hookSecretPath, isDisabled, filteredEvents }) => {
const isEventSubscribed = !filteredEvents || filteredEvents.length === 0 || filteredEvents.includes(event.type);
return !isDisabled && isWebhookPathSubscribed(event.type, secretPath, hookSecretPath) && isEventSubscribed;
});
if (!toBeTriggeredHooks.length) return;
logger.info({ environment, secretPath, projectId }, "Secret webhook job started");
let { projectName } = event.payload;
if (!projectName) {
const project = await requestMemoize(requestMemoKeys.projectFindById(event.payload.projectId), () =>
projectDAL.findById(event.payload.projectId)
);
projectName = project.name;
}
const { environmentName } = event.payload;
const webhooksTriggered = await Promise.allSettled(
toBeTriggeredHooks.map((hook) => {
const formattedEvent = {
type: event.type,
payload: { ...event.payload, type: hook.type, projectName, environmentName }
} as TWebhookPayloads;
const payload = getWebhookPayload(formattedEvent);
if (!payload) return;
return triggerWebhookRequest(hook, secretManagerDecryptor, payload);
})
);
const eventPayloads: WebhookTriggeredEvent["metadata"][] = [];
const successWebhooks: string[] = [];
const failedWebhooks: { id: string; error: string }[] = [];
webhooksTriggered.forEach((result, i) => {
const hook = toBeTriggeredHooks[i];
const eventMetadata = {
webhookId: hook.id,
type: event.type,
payload: {
type: hook.type!,
...event.payload,
projectName
}
};
if (result.status === "rejected") {
const reason = result.reason as unknown;
const error = reason instanceof Error ? reason.message : String(reason ?? "Unknown webhook error");
logger.warn(
{ webhookId: hook.id, projectId, environment, secretPath, err: reason },
`Webhook delivery failed [webhookId=${hook.id}] [projectId=${projectId}] [environment=${environment}] [secretPath=${secretPath}] [error=${error}]`
);
failedWebhooks.push({ id: hook.id, error });
eventPayloads.push({ ...eventMetadata, status: "failed" } as WebhookTriggeredEvent["metadata"]);
return;
}
successWebhooks.push(hook.id);
eventPayloads.push({ ...eventMetadata, status: "success" } as WebhookTriggeredEvent["metadata"]);
});
await webhookDAL.transaction(async (tx) => {
const env = await projectEnvDAL.findOne({ projectId, slug: environment }, tx);
if (!env) {
throw new NotFoundError({
message: `Environment with slug '${environment}' in project with ID '${projectId}' not found`
});
}
if (successWebhooks.length) {
await webhookDAL.update(
{ envId: env.id, $in: { id: successWebhooks } },
{ lastStatus: "success", lastRunErrorMessage: null },
tx
);
}
if (failedWebhooks.length) {
await webhookDAL.bulkUpdate(
failedWebhooks.map(({ id, error }) => ({
id,
lastRunErrorMessage: error,
lastStatus: "failed"
})),
tx
);
}
});
for (const eventPayload of eventPayloads) {
// eslint-disable-next-line no-await-in-loop
await auditLogService.createAuditLog({
actor: {
type: ActorType.PLATFORM,
metadata: {}
},
projectId,
event: {
type: EventType.WEBHOOK_TRIGGERED,
metadata: eventPayload
}
});
}
logger.info({ environment, secretPath, projectId }, "Secret webhook job ended");
};