איסוף יומני ביקורת של Slack

נתמך ב:

במאמר הזה מוסבר איך להטמיע יומני ביקורת של Slack ב-Google Security Operations באמצעות פונקציות של Google Cloud Run או Amazon S3 עם AWS Lambda.

יומני הביקורת של Slack מספקים תיעוד מפורט של אירועים שקשורים לאבטחה בארגון שלכם ב-Slack Enterprise Grid. בעזרת Audit Logs API אפשר לעקוב אחרי פעולות של משתמשים, כמו התחברות, הורדת קבצים, התקנת אפליקציות ושינויים אדמיניסטרטיביים, למטרות תאימות וניטור לצורכי אבטחה.

לפני שמתחילים

חשוב לוודא שיש לכם את הדברים הבאים:

  • מופע של Google SecOps.
  • תוכנית Slack Enterprise Grid עם הרשאת בעלים של הארגון.

  • גישה מיוחדת לאחד מהבאים:

    • Google Cloud (לאפשרות 1: פונקציות Cloud Run ו-Cloud Scheduler), או
    • AWS (לאפשרות 2: S3, ‏ IAM, ‏ Lambda, ‏ EventBridge).

איסוף פרטי הכניסה ל-Slack

יצירת האפליקציה ב-Slack

כדי להשתמש ב-Slack Audit Logs API, צריך טוקן OAuth של משתמש עם היקף ההרשאות auditlogs:read. כדי לקבל את הטוקן הזה, צריך להתקין אפליקציה ברמת הארגון ב-Enterprise Grid, ולא ברמת סביבת העבודה.

  1. נכנסים ל-Slack בתור הבעלים של הארגון ב-Enterprise Grid.
  2. נכנסים לדף האפליקציות של Slack API.
  3. לוחצים על Create New App (יצירת אפליקציה חדשה).
  4. לוחצים על מאפס.
  5. מזינים את פרטי ההגדרה הבאים:
    • שם האפליקציה: מזינים שם תיאורי (לדוגמה, Google SecOps Audit Integration).
    • Pick a workspace to develop your app in (בחירת סביבת עבודה לפיתוח האפליקציה): בוחרים את סביבת העבודה לפיתוח ב-Slack (כל סביבת עבודה בארגון).
  6. לחצו על Create App.

הגדרת היקפי ההרשאות של OAuth

  1. בדף ההגדרות של האפליקציה, בוחרים באפשרות OAuth & Permissions (OAuth והרשאות) בתפריט הניווט הימני.
  2. עוברים לקטע Scopes (היקפים).
  3. בקטע User Token Scopes (ולא Bot Token Scopes), לוחצים על Add an OAuth Scope.
  4. מוסיפים את ההיקף הבא:
    • ‫auditlogs:read – ההיקף הזה מאפשר גישה ל-Audit Logs API של הארגון ב-Enterprise Grid.
  5. בקטע Bot Token Scopes, לוחצים על Add an OAuth Scope.
  6. מוסיפים את ההיקף הבא:
    • users:read – צריך להוסיף את ההיקף הזה כדי שאפשר יהיה להתקין את האפליקציה ברמת הארגון.

התקנת האפליקציה בארגון ב-Enterprise

‫Audit Logs API קורא אירועים מכל הארגון ב-Enterprise, ולכן צריך להתקין את האפליקציה ברמת הארגון ולא בסביבת עבודה אחת. ב-Slack יש שתי דרכים לעשות את זה. שתי השיטות יוצרות את אותו טוקן OAuth של משתמש ברמת הארגון. צריך להשתמש באחת מהן.

אפשרות א': התקנה מהגדרות האפליקציה (אפליקציה ברמת הארגון)

זה הנתיב מהדף Developing apps for Enterprise orgs (פיתוח אפליקציות לארגונים) של Slack. היא לא צריכה כתובת URL להפניה אוטומטית, הפצה ציבורית או שירות אינטרנט.

  1. בדף ההגדרות של האפליקציה, בוחרים באפשרות Org Level Apps (אפליקציות ברמת הארגון) בתפריט הניווט הימני.
  2. לוחצים על הצטרפות.
  3. בהודעת האישור, לוחצים על כן, אני רוצה להצטרף.

  4. נכנסים בתור הבעלים של הארגון ב-Enterprise.

  5. בסרגל הניווט הימני, לוחצים על OAuth & Permissions (OAuth והרשאות).

  6. לוחצים על Install to Organization (התקנה בארגון).

  7. בודקים את ההרשאות הנדרשות במסך האישור ולוחצים על אישור.

