‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

איסוף יומנים מ-Snowflake

נתמך ב:

Google SecOps SIEM

במאמר הזה מוסבר איך להטמיע יומני Snowflake ב-Google Security Operations. אתם יכולים להגדיר הטמעה בשתי שיטות: Cloud Storage V2 (מומלץ) או Amazon S3 V2. שתי השיטות משתמשות באותו מנגנון בצד של Snowflake: משימה מתוזמנת פורקת את נתוני השימוש בחשבון לשלב חיצוני, ו-Google SecOps קורא את הקבצים שיוצאו באמצעות פיד.

‫Snowflake היא פלטפורמת נתונים בענן שמאחסנת את הפעילות בחשבון בסכימה SNOWFLAKE.ACCOUNT_USAGE. בתצוגה LOGIN_HISTORY מתועדים ניסיונות האימות, כולל כתובת ה-IP של הלקוח, גורם האימות והסיבה לכישלון. התצוגה QUERY_HISTORY מתעדת כל הצהרה שבוצעה בחשבון, כולל המשתמש, התפקיד, המחסן והאובייקטים שבהם בוצעו שינויים.

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

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

מכונה של Google SecOps
גישה ל-Snowflake עם תפקיד שמאפשר ליצור שילובי אחסון (רק ל-ACCOUNTADMIN יש את ההרשאה הזו כברירת מחדל), מסדי נתונים, מחסנים, שלבים ומשימות
ב-Cloud Storage V2: פרויקט ב- Google Cloud שבו Cloud Storage API מופעל, ויש הרשאות ליצור קטגוריות, ליצור תפקידים של ניהול זהויות והרשאות גישה (IAM) ולנהל את מדיניות ה-IAM של הקטגוריות
ב-Amazon S3 V2: גישה עם הרשאות ל-AWS כדי ליצור קטגוריות S3, כללי מדיניות של IAM, תפקידים של IAM ומשתמשים של IAM

מתן גישה לנתוני השימוש בחשבון Snowflake

התצוגות של SNOWFLAKE.ACCOUNT_USAGE ניתנות לקריאה על ידי ACCOUNTADMIN רק עד שניתנת גישה באופן מפורש. יוצרים תפקיד ייעודי לייצוא ומקצים לו את שני התפקידים במסד הנתונים שכוללים את התצוגות שהמסמך הזה מייצא.

נכנסים ל-Snowflake ופותחים גיליון עבודה.
כדי ליצור את תפקיד הייצוא ולהעניק לו גישת קריאה לתצוגות השימוש בחשבון:
```
USE ROLE ACCOUNTADMIN;

CREATE ROLE IF NOT EXISTS SECOPS_EXPORTER;

GRANT DATABASE ROLE SNOWFLAKE.SECURITY_VIEWER TO ROLE SECOPS_EXPORTER;
GRANT DATABASE ROLE SNOWFLAKE.GOVERNANCE_VIEWER TO ROLE SECOPS_EXPORTER;
```
הערה: SNOWFLAKE.SECURITY_VIEWER כולל את LOGIN_HISTORY ו-SNOWFLAKE.GOVERNANCE_VIEWER כולל את QUERY_HISTORY. אפשר גם להעניק את ההרשאה IMPORTED PRIVILEGES ON DATABASE SNOWFLAKE, אבל היא חושפת את כל הסכימה, כולל נתונים ברמת הארגון, ולכן עדיף להשתמש בשני התפקידים של מסד הנתונים.

יוצרים את מסד הנתונים, הסכימה והמחסן שמשמשים לייצוא, ומקצים להם את התפקיד באופן הבא:

CREATE DATABASE IF NOT EXISTS SECOPS_EXPORT;
CREATE SCHEMA IF NOT EXISTS SECOPS_EXPORT.ACTIVITY;

CREATE WAREHOUSE IF NOT EXISTS SECOPS_EXPORT_WH
    WITH WAREHOUSE_SIZE = 'XSMALL'
    AUTO_SUSPEND = 60
    AUTO_RESUME = TRUE
    INITIALLY_SUSPENDED = TRUE;

GRANT USAGE ON DATABASE SECOPS_EXPORT TO ROLE SECOPS_EXPORTER;
GRANT USAGE, CREATE STAGE, CREATE TABLE, CREATE PROCEDURE, CREATE TASK, CREATE FILE FORMAT
    ON SCHEMA SECOPS_EXPORT.ACTIVITY TO ROLE SECOPS_EXPORTER;
GRANT USAGE, OPERATE ON WAREHOUSE SECOPS_EXPORT_WH TO ROLE SECOPS_EXPORTER;
GRANT EXECUTE TASK ON ACCOUNT TO ROLE SECOPS_EXPORTER;
GRANT ROLE SECOPS_EXPORTER TO USER <YOUR_USER>;

מחליפים את <YOUR_USER> במשתמש ב-Snowflake שהוא הבעלים של הייצוא.

שיטה 1: Cloud Storage V2 (מומלץ)

יצירת קטגוריה של Cloud Storage

נכנסים לGoogle Cloud מסוף.
בוחרים את הפרויקט או יוצרים פרויקט חדש.
בתפריט הניווט, נכנסים ל-Cloud Storage > Buckets.
לוחצים על Create bucket.

ממלאים את פרטי ההגדרה הבאים:

הגדרה	ערך
Name your bucket	מזינים שם ייחודי ברמה גלובלית (לדוגמה, `snowflake-activity-logs`)
סוג המיקום	בוחרים לפי הצרכים (אזור, שני אזורים, מספר אזורים)
Location	בוחרים את המיקום (לדוגמה, `us-central1`)
סוג אחסון (storage class)	רגיל (מומלץ ליומנים שהגישה אליהם תכופה)
בקרת גישה	אחידה (מומלץ)
כלי הגנה	אופציונלי: הפעלת ניהול גרסאות של אובייקטים או מדיניות שמירת נתונים

לוחצים על יצירה.

יצירת תפקיד בהתאמה אישית ב-Cloud Storage ל-Snowflake

במסוף Google Cloud , נכנסים לדף IAM & Admin > Roles.
לוחצים על יצירת תפקיד.
מזינים את פרטי ההגדרה הבאים:
- כותרת: מזינים Snowflake Unload
- מזהה: מזינים snowflake_unload
- ‫Role launch stage: בוחרים באפשרות General Availability.
לוחצים על Add permissions ומוסיפים את ההרשאות הבאות:
- storage.buckets.get
- storage.objects.create
- storage.objects.delete
- storage.objects.list
לוחצים על יצירה.

הערה: זוהי קבוצת ההרשאות שמתועדת ב-Snowflake לפריקת נתונים. כדי לטעון נתונים ל-Snowflake צריך גם את storage.objects.get, אבל השילוב הזה לא דורש את זה.

יצירת שילוב האחסון של Snowflake ל-Cloud Storage

בגיליון עבודה של Snowflake, יוצרים את שילוב האחסון באופן הבא:

USE ROLE ACCOUNTADMIN;

CREATE STORAGE INTEGRATION SECOPS_GCS_INT
    TYPE = EXTERNAL_STAGE
    STORAGE_PROVIDER = 'GCS'
    ENABLED = TRUE
    STORAGE_ALLOWED_LOCATIONS = ('gcs://snowflake-activity-logs/snowflake/');

GRANT USAGE ON INTEGRATION SECOPS_GCS_INT TO ROLE SECOPS_EXPORTER;

מחליפים את snowflake-activity-logs בשם הקטגוריה.

כדי לאחזר את חשבון השירות שנוצר ב-Snowflake בשביל השילוב:
```
DESC STORAGE INTEGRATION SECOPS_GCS_INT;
```
מעתיקים את הערך של המאפיין STORAGE_GCP_SERVICE_ACCOUNT. הערך הוא בפורמט הבא:
```
service-account-id@project1-123456.iam.gserviceaccount.com
```
הערה: ב-Snowflake נוצר חשבון שירות אחד לכל חשבון Snowflake, כך שכל שילוב של אחסון ב-Cloud Storage בחשבון משתמש באותו ערך.

מתן גישה לקטגוריה לחשבון השירות של Snowflake

במסוף Google Cloud , נכנסים לדף Cloud Storage > Buckets.
לוחצים על הקטגוריה שיצרתם (לדוגמה, snowflake-activity-logs).
עוברים לכרטיסייה Permissions.
לוחצים על הענקת גישה.
מזינים את פרטי ההגדרה הבאים:
- Add principals: מדביקים את הערך של STORAGE_GCP_SERVICE_ACCOUNT
- הקצאת תפקידים: בוחרים באפשרות Snowflake Unload.
לוחצים על Save.

יצירת פורמט הקובץ והשלב החיצוני

בגיליון עבודה של Snowflake, יוצרים את פורמט הקובץ ואת השלב שכותב לקטגוריה באופן הבא:
```
USE ROLE SECOPS_EXPORTER;
USE SCHEMA SECOPS_EXPORT.ACTIVITY;

CREATE OR REPLACE FILE FORMAT SECOPS_JSON_FORMAT
    TYPE = JSON;

CREATE OR REPLACE STAGE SECOPS_EXPORT_STAGE
    URL = 'gcs://snowflake-activity-logs/snowflake/'
    STORAGE_INTEGRATION = SECOPS_GCS_INT
    FILE_FORMAT = SECOPS_JSON_FORMAT;
```
הערה: כברירת מחדל, Snowflake דוחס קבצים שנפרקו באמצעות gzip, כך שהקטגוריה מקבלת אובייקטים מסוג .json.gz. הפיד מבטל את הדחיסה שלהם במהלך ההטמעה.

יצירת טבלת מצב הייצוא

הייצוא עוקב אחרי המיקום שאליו הוא הגיע בכל תצוגה. בלי סימן המים הזה, כל הפעלה תייצא מחדש את כל התצוגה ואותם אירועים יוטמעו שוב.

יוצרים את טבלת המצבים ומזינים בה נתונים באופן הבא:
```
CREATE TABLE IF NOT EXISTS SECOPS_EXPORT_STATE (
    VIEW_NAME STRING NOT NULL,
    LAST_EXPORTED TIMESTAMP_LTZ NOT NULL,
    WINDOW_END TIMESTAMP_LTZ
);

INSERT INTO SECOPS_EXPORT_STATE (VIEW_NAME, LAST_EXPORTED)
    SELECT 'LOGIN_HISTORY', DATEADD('day', -7, CURRENT_TIMESTAMP())
    UNION ALL
    SELECT 'QUERY_HISTORY', DATEADD('day', -7, CURRENT_TIMESTAMP());
```
הערה: ערכי הבסיס קובעים כמה נתונים היסטוריים ייצאו בהפעלה הראשונה. בתצוגות של השימוש בחשבון נשמרים נתונים של 365 ימים, כך שאפשר למלא יותר חוסרים, אבל הייצוא הראשון יהיה גדול. מריצים את ההצהרה INSERT פעם אחת. אם מריצים אותו שוב, נוספות שורות כפולות והייצוא מפסיק להתקדם כמו שצריך.

