收集 Slack 审核日志

支持的平台：

本文档介绍了如何使用 Google Cloud Run Functions 或 Amazon S3 与 AWS Lambda 将 Slack 审核日志注入到 Google Security Operations。

Slack 审核日志会详细记录 Slack 企业网格组织中的安全相关事件。借助审核日志 API，您可以监控用户操作（例如登录、文件下载、应用安装和管理变更），以实现合规性和安全性监控。

准备工作

确保您满足以下前提条件：

  • Google SecOps 实例
  • 具有组织所有者或管理员访问权限的 Slack Enterprise Grid 方案

  • 对以下任一内容的特权访问权限：

    • Google Cloud（对于选项 1：Cloud Run Functions 和 Cloud Scheduler），或
    • AWS（对于选项 2：S3、IAM、Lambda、EventBridge）

收集 Slack 凭据

创建 Slack 应用

Slack 审核日志 API 需要具有 auditlogs:read 范围的用户 OAuth 令牌。此令牌必须通过在 Enterprise Grid 组织级层（而非工作区级层）安装应用来获取。

  1. 使用 Enterprise Grid 组织的所有者或管理员账号登录 Slack 管理控制台。
  2. 前往 Slack API 应用页面。
  3. 点击创建新应用。
  4. 选择从头开始。
  5. 提供以下配置详细信息：
    • 应用名称：输入一个描述性名称（例如 Google SecOps Audit Integration）。
    • 选择要在哪个工作区中开发应用：选择您的开发 Slack 工作区（组织中的任何工作区）。
  6. 点击创建应用。

配置 OAuth 范围

  1. 在应用的设置页面中，从左侧导航栏中选择 OAuth 和权限。
  2. 向下滚动到范围部分。
  3. 在用户令牌范围（而非聊天机器人令牌范围）下，点击添加 OAuth 范围。
  4. 添加以下范围：
    • auditlogs:read - 此范围可让您访问 Enterprise Grid 组织的 Audit Logs API。
  5. 在聊天机器人令牌范围下，点击添加 OAuth 范围。

  6. 添加以下范围：

    • users:read - 需要此范围才能启用组织级应用安装。

配置重定向网址

  1. 在应用的设置页面中，从左侧导航栏中选择 OAuth 和权限。
  2. 前往重定向网址部分。
  3. 点击添加新的重定向网址。

  4. 输入以下网址：

    https://slack.com/oauth/v2/authorize

  5. 点击 Add（添加）。

  6. 点击 Save 网址s。

启用公开分发

如需在企业组织级（而非仅在工作区级）安装应用，您必须启用公开分发。

为什么需要公开分发？

  • Slack 要求具有组织级权限的应用启用公开分发。
  • 这样一来，您就可以在组织级层安装应用，而不是在单个工作区中安装。
  • 如果没有此权限，您只能将应用安装到 Enterprise Grid 中的单个工作区。
  • 启用公开分发只会移除安装范围的内部限制。

如需启用公开分发，请按以下步骤操作：

  1. 在应用的设置页面中，从左侧导航栏中选择管理分发。
  2. 在与其他工作区分享应用下，验证所有四个部分是否都带有绿色对勾标记：
    • 移除硬编码信息
    • 启用公开分发
    • 设置重定向网址
    • 添加 OAuth 范围
  3. 如果任何部分显示红色 X，请展开该部分并完成所需操作。
  4. 勾选我已检查并移除了所有硬编码信息旁边的复选框。
  5. 点击启用公开分发。

将应用安装到企业组织

  1. 在应用的设置页面中，从左侧导航栏中选择 OAuth 和权限。
  2. 在 Share Your App with Your Workspace 下，复制可分享的网址。
  3. 在浏览器中输入该网址。
  4. 严重：在安装界面中，检查右上角的下拉菜单。
  5. 确保您安装到企业组织，而不是单个工作区。
  6. 如果您在下拉菜单中看到工作区名称，请点击该名称，然后选择您的企业组织名称。
  7. 查看所请求的权限，然后点击允许。