אפשרות ב': הפצה ציבורית וכתובת URL שניתן לשתף

זה הנתיב מהדף Audit Logs API של Slack. הפעלת ההפצה הציבורית לא מוסיפה את האפליקציה ל-Slack Marketplace, אלא רק מאפשרת להתקין אותה מחוץ לסביבת הפיתוח.

  1. בדף ההגדרות של האפליקציה, בוחרים באפשרות OAuth & Permissions (OAuth והרשאות) בתפריט הניווט הימני.
  2. בקטע כתובות URL להפניה אוטומטית, לוחצים על הוספת כתובת URL חדשה להפניה אוטומטית, מזינים כתובת URL, לוחצים על הוספה ואז על שמירת כתובות ה-URL.

  3. בתפריט הניווט הימני, לוחצים על ניהול ההפצה.

  4. בקטע שיתוף האפליקציה עם סביבות עבודה אחרות, מוודאים שבכל ארבעת החלקים של רשימת המשימות מופיע סימן וי ירוק. אם מופיע סימן X אדום ליד קטע מסוים, מרחיבים אותו ומשלימים את הפעולה הנדרשת.

  5. מסמנים את התיבה בדקתי והסרתי את כל המידע בתוך הקוד.

  6. לוחצים על הפעלת הפצה ציבורית.

  7. נכנסים בתור הבעלים של הארגון ב-Enterprise.

  8. בקטע Share Your App with Your Workspace, מעתיקים את ה-Sharable URL ופותחים אותה בדפדפן.

  9. במסך ההתקנה, פותחים את התפריט הנפתח בפינה השמאלית העליונה ובוחרים באפשרות Enterprise organization, ולא בסביבת עבודה ספציפית.

  10. בודקים את ההרשאות הנדרשות ולוחצים על אישור.

אחזור פרטי הכניסה

  1. בסיום ההתקנה, חוזרים לדף OAuth & Permissions.
  2. בקטע OAuth Tokens, מאתרים את User OAuth Token.
  3. האסימון מתחיל ב-xoxp-.
  4. לוחצים על העתקה ושומרים את האסימון הזה בצורה מאובטחת.

    חשוב: זהו ה-SLACK_ADMIN_TOKEN של פונקציית Cloud Run או פונקציית Lambda. שומרים אותו במקום מאובטח. הוא מספק גישת קריאה לכל יומני הביקורת בארגון שלכם ב-Enterprise Grid.

  5. רושמים את מזהה הארגון:

    1. פותחים את Slack בדפדפן אינטרנט באמצעות כתובת ה-URL של הארגון (לדוגמה, acmeinc.enterprise.slack.com).
    2. אחרי שהדף נטען, קוראים את כתובת ה-URL. הפורמט שלו הוא https://app.slack.com/client/EXXXXXXX/CXXXXXXX.
    3. מעתיקים את המחרוזת שמתחילה ב-E. זהו מזהה הארגון שלכם.

אימות ההרשאות

כדי לוודא שלאפליקציה יש את ההרשאות הנדרשות:

  1. נכנסים לדף האפליקציות של Slack API.
  2. בוחרים את האפליקציה הרצויה.
  3. בסרגל הניווט הימני, לוחצים על OAuth & Permissions (OAuth והרשאות).
  4. בקטע OAuth Tokens (טוקנים של OAuth), מוודאים שמוצג User OAuth Token (טוקן OAuth של משתמש) (מתחיל ב-xoxp-).
  5. בקטע Scopes, מוודאים שהערך auditlogs:read מופיע בקטע User Token Scopes.

בדיקת הגישה ל-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: הגדרת ייצוא של יומני ביקורת מ-Slack באמצעות פונקציות Cloud Run של Google

