收集 Slack 审核日志

支持的语言：

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

Slack 审核日志会详细记录 Slack Enterprise Grid 组织中与安全相关的事件。借助 Audit Logs API，您可以监控用户操作（例如登录、文件下载、应用安装和管理更改），以进行合规性和安全监控。

准备工作

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

  • Google SecOps 实例。

  • 具有组织所有者访问权限的 Slack Enterprise Grid 方案。

  • 对以下任一资源的特权访问权限：

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

收集 Slack 凭证

创建 Slack 应用

Slack Audit Logs 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. 在 User Token Scopes（用户令牌范围，而非聊天机器人令牌范围）下，点击 Add an OAuth Scope（添加 OAuth 范围）。
  4. 添加以下范围：
    • auditlogs:read - 此范围支持访问 Enterprise Grid 组织的 Audit Logs API。
  5. 在 Bot Token Scopes（机器人令牌范围）下，点击 Add an OAuth Scope（添加 OAuth 范围）。
  6. 添加以下范围：
    • users:read - 存在，以便在组织级层安装应用。

在 Enterprise 组织中安装应用

Audit Logs API 会读取整个企业组织的事件，因此必须在组织级层（而非单个工作区中）安装该应用。Slack 文档介绍了两种实现此目的的方法。两者都会生成相同的组织级用户 OAuth 令牌。请使用其中一个。

选项 A：从应用设置中安装（组织级应用）

此路径来自 Slack 的为企业组织开发应用页面。它不需要重定向网址、公开分发和 Web 服务。

  1. 在应用的“设置”页面中，从左侧导航栏中选择组织级应用。
  2. 点击选择启用。

  3. 在确认提示中，点击是，选择启用。

  4. 以企业组织所有者的身份登录。

  5. 从左侧导航栏中选择 OAuth & Permissions（OAuth 和权限）。

  6. 点击安装到组织。

  7. 在确认屏幕上查看请求的权限，然后点击允许。

选项 B：公开分发和可分享的网址

这是 Slack 的审核日志 API 页面中的路径。启用公开分发不会在 Slack Marketplace 中列出应用；它仅允许在开发工作区之外安装应用。

  1. 在应用的设置页面中，从左侧导航栏中选择 OAuth & Permissions（OAuth 和权限）。

  2. 在重定向网址部分中，点击添加新的重定向网址，输入网址，点击添加，然后点击保存网址。

  3. 从左侧导航栏中选择管理分发。

  4. 在与其他工作区共享您的应用下，确认所有四个核对清单部分都显示绿色对勾标记。如果某个部分显示红色 X，请展开该部分并完成所需的操作。

  5. 选中我已检查并移除了所有硬编码信息复选框。

  6. 点击启用公开分发。

  7. 以企业组织所有者的身份登录。

  8. 在与工作区分享应用下，复制可分享的网址，然后在浏览器中打开该网址。

  9. 在安装界面中，打开右上角的下拉菜单，然后选择企业组织，而不是个人工作区。

  10. 查看请求的权限，然后点击允许。

检索凭证

  1. 安装完成后，您将返回 OAuth & Permissions（OAuth 和权限）页面。
  2. 在 OAuth 令牌部分，找到用户 OAuth 令牌。
  3. 令牌以 xoxp- 开头。

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

    重要提示：这是 Cloud Run 函数或 Lambda 函数的 SLACK_ADMIN_TOKEN。请妥善存储。它提供对 Enterprise Grid 组织中所有审核日志的读取权限。

  5. 记下您的组织 ID：

    1. 使用组织网址（例如 acmeinc.enterprise.slack.com）在网络浏览器中打开 Slack。
    2. 网页加载完毕后，请阅读网址。其格式为 https://app.slack.com/client/EXXXXXXX/CXXXXXXX。
    3. 复制以 E 开头的字符串。这就是您的组织 ID。