检索凭据

授权完成后，系统会将您重定向到 OAuth 和权限页面。

  1. 在 Workspace 的 OAuth 令牌下，找到用户 OAuth 令牌。
  2. 令牌以 xoxp- 开头。

  3. 点击复制并妥善保存此令牌。

  4. 记下您的组织 ID：

    1. 前往 Slack 管理控制台。
    2. 依次前往设置和权限 > 组织设置。
    3. 复制组织 ID。

验证权限

如需验证您的应用是否拥有所需的权限，请执行以下操作：

  1. 前往 Slack API 应用页面。
  2. 选择您的应用。
  3. 从左侧导航栏中选择 OAuth 和权限。
  4. 在 Workspace 的 OAuth 令牌下，验证是否显示了用户 OAuth 令牌（以 xoxp- 开头）。
  5. 在范围下，验证 User Token Scopes 下是否显示 auditlogs:read。

测试 API 访问权限

  • 在继续进行集成之前，请先测试您的令牌：

    SLACK_TOKEN="xoxp-your-token-here"

curl -H "Authorization: Bearer $SLACK_TOKEN" \
  "https://api.slack.com/audit/v1/logs?limit=1"

    成功的响应包含一个包含审核日志事件的 entries 数组。如果您收到 invalid_auth 或 missing_scope 错误，请验证您的令牌和范围。

方案 1：使用 Google Cloud Run Functions 配置 Slack 审核日志导出

此选项使用 Google Cloud Run Functions 和 Cloud Scheduler 收集 Slack 审核日志，并使用 Chronicle 注入脚本直接将这些日志注入到 Google SecOps 中。

准备工作（选项 1）

确保您满足以下额外的前提条件：

  • 已启用以下 API 的 GCP 项目：
    • Cloud Functions API
    • Cloud Scheduler API
    • Secret Manager API
  • 在 Secret Manager 中创建 Cloud Functions 函数、Cloud Scheduler 作业和 Secret 的权限
  • Google SecOps 服务账号 JSON 文件

获取 Google SecOps 服务账号

  1. 登录 Google SecOps 控制台。
  2. 依次前往 SIEM 设置 > 收集代理。
  3. 下载数据注入身份验证文件。

  4. 妥善保存 JSON 文件。您将此文件作为 Secret 上传到 Google Secret Manager。

准备函数代码

从 Chronicle ingestion-scripts GitHub 代码库下载部署文件：

  1. 从 slack 文件夹中下载：
    • .env.yml
    • main.py
    • requirements.txt

  2. 从代码库的根目录中，下载整个 common 目录及其所有文件。

    您的部署目录应具有以下结构：

    deployment_directory/
├── common/
│   ├── __init__.py
│   ├── auth.py
│   ├── env_constants.py
│   ├── ingest.py
│   ├── status.py
│   └── utils.py
├── .env.yml
├── main.py
└── requirements.txt

在 Google Secret Manager 中配置密文

将敏感凭据存储在 Secret Manager 中，以便 Cloud Run function 安全访问。

为 Google SecOps 服务账号创建 Secret

  1. 在 GCP 控制台中，依次前往安全性 > Secret Manager。
  2. 点击创建密钥。
  3. 提供以下配置详细信息：
    • 名称：输入 chronicle-service-account。
    • Secret 值：输入 Google SecOps 服务账号 JSON 文件的全部内容。
  4. 点击创建密钥。

  5. 复制 Secret 的资源名称。格式为：

    projects/PROJECT_ID/secrets/chronicle-service-account/versions/latest

为 Slack 令牌创建 Secret

  1. 在 Secret Manager 页面上，点击创建密钥。
  2. 提供以下配置详细信息：
    • 名称：输入 slack-admin-token。
    • 密钥值：输入 Slack 用户 OAuth 令牌（以 xoxp- 开头）。
  3. 点击创建密钥。

  4. 复制 Secret 的资源名称。格式为：

    projects/PROJECT_ID/secrets/slack-admin-token/versions/latest