יצירת הליך הייצוא

יוצרים את הפרוצדורה שפורקת את שתי התצוגות ומקדמת את סימן המים באופן הבא:

CREATE OR REPLACE PROCEDURE SECOPS_EXPORT_ACTIVITY()
RETURNS STRING
LANGUAGE SQL
AS
$$
BEGIN
    UPDATE SECOPS_EXPORT_STATE
        SET WINDOW_END = DATEADD('hour', -3, CURRENT_TIMESTAMP());

    COPY INTO @SECOPS_EXPORT_STAGE/login_history/
        FROM (
            SELECT OBJECT_CONSTRUCT(
                'application', 'snowflake',
                'log_type', 'login_history',
                'EVENT_TIMESTAMP', EVENT_TIMESTAMP,
                'EVENT_TYPE', EVENT_TYPE,
                'USER_NAME', USER_NAME,
                'CLIENT_IP', CLIENT_IP,
                'REPORTED_CLIENT_TYPE', REPORTED_CLIENT_TYPE,
                'REPORTED_CLIENT_VERSION', REPORTED_CLIENT_VERSION,
                'FIRST_AUTHENTICATION_FACTOR', FIRST_AUTHENTICATION_FACTOR,
                'SECOND_AUTHENTICATION_FACTOR', SECOND_AUTHENTICATION_FACTOR,
                'IS_SUCCESS', IS_SUCCESS,
                'ERROR_CODE', ERROR_CODE,
                'ERROR_MESSAGE', ERROR_MESSAGE)
            FROM SNOWFLAKE.ACCOUNT_USAGE.LOGIN_HISTORY
            WHERE EVENT_TIMESTAMP > (SELECT LAST_EXPORTED FROM SECOPS_EXPORT_STATE WHERE VIEW_NAME = 'LOGIN_HISTORY')
                AND EVENT_TIMESTAMP <= (SELECT WINDOW_END FROM SECOPS_EXPORT_STATE WHERE VIEW_NAME = 'LOGIN_HISTORY')
        )
        FILE_FORMAT = (TYPE = JSON)
        INCLUDE_QUERY_ID = TRUE;

    UPDATE SECOPS_EXPORT_STATE
        SET LAST_EXPORTED = WINDOW_END
        WHERE VIEW_NAME = 'LOGIN_HISTORY';

    COPY INTO @SECOPS_EXPORT_STAGE/query_history/
        FROM (
            SELECT OBJECT_CONSTRUCT(
                'application', 'snowflake',
                'log_type', 'query_history',
                'START_TIME', START_TIME,
                'END_TIME', END_TIME,
                'QUERY_ID', QUERY_ID,
                'QUERY_TYPE', QUERY_TYPE,
                'EXECUTION_STATUS', EXECUTION_STATUS,
                'ERROR_MESSAGE', ERROR_MESSAGE,
                'USER_NAME', USER_NAME,
                'ROLE_NAME', ROLE_NAME,
                'WAREHOUSE_NAME', WAREHOUSE_NAME,
                'WAREHOUSE_SIZE', WAREHOUSE_SIZE,
                'DATABASE_NAME', DATABASE_NAME,
                'SCHEMA_NAME', SCHEMA_NAME,
                'SESSION_ID', SESSION_ID,
                'BYTES_SCANNED', BYTES_SCANNED,
                'ROWS_PRODUCED', ROWS_PRODUCED,
                'TOTAL_ELAPSED_TIME', TOTAL_ELAPSED_TIME)
            FROM SNOWFLAKE.ACCOUNT_USAGE.QUERY_HISTORY
            WHERE START_TIME > (SELECT LAST_EXPORTED FROM SECOPS_EXPORT_STATE WHERE VIEW_NAME = 'QUERY_HISTORY')
                AND START_TIME <= (SELECT WINDOW_END FROM SECOPS_EXPORT_STATE WHERE VIEW_NAME = 'QUERY_HISTORY')
        )
        FILE_FORMAT = (TYPE = JSON)
        INCLUDE_QUERY_ID = TRUE;

    UPDATE SECOPS_EXPORT_STATE
        SET LAST_EXPORTED = WINDOW_END
        WHERE VIEW_NAME = 'QUERY_HISTORY';

    RETURN 'Export completed';
END;
$$;

לכל שלב בתהליך יש סיבה:

החלון נסגר שלוש שעות לפני השעה הנוכחית. ‫Snowflake מאכלס את LOGIN_HISTORY עם זמן אחזור של עד שעתיים ואת QUERY_HISTORY עם זמן אחזור של עד 45 דקות, כך שחלון שמסתיים עכשיו ידלג על שורות שהתצוגה עדיין לא מימשה. לכן, האירועים מגיעים ל-Google SecOps בערך שלוש שעות אחרי שהם מתרחשים. קיצור זמן ההשהיה משפר את העדכניות של הנתונים, אבל פוגע בשלמות שלהם.
הערך WINDOW_END נכתב בטבלה לפני הפריקה, כך שהערך שמשמש את ההצהרה COPY INTO והערך שנכתב בחזרה ב-LAST_EXPORTED זהים. אם נחשב מחדש את השעה הנוכחית בהצהרה השנייה, נדלג על כל מה שקרה ביניהן.
כל עדכון של LAST_EXPORTED פועל אחרי הצהרת COPY INTO משלו. אם הפריקה נכשלת, התהליך נעצר, סימן המים נשאר במקום שבו הוא היה, וההרצה הבאה חוזרת על החלון הזה במקום לדלג עליו.
‫INCLUDE_QUERY_ID = TRUE מוסיף UUID לכל שם קובץ. בלי ההרשאה הזו, הקבצים שלא נטענו נקראים data_0_0_0, וייצוא חוזר לאותו נתיב מתנגש, מה שמתועד ב-Snowflake כמקור לנתונים כפולים בשלב.

תזמון משימת הייצוא

יוצרים ומפעילים את המשימה באופן הבא:
```
CREATE OR REPLACE TASK SECOPS_EXPORT_TASK
    WAREHOUSE = SECOPS_EXPORT_WH
    SCHEDULE = 'USING CRON 0 * * * * UTC'
    AS CALL SECOPS_EXPORT_ACTIVITY();

ALTER TASK SECOPS_EXPORT_TASK RESUME;
```
הערה: המשימות שנוצרות ב-Snowflake מושהות. המשימה לא תפעל עד להפעלה של ALTER TASK ... RESUME.
כדי לוודא שההגדרה תקינה, מריצים את המשימה פעם אחת בלי להמתין למועד שנקבע:
```
EXECUTE TASK SECOPS_EXPORT_TASK;
```

כדי לבדוק את התוצאה של ההרצה ואת הקבצים שהגיעו לשלב, פועלים לפי השלבים הבאים:

SELECT NAME, STATE, ERROR_MESSAGE, SCHEDULED_TIME
FROM TABLE(INFORMATION_SCHEMA.TASK_HISTORY(TASK_NAME => 'SECOPS_EXPORT_TASK'))
ORDER BY SCHEDULED_TIME DESC
LIMIT 5;

LIST @SECOPS_EXPORT_STAGE;

אחזור של חשבון השירות של Google SecOps

מערכת Google SecOps משתמשת בחשבון שירות ייחודי כדי לקרוא נתונים מהקטגוריה של Cloud Storage. אתם צריכים לתת לחשבון השירות הזה גישה לקטגוריה שלכם.

עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמה של SIEM בלבד, עוברים אל הגדרות > פידים.
לוחצים על הוספת פיד חדש.
לוחצים על הגדרת פיד יחיד.
בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Snowflake activity logs).
בוחרים באפשרות Google Cloud Storage V2 בתור סוג המקור.
בוחרים באפשרות Snowflake בתור סוג היומן.
לוחצים על Get Service Account (קבלת חשבון שירות).
תוצג כתובת אימייל ייחודית של חשבון שירות, לדוגמה:
```
chronicle-12345678@chronicle-gcp-prod.iam.gserviceaccount.com
```
מעתיקים את כתובת האימייל הזו כדי להשתמש בה בשלב הבא.

הערה: לכל מכונה של Google SecOps יש חשבון שירות ייחודי. אל תשתמשו בחשבונות שירות ממסמכים או מדוגמאות אחרים.
לוחצים על הבא.
מציינים ערכים לפרמטרים הבאים של הקלט:
- כתובת ה-URL של קטגוריית האחסון: מזינים את ה-URI של קטגוריית Cloud Storage עם נתיב הקידומת:
```
gs://snowflake-activity-logs/snowflake/
```
הערה: תמיד צריך לכלול את הלוכסן (/) בסוף ה-URI.
- אפשרות מחיקת המקור: בוחרים את אפשרות המחיקה המועדפת:
  - אף פעם לא למחוק קבצים: אף פעם לא למחוק קבצים מהמקור (מומלץ לבדיקה).
  - Delete transferred files and empty directories: מחיקת קבצים וספריות ריקות מהמקור אחרי שהאחזור הושלם בהצלחה.
- גיל הקובץ המקסימלי: כולל קבצים ששונו במספר הימים האחרונים (ברירת המחדל היא 180 ימים)
- מרחב השמות של הנכס: מרחב השמות של הנכס
- תוויות הטמעה: התווית שתתווסף לאירועים מהפיד הזה
לוחצים על הבא.
בודקים את הגדרות הפיד החדש במסך סיום ולוחצים על שליחה.

מתן הרשאות IAM לחשבון השירות של Google SecOps

לחשבון השירות של Google SecOps נדרשים שני תפקידים בקטגוריה של Cloud Storage: ‏Storage Object Viewer כדי לקרוא את אובייקטי היומן, ותפקיד ברמת הקטגוריה כדי לקרוא את המטא-נתונים של הקטגוריה.