验证权限

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

  1. 前往 Slack API 应用页面。
  2. 选择您的应用。
  3. 从左侧导航栏中选择 OAuth & Permissions（OAuth 和权限）。
  4. 在 OAuth 令牌下，验证是否显示了用户 OAuth 令牌（以 xoxp- 开头）。
  5. 在范围下，验证 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 审核日志，并使用 Google SecOps 注入脚本将其直接注入 Google SecOps。

准备工作（选项 1）

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

  • 一个启用了以下 API 的 Google Cloud 项目：
    • Cloud Run Admin API
    • Eventarc API
    • Pub/Sub API
    • Cloud Scheduler API
    • Secret Manager API
  • 创建 Cloud Run functions 函数、Pub/Sub 主题、Eventarc 触发器、Cloud Scheduler 作业和 Secret Manager 中的 Secret 的权限。
  • Google SecOps 服务账号 JSON 文件。

获取 Google SecOps 服务账号

  1. 登录 Google SecOps 控制台。
  2. 前往 SIEM 设置> 收集代理。
  3. 点击下载以下载内容提交身份验证文件。
  4. 妥善保存 JSON 文件。您需要将此文件作为 Secret 上传到 Google Secret Manager。

准备函数代码

从 Google SecOps 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 functions 函数安全访问。

为 Google SecOps 服务账号创建 Secret

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

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

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

为 Slack 令牌创建 Secret

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

  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 文件。

创建 Pub/Sub 主题

Cloud Scheduler 通过 Pub/Sub 主题触发 Cloud Run 函数。

  1. 在 GCP 控制台中，前往 Pub/Sub > 主题。
  2. 点击创建主题。
  3. 在主题 ID 字段中，输入 slack-audit-trigger。
  4. 点击创建。

部署 Cloud Run 函数

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

    gcloud run deploy slack-audit-to-chronicle \
  --source . \
  --function main \
  --base-image google-22/python312 \
  --region <REGION> \
  --service-account <SERVICE_ACCOUNT_EMAIL> \
  --env-vars-file .env.yml \
  --memory 512Mi \
  --timeout 540 \
  --max-instances 1 \
  --no-allow-unauthenticated
    • 将 <REGION> 替换为区域（例如 us-central1），并将 <SERVICE_ACCOUNT_EMAIL> 替换为您希望 Cloud Run 函数使用的服务账号的电子邮件地址。

  2. 为函数创建 Pub/Sub 触发器，如下所示：

    gcloud eventarc triggers create slack-audit-trigger \
  --location <REGION> \
  --destination-run-service slack-audit-to-chronicle \
  --destination-run-region <REGION> \
  --event-filters "type=google.cloud.pubsub.topic.v1.messagePublished" \
  --transport-topic projects/<PROJECT_ID>/topics/slack-audit-trigger \
  --service-account <SERVICE_ACCOUNT_EMAIL>
    • 请将 <PROJECT_ID> 替换为您的 Google Cloud 项目 ID。

  3. 等待部署完成。

设置 Cloud Scheduler

  1. 在 GCP 控制台中，前往 Cloud Scheduler > 创建作业。

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

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

  3. 点击继续。

  4. 在配置执行部分中：

    • 目标类型：选择 Pub/Sub。
    • 主题：选择 slack-audit-trigger。
    • 邮件正文：输入 run。

  5. 点击创建。

时间表频率选项

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

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

测试集成（选项 1）

  1. 在 Cloud Scheduler 控制台中，找到您的作业 (slack-audit-scheduler)。
  2. 点击强制运行以手动触发作业。
  3. 等待几秒钟。
  4. 前往 Cloud Run。
  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. 创建函数后，打开代码标签页，删除桩代码并粘贴以下代码 (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。
    • Access type（访问类型）：选择 Programmatic access（以编程方式使用）。
  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. 点击下一步。

  8. 为以下输入参数指定值：

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

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

Replace `slack-audit-logs` with your actual S3 bucket name.

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

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

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

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

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

    • 注入标签：要应用于此 Feed 中的事件的标签。

  9. 点击下一步。

  10. 在最终确定界面中查看新的新闻信息流配置，然后点击提交。

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

更新日志

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

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