配置环境变量

  1. 在部署目录中打开 .env.yml 文件，然后配置环境变量：

    CHRONICLE_CUSTOMER_ID: "<your-chronicle-customer-id>"
CHRONICLE_REGION: "us"
CHRONICLE_SERVICE_ACCOUNT: "projects/<PROJECT_ID>/secrets/chronicle-service-account/versions/latest"
CHRONICLE_NAMESPACE: ""
POLL_INTERVAL: "5"
SLACK_ADMIN_TOKEN: "projects/<PROJECT_ID>/secrets/slack-admin-token/versions/latest"

    替换以下内容：

    • <your-chronicle-customer-id>：您的 Google SecOps 客户 ID。
    • <PROJECT_ID>：您的 Google Cloud 项目 ID。
    • CHRONICLE_REGION：设置为您的 Google SecOps 区域。有效值：us、asia-northeast1、asia-south1、asia-southeast1、australia-southeast1、europe、europe-west2、europe-west3、europe-west6、europe-west9、europe-west12、me-central1、me-central2、me-west1、northamerica-northeast2、southamerica-east1。
    • POLL_INTERVAL：函数执行的频次间隔（以分钟为单位）。此时长必须与 Cloud Scheduler 作业间隔相同。

  2. 保存 .env.yml 文件。

部署 Cloud Run 函数

  1. 在 Google Cloud 控制台中打开终端或 Cloud Shell。前往部署目录，然后执行以下命令：

    gcloud functions deploy slack-audit-to-chronicle \
  --entry-point main \
  --trigger-http \
  --runtime python312 \
  --env-vars-file .env.yml \
  --timeout 540s \
  --memory 512MB \
  --service-account <SERVICE_ACCOUNT_EMAIL>

    将 <SERVICE_ACCOUNT_EMAIL> 替换为您希望 Cloud Run 函数使用的服务账号的电子邮件地址。

  2. 等待部署完成。部署完成后，记下输出中的函数网址。

设置 Cloud Scheduler

  1. 在 GCP Console 中，依次前往 Cloud Scheduler > 创建作业。

  2. 提供以下配置详细信息：

    设置 值
    名称 slack-audit-scheduler
    区域 选择部署 Cloud Run 函数的同一区域
    频率 */5 * * * *（每 5 分钟，与 POLL_INTERVAL 值匹配）
    时区 选择时区（建议选择世界协调时间 [UTC]）

  3. 点击继续。

  4. 在配置执行部分中：

    • 目标类型：选择 HTTP。
    • 网址：输入部署输出中的 Cloud Run 函数网址。
    • HTTP 方法：选择 POST。

  5. 在 Auth header 部分中：

    • 选择添加 OIDC 令牌。
    • 服务账号：选择用于 Cloud Run 函数的同一服务账号。

  6. 点击创建。

时间表频率选项

根据日志量和延迟时间要求选择频次：

频率 Cron 表达式 使用场景
每隔 5 分钟 */5 * * * * 标准（推荐）
每隔 15 分钟 */15 * * * * 搜索量中等
每小时 0 * * * * 音量低

测试集成（方法 1）

  1. 在 Cloud Scheduler 控制台中，找到您的作业 (slack-audit-scheduler)。
  2. 点击强制运行以手动触发作业。
  3. 等待几秒钟。
  4. 前往 Cloud Functions。
  5. 点击函数名称 (slack-audit-to-chronicle)。
  6. 点击日志标签页。

  7. 验证函数是否已成功执行。查找：

    Retrieving the Slack Audit logs since: YYYY-MM-DDTHH:MM:SSZ
Processing logs...
Retrieved X audit logs from the API call
Logs processed successfully.

选项 2：使用 AWS S3 配置 Slack 审核日志导出