נכנסים לדף Cloud Storage > Buckets.
לוחצים על שם הקטגוריה.
עוברים לכרטיסייה Permissions.
לוחצים על הענקת גישה.
מזינים את פרטי ההגדרה הבאים:
- Add principals: מדביקים את כתובת האימייל של חשבון השירות של Google SecOps.
- הקצאת תפקידים: בוחרים את שני התפקידים הבאים:
  - צפייה באובייקטים של אחסון: קריאת אובייקטים של יומנים.
  - קריאה בקטגוריה באחסון מדור קודם: קריאת המטא-נתונים של הקטגוריה. אם בחרתם באפשרות המחיקה Delete transferred files and empty directories, בחרו במקום זאת באפשרות Storage Legacy Bucket Writer, שגם מעניקה את הרשאת המחיקה.
לוחצים על Save.

שיטה 2: Amazon S3 V2

השיטה הזו מתאימה אם היומנים צריכים להגיע ל-Amazon S3. הצד של Snowflake זהה, מלבד שילוב האחסון והשלב, כך שההליך והמשימה של הייצוא משיטה 1 משמשים שוב ללא שינוי.

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

יוצרים קטגוריה של Amazon S3 לפי המדריך למשתמש: יצירת קטגוריה.
שומרים את הערכים של Name ו-Region של הקטגוריה לשימוש עתידי. לדוגמה, snowflake-activity-logs.

הגדרת מדיניות Snowflake AWS IAM

נכנסים למסוף הניהול של AWS.
מחפשים את IAM ובוחרים באפשרות הזו.
לוחצים על הגדרות חשבון.
בקטע Security Token Service (STS)‎ ברשימה Endpoints, מאתרים את האזור ב-Snowflake שבו נמצא החשבון.
אם הסטטוס של STS הוא "לא פעיל", מעבירים את המתג למצב פעיל.
לוחצים על כללי מדיניות.
לוחצים על Create Policy.
בעורך המדיניות, בוחרים באפשרות JSON.

מעתיקים ומדביקים את המדיניות הבאה, שמעניקה ל-Snowflake את ההרשאות שנדרשות כדי לפרוק נתונים לקטגוריה אחת ולנתיב תיקייה אחד:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:PutObject",
                "s3:GetObject",
                "s3:GetObjectVersion",
                "s3:DeleteObject",
                "s3:DeleteObjectVersion"
            ],
            "Resource": "arn:aws:s3:::snowflake-activity-logs/snowflake/*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:ListBucket",
                "s3:GetBucketLocation"
            ],
            "Resource": "arn:aws:s3:::snowflake-activity-logs",
            "Condition": {
                "StringLike": {
                    "s3:prefix": [
                        "snowflake/*"
                    ]
                }
            }
        }
    ]
}

לוחצים על הבא.
מזינים שם מדיניות (לדוגמה, snowflake_access) ותיאור (אופציונלי).
לוחצים על יצירת מדיניות.

הגדרת תפקיד AWS IAM ב-Snowflake

ב-IAM, בוחרים באפשרות Roles.
לוחצים על יצירת תפקיד.
בוחרים באפשרות AWS account בתור סוג הישות המהימנה.
בוחרים באפשרות Another AWS account.
בשדה Account ID, מזינים באופן זמני את מזהה החשבון שלכם ב-AWS. בהמשך, אתם משנים את יחסי האמון ונותנים גישה ל-Snowflake.
בוחרים באפשרות דרישת מזהה חיצוני.
מזינים מזהה של פלייסהולדר, למשל 0000. בהמשך תחליפו אותו במזהה החיצוני של שילוב האחסון.
לוחצים על הבא.
בוחרים את מדיניות ה-IAM שיצרתם קודם.
לוחצים על הבא.
מזינים שם ותיאור לתפקיד.
לוחצים על יצירת תפקיד.
בדף סיכום התפקיד, מעתיקים ושומרים את הערך של Role ARN.

יצירת שילוב האחסון של Snowflake ל-Amazon S3

בגיליון עבודה של Snowflake, יוצרים את שילוב האחסון באופן הבא:

USE ROLE ACCOUNTADMIN;

CREATE STORAGE INTEGRATION SECOPS_S3_INT
    TYPE = EXTERNAL_STAGE
    STORAGE_PROVIDER = 'S3'
    ENABLED = TRUE
    STORAGE_AWS_ROLE_ARN = '<IAM_ROLE_ARN>'
    STORAGE_ALLOWED_LOCATIONS = ('s3://snowflake-activity-logs/snowflake/');

GRANT USAGE ON INTEGRATION SECOPS_S3_INT TO ROLE SECOPS_EXPORTER;

מחליפים את <IAM_ROLE_ARN> ב-ARN של התפקיד ששמרתם.

כדי לאחזר את זהות ה-AWS שנוצרה על ידי Snowflake לשילוב, מבצעים את הפעולות הבאות:
```
DESC INTEGRATION SECOPS_S3_INT;
```
מעתיקים ושומרים את הערכים של המאפיינים הבאים:
- STORAGE_AWS_IAM_USER_ARN
- STORAGE_AWS_EXTERNAL_ID

מתן גישה לקטגוריה למשתמש IAM ב-Snowflake

נכנסים ל-AWS Management Console.
בוחרים באפשרות IAM > Roles.
בוחרים את התפקיד שיצרתם קודם.
לוחצים על הכרטיסייה Trust relationships.
לוחצים על Edit trust policy.

מעדכנים את מסמך המדיניות עם ערכי הפלט של DESC INTEGRATION באופן הבא:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Sid": "",
            "Effect": "Allow",
            "Principal": {
                "AWS": "<STORAGE_AWS_IAM_USER_ARN>"
            },
            "Action": "sts:AssumeRole",
            "Condition": {
                "StringEquals": {
                    "sts:ExternalId": "<STORAGE_AWS_EXTERNAL_ID>"
                }
            }
        }
    ]
}