באפשרות הזו משתמשים בפונקציות של Google Cloud Run וב-Cloud Scheduler כדי לאסוף את יומני הביקורת של Slack ולהטמיע אותם ישירות ב-Google SecOps באמצעות סקריפטים להטמעה של Google SecOps.

לפני שמתחילים (אפשרות 1)

ודאו שאתם עומדים בדרישות המוקדמות הנוספות הבאות:

  • פרויקט ב- Google Cloud שבו מופעלים ממשקי ה-API הבאים:
    • Cloud Run Admin API
    • Eventarc API
    • Pub/Sub API
    • Cloud Scheduler API
    • Secret Manager API
  • הרשאות ליצירת פונקציות Cloud Run, נושאי Pub/Sub, טריגרים של Eventarc, משימות של Cloud Scheduler וסודות ב-Secret Manager.
  • קובץ JSON של חשבון שירות ב-Google SecOps.

איך מקבלים את חשבון השירות של Google SecOps

  1. נכנסים למסוף Google SecOps.
  2. עוברים אל הגדרות > ניהול נתונים > סוכני איסוף. אם אתם משתמשים בפלטפורמת SIEM בלבד, עוברים אל הגדרות > סוכני איסוף.
  3. לוחצים על Download כדי להוריד את קובץ האימות להטמעת נתונים.
  4. שומרים את קובץ ה-JSON בצורה מאובטחת. אתם צריכים להעלות את הקובץ הזה כסוד ב-Google Secret Manager.

הכנת קוד הפונקציה

מורידים את קובצי הפריסה ממאגר ה-GitHub של Google SecOps ingestion-scripts:

  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 תוכל לגשת אליהם בצורה מאובטחת.

יצירת סוד לחשבון השירות של Google SecOps

  1. במסוף Google Cloud , נכנסים לדף Security > Secret Manager.
  2. לוחצים על Create Secret.
  3. מזינים את פרטי ההגדרה הבאים:
    • שם: מזינים chronicle-service-account.
    • ‫Secret value: מדביקים את כל התוכן של קובץ ה-JSON של חשבון השירות של Google SecOps.
  4. לוחצים על Create Secret.
  5. מעתיקים את שם המשאב של הסוד. הפורמט הוא:

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

יצירת סוד לטוקן של Slack

  1. בדף Secret Manager, לוחצים על Create Secret.
  2. מזינים את פרטי ההגדרה הבאים:
    • שם: מזינים slack-admin-token.
    • ערך הסוד: מדביקים את טוקן ה-OAuth של משתמש Slack (מתחיל ב-xoxp-).
  3. לוחצים על Create Secret.
  4. מעתיקים את שם המשאב של הסוד. הפורמט הוא:

    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.
      • ‫<PROJECT_ID>: מזהה הפרויקט ב- Google Cloud .
      • ‫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 מפעיל את פונקציית Cloud Run דרך נושא Pub/Sub.

  1. במסוף GCP, נכנסים לדף Pub/Sub > Topics.
  2. לוחצים על Create topic.
  3. בשדה Topic ID, מזינים slack-audit-trigger.
  4. לוחצים על יצירה.

פריסת פונקציית Cloud Run

  1. פותחים טרמינל או את Cloud Shell במסוף Google Cloud . עוברים לספריית הפריסה ומריצים את הפקודה הבאה:

    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 .
  3. מחכים עד שהפריסה תסתיים.

הגדרת Cloud Scheduler

  1. במסוף GCP, נכנסים לדף Cloud Scheduler > Create job.
  2. ממלאים את פרטי ההגדרה הבאים:

    הגדרה ערך
    שם slack-audit-scheduler
    אזור בוחרים את אותו אזור שבו פרסתם את פונקציית Cloud Run.
    תדירות ‫*/5 * * * * (כל 5 דקות, בהתאם לערך של POLL_INTERVAL)
    אזור זמן בחירת אזור זמן (מומלץ לבחור ב-UTC)
  3. לוחצים על Continue.

  4. בקטע Configure the execution:

    • ‫Target type: בוחרים באפשרות Pub/Sub.
    • נושא: בוחרים באפשרות slack-audit-trigger.
    • גוף ההודעה: מזינים run.
  5. לוחצים על יצירה.

אפשרויות לתדירות התזמון