此选项使用 AWS Lambda 收集 Slack 审核日志并将其存储在 Amazon S3 中，然后配置 Google SecOps Feed 以注入日志。

准备工作（选项 2）

确保您满足以下额外前提条件：

  • 一个有权创建 S3 存储分区、IAM 用户/角色/政策、Lambda 函数和 EventBridge 规则的 AWS 账号。

创建 Amazon S3 存储桶

  1. 按照创建存储桶用户指南创建 Amazon S3 存储桶。
  2. 保存存储桶名称和区域以供日后参考（例如 slack-audit-logs）。

为 S3 上传配置 IAM 政策和角色

  1. 在 AWS 控制台中，依次前往 IAM > 政策 > 创建政策 > JSON 标签页。

  2. 输入以下政策。如果您使用了其他存储桶名称，请替换 slack-audit-logs：

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowPutObjects",
      "Effect": "Allow",
      "Action": "s3:PutObject",
      "Resource": "arn:aws:s3:::slack-audit-logs/*"
    },
    {
      "Sid": "AllowGetStateObject",
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::slack-audit-logs/slack/audit/state.json"
    }
  ]
}

  3. 点击下一步。

  4. 输入政策名称 SlackAuditS3Policy。

  5. 点击创建政策。

  6. 依次前往 IAM > 角色 > 创建角色 > AWS 服务 > Lambda。

  7. 附加新创建的政策 SlackAuditS3Policy。

  8. 将角色命名为 SlackAuditToS3Role，然后点击创建角色。

创建 Lambda 函数

  1. 在 AWS 控制台中，依次前往 Lambda > 函数 > 创建函数。
  2. 点击从头开始创作。

  3. 提供以下配置详细信息：

    设置 值
    名称 slack_audit_to_s3
    运行时 Python 3.13
    架构 x86_64
    执行角色 SlackAuditToS3Role

  4. 点击创建函数。

  5. 创建函数后，打开 Code 标签页，删除桩代码并输入以下代码 (slack_audit_to_s3.py)：

    #!/usr/bin/env python3
# Lambda: Pull Slack Audit Logs (Enterprise Grid) to S3 (JSONL format)
import os, json, time, urllib.parse
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError
import boto3

BASE_URL = "https://api.slack.com/audit/v1/logs"
TOKEN = os.environ["SLACK_AUDIT_TOKEN"]
BUCKET = os.environ["S3_BUCKET"]
PREFIX = os.environ.get("S3_PREFIX", "slack/audit/")
STATE_KEY = os.environ.get("STATE_KEY", "slack/audit/state.json")
LIMIT = int(os.environ.get("LIMIT", "200"))
MAX_PAGES = int(os.environ.get("MAX_PAGES", "20"))
LOOKBACK_SEC = int(os.environ.get("LOOKBACK_SECONDS", "3600"))
HTTP_TIMEOUT = int(os.environ.get("HTTP_TIMEOUT", "60"))
HTTP_RETRIES = int(os.environ.get("HTTP_RETRIES", "3"))
RETRY_AFTER_DEFAULT = int(os.environ.get("RETRY_AFTER_DEFAULT", "2"))
# Optional server-side filters (comma-separated 'action' values)
ACTIONS = os.environ.get("ACTIONS", "").strip()

s3 = boto3.client("s3")

def _get_state() -> dict:
    try:
        obj = s3.get_object(Bucket=BUCKET, Key=STATE_KEY)
        st = json.loads(obj["Body"].read() or b"{}")
        return {"cursor": st.get("cursor")}
    except Exception:
        return {"cursor": None}

def _put_state(state: dict) -> None:
    body = json.dumps(state, separators=(",", ":")).encode("utf-8")
    s3.put_object(
        Bucket=BUCKET, Key=STATE_KEY, Body=body, ContentType="application/json"
    )