לוחצים על עדכון המדיניות.

יצירת פורמט הקובץ, שלב הייצוא ואובייקטים לייצוא

בגיליון עבודה של Snowflake, יוצרים את פורמט הקובץ ואת השלב שכותב לקטגוריה באופן הבא:

USE ROLE SECOPS_EXPORTER;
USE SCHEMA SECOPS_EXPORT.ACTIVITY;

CREATE OR REPLACE FILE FORMAT SECOPS_JSON_FORMAT
    TYPE = JSON;

CREATE OR REPLACE STAGE SECOPS_EXPORT_STAGE
    URL = 's3://snowflake-activity-logs/snowflake/'
    STORAGE_INTEGRATION = SECOPS_S3_INT
    FILE_FORMAT = SECOPS_JSON_FORMAT;

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

הגדרת AWS IAM ל-Google SecOps

נכנסים למסוף הניהול של AWS.
יוצרים משתמש לפי המדריך למשתמש: יצירת משתמש IAM.
בוחרים את המשתמש שנוצר.
לוחצים על הכרטיסייה פרטי כניסה מאובטחים.
בקטע Access Keys, לוחצים על Create Access Key.
בוחרים באפשרות שירות של צד שלישי בתור תרחיש לדוגמה.
לוחצים על הבא.
אופציונלי: מוסיפים תג תיאור.
לוחצים על יצירת מפתח גישה.
לוחצים על Download .csv file כדי לשמור את Access Key ואת Secret Access Key לשימוש עתידי.
לוחצים על סיום.
לוחצים על הכרטיסייה הרשאות.
בקטע מדיניות הרשאות, לוחצים על הוספת הרשאות.
לוחצים על הוספת הרשאות.
בוחרים באפשרות Attach policies directly.
מחפשים את המדיניות AmazonS3FullAccess ובוחרים בה.
לוחצים על הבא.
לוחצים על הוספת הרשאות.

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

עוברים אל הגדרות > ניהול נתונים > פידים. אם אתם משתמשים בפלטפורמה של SIEM בלבד, עוברים אל הגדרות > פידים.
לוחצים על הוספת פיד חדש.
בדף הבא, לוחצים על הגדרת פיד יחיד.
בשדה שם הפיד, מזינים שם לפיד (לדוגמה, Snowflake activity logs).
בוחרים באפשרות Amazon S3 V2 בתור סוג המקור.
בוחרים באפשרות Snowflake בתור סוג היומן.
לוחצים על הבא.
מציינים ערכים לפרמטרים הבאים של הקלט:
- S3 URI: s3://snowflake-activity-logs/snowflake/
- אפשרות מחיקת מקור: בוחרים את אפשרות המחיקה לפי ההעדפה שלכם.
- גיל הקובץ המקסימלי: כולל קבצים ששונו במספר הימים האחרונים (ברירת המחדל היא 180 ימים)
- מזהה מפתח הגישה: מפתח גישה של משתמש עם גישה לקטגוריית S3
- מפתח גישה סודי: מפתח סודי של משתמש עם גישה לקטגוריית S3
- מרחב השמות של הנכס: מרחב השמות של הנכס
- תוויות הטמעה: התווית שתתווסף לאירועים מהפיד הזה
לוחצים על הבא.
בודקים את הגדרות הפיד החדש במסך סיום ולוחצים על שליחה.

טבלת מיפוי UDM

