Skip to content

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

26.5 KB
Raw Blame
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");
};