def _http_get(params: dict) -> dict:
    qs = urllib.parse.urlencode(params, doseq=True)
    url = f"{BASE_URL}?{qs}" if qs else BASE_URL
    req = Request(url, method="GET")
    req.add_header("Authorization", f"Bearer {TOKEN}")
    req.add_header("Accept", "application/json")
    attempt = 0
    while True:
        try:
            with urlopen(req, timeout=HTTP_TIMEOUT) as r:
                return json.loads(r.read().decode("utf-8"))
        except HTTPError as e:
            # Respect Retry-After on 429/5xx
            if e.code in (429, 500, 502, 503, 504) and attempt < HTTP_RETRIES:
                retry_after = 0
                try:
                    retry_after = int(
                        e.headers.get("Retry-After", RETRY_AFTER_DEFAULT)
                    )
                except Exception:
                    retry_after = RETRY_AFTER_DEFAULT
                time.sleep(max(1, retry_after))
                attempt += 1
                continue
            raise
        except URLError:
            if attempt < HTTP_RETRIES:
                time.sleep(RETRY_AFTER_DEFAULT)
                attempt += 1
                continue
            raise

def _write_page(data: dict, page_idx: int) -> str:
    """Extract entries from Slack API response and write as JSONL."""
    entries = data.get("entries") or []
    if not entries:
        return None
    lines = [json.dumps(entry, separators=(",", ":")) for entry in entries]
    body = "\n".join(lines).encode("utf-8")
    ts = time.strftime("%Y/%m/%d/%H%M%S", time.gmtime())
    key = f"{PREFIX}{ts}-slack-audit-p{page_idx:05d}.json"
    s3.put_object(
        Bucket=BUCKET, Key=key, Body=body, ContentType="application/json"
    )
    return key

def lambda_handler(event=None, context=None):
    state = _get_state()
    cursor = state.get("cursor")
    params = {"limit": LIMIT}
    if ACTIONS:
        params["action"] = [a.strip() for a in ACTIONS.split(",") if a.strip()]
    if cursor:
        params["cursor"] = cursor
    else:
        # First run (or reset): fetch a recent window by time
        params["oldest"] = int(time.time()) - LOOKBACK_SEC
    pages = 0
    total = 0
    last_cursor = None
    while pages < MAX_PAGES:
        data = _http_get(params)
        _write_page(data, pages)
        entries = data.get("entries") or []
        total += len(entries)
        # Cursor for next page
        meta = data.get("response_metadata") or {}
        next_cursor = meta.get("next_cursor") or data.get("next_cursor")
        if next_cursor:
            params = {"limit": LIMIT, "cursor": next_cursor}
            if ACTIONS:
                params["action"] = [
                    a.strip() for a in ACTIONS.split(",") if a.strip()
                ]
            last_cursor = next_cursor
            pages += 1
            continue
        break
    if last_cursor:
        _put_state({"cursor": last_cursor})
    return {
        "ok": True,
        "pages": pages + (1 if total or last_cursor else 0),
        "entries": total,
        "cursor": last_cursor,
    }

if __name__ == "__main__":
    print(lambda_handler())

配置 Lambda 环境变量

  1. 依次前往配置 > 环境变量 > 修改 > 添加环境变量。

  2. 输入以下环境变量，并替换为您的值：

    键 示例值
    SLACK_AUDIT_TOKEN xoxp-...（具有 auditlogs:read 的组织级用户令牌）
    S3_BUCKET slack-audit-logs
    S3_PREFIX slack/audit/
    STATE_KEY slack/audit/state.json
    LIMIT 200
    MAX_PAGES 20
    LOOKBACK_SECONDS 3600
    HTTP_TIMEOUT 60
    HTTP_RETRIES 3
    RETRY_AFTER_DEFAULT 2
    ACTIONS （可选，以英文逗号分隔的操作过滤条件）

  3. 点击保存。

  4. 选择配置标签页。在常规配置面板中，点击修改。

  5. 将超时更改为 5 minutes（300 秒），然后点击保存。