שדה ביומן	מיפוי UDM	Logic (פונקציה לוגית)
`column4_label`	`additional.fields`	ממוזג
`column7_label`	`additional.fields`	ממוזג
`first_authentication_factor_label`	`additional.fields`	ממוזג
`host_list`	`additional.fields`	ממוזג
`query_text_label`	`additional.fields`	ממוזג
`query_type_label`	`additional.fields`	ממוזג
`roleIds_list`	`additional.fields`	ממוזג
`roleNames_list`	`additional.fields`	ממוזג
`rolecount_label`	`additional.fields`	ממוזג
`user_count_label`	`additional.fields`	ממוזג
`has_principal`	`extensions.auth.type`	מופה: `true` ← `AUTHTYPE_UNSPECIFIED`
`START_TIME`	`metadata.event_timestamp`	נותח בתור `yyyy-MM-dd HH:mm:ss.SSS Z`
`column2`	`metadata.event_timestamp`	נותח בתור `yyyy-MM-dd HH:mm:ss.SSS Z`
`column20`	`metadata.event_timestamp`	נותח בתור `yyyy-MM-dd HH:mm:ss.SSS Z`
`ts`	`metadata.event_timestamp`	נותח בתור `ISO8601`
`event_type`	`metadata.event_type`	מיפוי ישיר
`has_principal`	`metadata.event_type`	מיפוי: `true` ← `NETWORK_CONNECTION`, `true` ← `STATUS_UPDATE`, `true` ← `USER_LOGIN`
`has_principal_user`	`metadata.event_type`	מופה: `true` ← `USER_UNCATEGORIZED`
`column10`	`metadata.product_event_type`	מיפוי ישיר
`QUERY_ID`	`metadata.product_log_id`	מיפוי ישיר
`column1`	`metadata.product_log_id`	מיפוי ישיר
`column6`	`metadata.product_version`	מיפוי ישיר
`SESSION_ID`	`network.http.session_id`	מיפוי ישיר
`RECEIVED_BYTES`	`network.received_bytes`	שינוי שם/מיפוי
`BYTES_SENT_OVER_THE_NETWORK`	`network.sent_bytes`	שינוי שם/מיפוי
`SENT_BYTES`	`network.sent_bytes`	שינוי שם/מיפוי
`APPLICATION`	`principal.application`	מיפוי ישיר
`data.user_name`	`principal.asset.hostname`	מיפוי ישיר
`CLIENT_IP`	`principal.asset.ip`	ממוזג
`IP`	`principal.asset.ip`	ממוזג
`column5`	`principal.asset.ip`	ממוזג
`SOURCE_REGION`	`principal.cloud.availability_zone`	מיפוי ישיר
`SOURCE_CLOUD`	`principal.cloud.environment`	מופו: `(?i)azure` ← `MICROSOFT_AZURE`, `(?i)amazon` ← `AMAZON_WEB_SERVICES`, `(?i)google` ...
`data.user_name`	`principal.hostname`	מיפוי ישיר
`CLIENT_IP`	`principal.ip`	ממוזג
`IP`	`principal.ip`	ממוזג
`column5`	`principal.ip`	ממוזג
`OS`	`principal.platform`	מופו: `(?i)Linux` ← `LINUX`, `(?i)windows` ← `WINDOWS`, `(?i)mac/ios` ← `MAC`
`OS_VERSION`	`principal.platform_version`	מיפוי ישיר
`SOURCE_CLOUD_label`	`principal.resource.attribute.labels`	ממוזג
`roles`	`principal.user.attribute.roles`	ממוזג
`data.role_name`	`principal.user.role_name`	מיפוי ישיר
`column9`	`principal.user.user_display_name`	מיפוי ישיר
`USER_NAME`	`principal.user.userid`	מיפוי ישיר
`column10`	`principal.user.userid`	מיפוי ישיר
`column3`	`principal.user.userid`	מיפוי ישיר
`EXECUTION_STATUS`	`security_result.action`	מופה: `(?i)success` ← `action`, `(?i)fail` ← `security_result_action_block`
`STATUS`	`security_result.action`	מופה: `(?i)success` ← `action`, `(?i)fail` ← `action`
`action`	`security_result.action`	ממוזג
`security_result_action_block`	`security_result.action`	ממוזג
`OCSP_MODE`	`security_result.action_details`	מיפוי ישיר
`column11`	`security_result.action_details`	מיפוי ישיר
`column3`	`security_result.action_details`	מיפוי ישיר
`BYTES_DELETED_label`	`security_result.detection_fields`	ממוזג
`BYTES_READ_FROM_RESULT_label`	`security_result.detection_fields`	ממוזג
`BYTES_SCANNED_label`	`security_result.detection_fields`	ממוזג
`BYTES_SPILLED_TO_LOCAL_STORAGE_label`	`security_result.detection_fields`	ממוזג
`BYTES_SPILLED_TO_REMOTE_STORAGE_label`	`security_result.detection_fields`	ממוזג
`BYTES_WRITTEN_TO_RESULT_label`	`security_result.detection_fields`	ממוזג
`BYTES_WRITTEN_label`	`security_result.detection_fields`	ממוזג
`CHILD_QUERIES_WAIT_TIME_label`	`security_result.detection_fields`	ממוזג
`CLUSTER_NUMBER_label`	`security_result.detection_fields`	ממוזג
`COMPILATION_TIME_label`	`security_result.detection_fields`	ממוזג
`CREDITS_USED_CLOUD_SERVICES_label`	`security_result.detection_fields`	ממוזג
`DATABASE_ID_label`	`security_result.detection_fields`	ממוזג
`DATABASE_NAME_label`	`security_result.detection_fields`	ממוזג
`END_TIME_label`	`security_result.detection_fields`	ממוזג
`ERROR_MESSAGE_label`	`security_result.detection_fields`	ממוזג
`EXECUTION_TIME_label`	`security_result.detection_fields`	ממוזג
`EXTERNAL_FUNCTION_TOTAL_INVOCATIONS_label`	`security_result.detection_fields`	ממוזג
`EXTERNAL_FUNCTION_TOTAL_RECEIVED_BYTES_label`	`security_result.detection_fields`	ממוזג
`EXTERNAL_FUNCTION_TOTAL_RECEIVED_ROWS_label`	`security_result.detection_fields`	ממוזג
`EXTERNAL_FUNCTION_TOTAL_SENT_BYTES_label`	`security_result.detection_fields`	ממוזג
`EXTERNAL_FUNCTION_TOTAL_SENT_ROWS_label`	`security_result.detection_fields`	ממוזג
`INBOUND_DATA_TRANSFER_BYTES_label`	`security_result.detection_fields`	ממוזג
`IS_CLIENT_GENERATED_STATEMENT_label`	`security_result.detection_fields`	ממוזג
`LIST_EXTERNAL_FILES_TIME_label`	`security_result.detection_fields`	ממוזג
`OUTBOUND_DATA_TRANSFER_BYTES_label`	`security_result.detection_fields`	ממוזג
`PARTITIONS_SCANNED_label`	`security_result.detection_fields`	ממוזג
`PARTITIONS_TOTAL_label`	`security_result.detection_fields`	ממוזג
`PERCENTAGE_SCANNED_FROM_CACHE_label`	`security_result.detection_fields`	ממוזג
`QUERY_ACCELERATION_BYTES_SCANNED_label`	`security_result.detection_fields`	ממוזג
`QUERY_ACCELERATION_PARTITIONS_SCANNED_label`	`security_result.detection_fields`	ממוזג
`QUERY_ACCELERATION_UPPER_LIMIT_SCALE_FACTOR_label`	`security_result.detection_fields`	ממוזג
`QUERY_HASH_VERSION_label`	`security_result.detection_fields`	ממוזג
`QUERY_HASH_label`	`security_result.detection_fields`	ממוזג
`QUERY_LOAD_PERCENT_label`	`security_result.detection_fields`	ממוזג
`QUERY_PARAMETERIZED_HASH_VERSION_label`	`security_result.detection_fields`	ממוזג
`QUERY_TAG_label`	`security_result.detection_fields`	ממוזג
`QUERY_TYPE_label`	`security_result.detection_fields`	ממוזג
`QUEUED_OVERLOAD_TIME_label`	`security_result.detection_fields`	ממוזג
`QUEUED_PROVISIONING_TIME_label`	`security_result.detection_fields`	ממוזג
`QUEUED_REPAIR_TIME_label`	`security_result.detection_fields`	ממוזג
`RELEASE_VERSION_label`	`security_result.detection_fields`	ממוזג
`ROLE_TYPE_label`	`security_result.detection_fields`	ממוזג
`ROWS_DELETED_label`	`security_result.detection_fields`	ממוזג
`ROWS_INSERTED_label`	`security_result.detection_fields`	ממוזג
`ROWS_PRODUCED_label`	`security_result.detection_fields`	ממוזג
`ROWS_UNLOADED_label`	`security_result.detection_fields`	ממוזג
`ROWS_UPDATED_label`	`security_result.detection_fields`	ממוזג
`ROWS_WRITTEN_TO_RESULT_label`	`security_result.detection_fields`	ממוזג
`SCHEMA_ID_label`	`security_result.detection_fields`	ממוזג
`SCHEMA_NAME_label`	`security_result.detection_fields`	ממוזג
`TOTAL_ELAPSED_TIME_label`	`security_result.detection_fields`	ממוזג
`TRANSACTION_BLOCKED_TIME_label`	`security_result.detection_fields`	ממוזג
`TRANSACTION_ID_label`	`security_result.detection_fields`	ממוזג
`WAREHOUSE_ID_label`	`security_result.detection_fields`	ממוזג
`WAREHOUSE_NAME_label`	`security_result.detection_fields`	ממוזג
`WAREHOUSE_SIZE_label`	`security_result.detection_fields`	ממוזג
`WAREHOUSE_TYPE_label`	`security_result.detection_fields`	ממוזג
`authentication_factor_label`	`security_result.detection_fields`	ממוזג
`column4_label`	`security_result.detection_fields`	ממוזג
`column6_label`	`security_result.detection_fields`	ממוזג
`column7_label`	`security_result.detection_fields`	ממוזג
`column8_label`	`security_result.detection_fields`	ממוזג
`event_id_label`	`security_result.detection_fields`	ממוזג
`event_type_label`	`security_result.detection_fields`	ממוזג
`is_success_label`	`security_result.detection_fields`	ממוזג
`python_compiler_label`	`security_result.detection_fields`	ממוזג
`python_runtime_label`	`security_result.detection_fields`	ממוזג
`python_version_label`	`security_result.detection_fields`	ממוזג
`reported_client_type_label`	`security_result.detection_fields`	ממוזג
`reported_client_version_label`	`security_result.detection_fields`	ממוזג
`tracing_label`	`security_result.detection_fields`	ממוזג
`EXECUTION_STATUS`	`security_result.summary`	מיפוי ישיר
`STATUS`	`security_result.summary`	מיפוי ישיר
`column17`	`security_result.summary`	מיפוי ישיר
`TARGET_REGION`	`target.cloud.availability_zone`	מיפוי ישיר
`TARGET_CLOUD`	`target.cloud.environment`	מופו: `(?i)azure` ← `MICROSOFT_AZURE`, `(?i)amazon` ← `AMAZON_WEB_SERVICES`, `(?i)google` ...
`TARGET_CLOUD_label`	`target.resource.attribute.labels`	ממוזג
`column2_label`	`target.resource.attribute.labels`	ממוזג
`column7_label`	`target.resource.attribute.labels`	ממוזג
`USER_NAME`	`target.user.userid`	מיפוי ישיר
`column4`	`target.user.userid`	מיפוי ישיר
לא רלוונטי	`extensions.auth.type`	קבוע: `AUTHTYPE_UNSPECIFIED`
לא רלוונטי	`metadata.event_type`	קבוע: `NETWORK_CONNECTION`
לא רלוונטי	`metadata.product_name`	קבוע: `SNOWFLAKE`
לא רלוונטי	`metadata.vendor_name`	קבוע: `SNOWFLAKE`
לא רלוונטי	`principal.cloud.environment`	קבוע: `MICROSOFT_AZURE`
לא רלוונטי	`principal.platform`	קבוע: `LINUX`
לא רלוונטי	`target.cloud.environment`	קבוע: `MICROSOFT_AZURE`

יומן שינויים

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

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