בוחרים את התדירות בהתאם לנפח היומן ולדרישות לגבי זמן האחזור:

תדירות ביטוי Cron תרחיש לדוגמה
כל 5 דקות */5 * * * * רגיל (מומלץ)
כל 15 דקות */15 * * * * נפח חיפושים בינוני
כל שעה 0 * * * * עוצמת הקול חלשה

בדיקת השילוב (אפשרות 1)

  1. במסוף Cloud Scheduler, מוצאים את המשימה (slack-audit-scheduler).
  2. לוחצים על Force run כדי להפעיל את המשימה באופן ידני.
  3. מחכים כמה שניות.
  4. נכנסים לדף Cloud Run.
  5. לוחצים על שם השירות (slack-audit-to-chronicle).
  6. לוחצים על הכרטיסייה Logs.
  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: הגדרת ייצוא של יומני ביקורת של Slack באמצעות AWS S3

באפשרות הזו משתמשים ב-AWS Lambda כדי לאסוף את יומני הביקורת של Slack ולאחסן אותם ב-Amazon S3, ואז מגדירים פיד של Google SecOps כדי להטמיע את היומנים.

לפני שמתחילים (אפשרות 2)

ודאו שאתם עומדים בדרישות המוקדמות הנוספות הבאות:

  • חשבון AWS עם הרשאות ליצור קטגוריות S3, משתמשים/תפקידים/כללי מדיניות של IAM, פונקציות Lambda וכללי EventBridge.

יצירת קטגוריה ב-Amazon S3

  1. יוצרים קטגוריה ב-Amazon S3 לפי ההוראות במדריך למשתמש Creating a bucket.
  2. שומרים את שם הקטגוריה ואת האזור שלה לעיון בעתיד (לדוגמה, slack-audit-logs).

הגדרת מדיניות ותפקידים של IAM להעלאות ל-S3

  1. במסוף AWS, עוברים אל הכרטיסייה IAM > Policies > Create policy > 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 > Roles > Create role > AWS service > Lambda.

  7. מצרפים את המדיניות החדשה שנוצרה SlackAuditS3Policy.

  8. נותנים לתפקיד את השם SlackAuditToS3Role ולוחצים על יצירת תפקיד.