创建 EventBridge 计划

  1. 依次前往 Amazon EventBridge > 调度器 > 创建调度。
  2. 提供以下配置详细信息：
    • 名称：输入 slack-audit-1h。
    • 周期性安排：选择基于费率的安排。
    • 费率表达式：输入 1 hours。
    • 灵活的时间窗口：选择关闭。
  3. 点击下一步。
  4. 选择目标：
    • 目标 API：选择 AWS Lambda 调用。
    • Lambda 函数：选择 slack_audit_to_s3。
  5. 点击下一步。
  6. 点击下一步（跳过可选设置）。
  7. 检查并点击创建时间表。

可选：为 Google SecOps 创建只读 IAM 用户

  1. 依次前往 AWS 控制台 > IAM > 用户 > 创建用户。
  2. 提供以下配置详细信息：
    • 用户名：输入 secops-reader。
    • 访问类型：选择以编程方式访问。
  3. 点击下一步。
  4. 选择直接附加政策。

  5. 点击创建政策。在 JSON 标签页中，输入以下内容：

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::slack-audit-logs/*"
    },
    {
      "Effect": "Allow",
      "Action": ["s3:ListBucket"],
      "Resource": "arn:aws:s3:::slack-audit-logs"
    }
  ]
}

  6. 点击下一步。

  7. 输入政策名称 secops-reader-policy。

  8. 点击创建政策。

  9. 返回到用户创建页面，刷新政策列表，然后选择 secops-reader-policy。

  10. 点击下一步。

  11. 点击创建用户。

  12. 选择已创建的用户 secops-reader。

  13. 依次前往安全凭据 > 访问密钥 > 创建访问密钥。

  14. 选择第三方服务。

  15. 点击下一步。

  16. 点击创建访问密钥。

  17. 点击下载 .csv 文件以保存凭据。

在 Google SecOps 中配置 Feed 以注入 Slack 审核日志

  1. 依次前往 SIEM 设置 > Feed。
  2. 点击添加新 Feed。
  3. 点击配置单个 Feed。
  4. 在 Feed 名称字段中，输入 Feed 的名称（例如 Slack Audit Logs）。
  5. 选择 Amazon S3 V2 作为来源类型。
  6. 选择 Slack 审核作为日志类型。

  7. 点击下一步。

    为以下输入参数指定值：

    • S3 URI：输入带有前缀路径的 S3 存储桶 URI：

      s3://slack-audit-logs/slack/audit/

      将 slack-audit-logs 替换为您的实际 S3 存储桶名称。

    • 源删除选项：根据您的偏好选择删除选项。

    • 文件存在时间上限：包含在过去指定天数内修改的文件。默认值为 180 天。

    • 访问密钥 ID：具有 S3 存储桶访问权限的用户访问密钥（来自 secops-reader IAM 用户）。

    • 私有访问密钥：具有 S3 存储桶访问权限的用户私有密钥（来自 secops-reader IAM 用户）。

    • 资产命名空间：资产命名空间。

    • 提取标签：要应用于相应 Feed 中事件的标签。

  8. 点击下一步。

  9. 在最终确定界面中查看新的 Feed 配置，然后点击提交。

UDM 映射表

日志字段 UDM 映射 逻辑
action metadata.product_event_type 直接从 action 字段映射
actor.type principal.labels 直接与键 actor.type 相关联
actor.user.email principal.user.email_addresses 直接映射
actor.user.id principal.user.product_object_id 直接映射
actor.user.id principal.user.userid 直接映射
actor.user.name principal.user.user_display_name 直接映射
actor.user.team principal.user.group_identifiers 直接映射
context.ip_address principal.ip 直接映射
context.location.domain about.resource.attribute.labels 直接与键 context.location.domain 相关联
context.location.id about.resource.id 直接映射
context.location.name about.resource.name 直接映射
context.location.name about.resource.attribute.labels 直接与键 context.location.name 相关联
context.location.type about.resource.resource_subtype 直接映射
context.session_id network.session_id 直接映射
context.ua network.http.user_agent 直接映射
context.ua network.http.parsed_user_agent 从 context.ua 字段派生的已解析用户代理
country principal.location.country_or_region 直接映射
date_create metadata.event_timestamp.seconds 纪元时间戳转换为时间戳对象
details.inviter.email target.user.email_addresses 直接映射
details.inviter.id target.user.product_object_id 直接映射
details.inviter.name target.user.user_display_name 直接映射
details.inviter.team target.user.group_identifiers 直接映射
details.reason security_result.description 直接映射；如果是数组，则用英文逗号连接
details.type about.resource.attribute.labels 直接与键 details.type 相关联
details.type security_result.summary 直接映射
entity.app.id target.resource.id 直接映射
entity.app.name target.resource.name 直接映射
entity.channel.id target.resource.id 直接映射
entity.channel.name target.resource.name 直接映射
entity.channel.privacy target.resource.attribute.labels 直接与键 entity.channel.privacy 相关联
entity.file.filetype target.resource.attribute.labels 直接与键 entity.file.filetype 相关联
entity.file.id target.resource.id 直接映射
entity.file.name target.resource.name 直接映射
entity.file.title target.resource.attribute.labels 直接与键 entity.file.title 相关联
entity.huddle.date_end about.resource.attribute.labels 直接与键 entity.huddle.date_end 相关联
entity.huddle.date_start about.resource.attribute.labels 直接与键 entity.huddle.date_start 相关联
entity.huddle.id about.resource.attribute.labels 直接与键 entity.huddle.id 相关联
entity.huddle.participants.0 about.resource.attribute.labels 直接与键 entity.huddle.participants.0 相关联
entity.huddle.participants.1 about.resource.attribute.labels 直接与键 entity.huddle.participants.1 相关联
entity.type target.resource.resource_subtype 直接映射
entity.user.email target.user.email_addresses 直接映射
entity.user.id target.user.product_object_id 直接映射
entity.user.name target.user.user_display_name 直接映射
entity.user.team target.user.group_identifiers 直接映射
entity.workflow.id target.resource.id 直接映射
entity.workflow.name target.resource.name 直接映射
id metadata.product_log_id 直接映射
ip principal.ip 直接映射
user_agent network.http.user_agent 直接映射
user_id principal.user.product_object_id 直接映射
username principal.user.product_object_id 直接映射
metadata.event_type 默认值为 USER_COMMUNICATION；如果操作为 user_created，则设置为 USER_CREATION；如果操作为 user_login 或 user_login_failed，则设置为 USER_LOGIN；如果操作为 user_logout，则设置为 USER_LOGOUT；如果操作与 file_ 匹配，则设置为 USER_RESOURCE_ACCESS；如果操作与 app_、private_、public_ 或 auth_policy_ 匹配，则设置为 USER_RESOURCE_UPDATE_PERMISSIONS；如果操作与 pref、legal_hold_、workflow_、channel_、user_deactivated、user_reactivated、role_change_ 或 user_channel_ 匹配，则设置为 USER_CHANGE_PERMISSIONS
metadata.log_type 硬编码为 SLACK_AUDIT
metadata.product_name 如果 date_create 存在，则设置为 Enterprise Grid；否则，如果 user_id 存在，则设置为 Audit Logs
metadata.vendor_name 硬编码为 Slack
extensions.auth.mechanism 硬编码为 REMOTE
extensions.auth.type 如果操作包含 user_login 或 user_logout，则设置为 SSO；否则设置为 MACHINE
security_result.action 默认为 ALLOW；如果操作为 user_login_failed，则设置为 BLOCK
target.application 如果 date_create 存在，则设置为 Slack；否则，如果 user_id 存在，则设置为 SLACK
details.url_private target.url 从变更日志映射
details.previous_ip_address principal.labels 从变更日志映射
details.previous_ua principal.labels 从变更日志映射

更新日志

查看相应解析器的更改日志

需要更多帮助？获得社区成员和 Google SecOps 专业人士的解答。