יצירת פונקציית Lambda

  1. ב-AWS Console, עוברים אל Lambda > Functions > Create function.
  2. לוחצים על יצירה מאפס.
  3. ממלאים את פרטי ההגדרה הבאים:

    הגדרה ערך
    שם slack_audit_to_s3
    זמן ריצה ‫Python 3.13
    ארכיטקטורה x86_64
    תפקיד ביצוע SlackAuditToS3Role
  4. לוחצים על Create function.

  5. אחרי שיוצרים את הפונקציה, פותחים את הכרטיסייה Code, מוחקים את ה-stub ומדביקים את הקוד הבא (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. עוברים אל Configuration > Environment variables > Edit > Add environment variable.
  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. לוחצים על Save.

  4. בוחרים את הכרטיסייה Configuration. בחלונית General configuration לוחצים על Edit.

  5. משנים את הערך של Timeout ל-5 minutes (300 שניות) ולוחצים על Save.

יצירת לוח זמנים ב-EventBridge

  1. עוברים אל Amazon EventBridge > Scheduler > Create schedule.
  2. מזינים את פרטי ההגדרה הבאים:
    • שם: מזינים slack-audit-1h.
    • לו"ז חזרה: בוחרים באפשרות לו"ז מבוסס-תעריף.
    • Rate expression: מזינים 1 hours.
    • חלון זמן גמיש: בוחרים באפשרות מושבת.
  3. לוחצים על הבא.
  4. בוחרים יעד:
    • Target API: בוחרים באפשרות AWS Lambda Invoke.
    • פונקציית Lambda: בוחרים באפשרות slack_audit_to_s3.
  5. לוחצים על הבא.
  6. לוחצים על הבא (מדלגים על הגדרות אופציונליות).
  7. בודקים את הפרטים ולוחצים על יצירת לוח זמנים.

(אופציונלי) יצירת משתמש IAM לקריאה בלבד ב-Google SecOps

  1. עוברים אל AWS Console > IAM > Users > Create user.
  2. מזינים את פרטי ההגדרה הבאים:
    • שם משתמש: מזינים secops-reader.
    • Access type: בוחרים באפשרות Programmatic access.
  3. לוחצים על הבא.
  4. בוחרים באפשרות Attach policies directly.
  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. לוחצים על Create user.

  12. בוחרים את המשתמש שנוצר secops-reader.

  13. עוברים אל Security credentials > Access keys > Create access key.

  14. בוחרים באפשרות שירות של צד שלישי.

  15. לוחצים על הבא.

  16. לוחצים על יצירת מפתח גישה.

  17. לוחצים על הורדת קובץ ‎ .csv כדי לשמור את פרטי הכניסה.

הגדרת פיד ב-Google SecOps כדי להטמיע יומני ביקורת של Slack

  1. עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמה של SIEM בלבד, עוברים אל הגדרות > פידים.
  2. לוחצים על הוספת פיד חדש.
  3. לוחצים על הגדרת פיד יחיד.
  4. בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Slack Audit Logs).
  5. בוחרים באפשרות Amazon S3 V2 בתור סוג המקור.
  6. בוחרים באפשרות ביקורת Slack בתור סוג היומן.
  7. לוחצים על הבא.
  8. מציינים ערכים לפרמטרים הבאים של הקלט:

    • ‫S3 URI: מזינים את ה-URI של קטגוריית S3 עם נתיב הקידומת:

      ```
      s3://slack-audit-logs/slack/audit/
      ```
      
      Replace `slack-audit-logs` with your actual S3 bucket name.
      
    • אפשרות למחיקת המקור: בוחרים את אפשרות המחיקה הרצויה.

    • גיל הקובץ המקסימלי: כולל קבצים ששונו במספר הימים האחרונים. ברירת המחדל היא 180 ימים.

    • מזהה מפתח גישה: מפתח גישה של משתמש עם גישה לקטגוריית S3 (ממשתמש secops-reader ניהול זהויות והרשאות גישה (IAM)).

    • מפתח גישה סודי: מפתח סודי של משתמש עם גישה לקטגוריית S3 (ממשתמש ה-IAM של secops-reader).

    • מרחב השמות של הנכס: מרחב השמות של הנכס.

    • תוויות הטמעה: התווית שתתווסף לאירועים מהפיד הזה.

  9. לוחצים על הבא.

  10. בודקים את הגדרות הפיד החדש במסך סיום ולוחצים על שליחה.

טבלת מיפוי UDM

שדה ביומן מיפוי UDM Logic (פונקציה לוגית)
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_CREATION אם הפעולה היא user_created, כ-USER_LOGIN אם הפעולה היא user_login או user_login_failed, כ-USER_LOGOUT אם הפעולה היא user_logout, כ-USER_RESOURCE_ACCESS אם הפעולה תואמת ל-file_, כ-USER_RESOURCE_UPDATE_PERMISSIONS אם הפעולה תואמת ל-app_, ל-private_, ל-public_ או ל-auth_policy_, כ-USER_CHANGE_PERMISSIONS אם הפעולה תואמת ל-pref, ל-legal_hold_, ל-workflow_, ל-channel_, ל-user_deactivated, ל-user_reactivated, ל-role_change_ או ל-user_channel_
metadata.log_type מקודד באופן קשיח ל-SLACK_AUDIT
metadata.product_name הגדרה ל-Enterprise Grid אם date_create קיים, אחרת ל-Audit Logs אם user_id קיים
metadata.vendor_name מקודד באופן קשיח ל-Slack
extensions.auth.mechanism מקודד באופן קשיח ל-REMOTE
extensions.auth.type הגדרה ל-SSO אם הפעולה מכילה את user_login או user_logout, אחרת MACHINE
security_result.action ברירת המחדל היא ALLOW; צריך להגדיר את הערך BLOCK אם הפעולה היא user_login_failed
target.application הגדרה ל-Slack אם date_create קיים, אחרת ל-SLACK אם user_id קיים

יומן שינויים

הצגת יומן השינויים של המנתח הזה

הבעיה עדיין לא נפתרה? קבלת תשובות מחברי הקהילה וממומחי Google SecOps.