Collecter les journaux Snowflake

Compatible avec :

Google SecOps SIEM

Ce document explique comment ingérer des journaux Snowflake dans Google Security Operations. Vous pouvez configurer l'ingestion de deux manières : Cloud Storage V2 (recommandé) ou Amazon S3 V2. Les deux méthodes utilisent le même mécanisme côté Snowflake : une tâche planifiée décharge les données d'utilisation du compte vers une zone de préparation externe, et Google SecOps lit les fichiers exportés avec un flux.

Snowflake est une plate-forme de données cloud qui stocke l'activité du compte dans le schéma SNOWFLAKE.ACCOUNT_USAGE. La vue LOGIN_HISTORY enregistre les tentatives d'authentification, y compris l'adresse IP client, le facteur d'authentification et la raison de l'échec. La vue QUERY_HISTORY enregistre chaque instruction exécutée dans le compte, y compris l'utilisateur, le rôle, l'entrepôt et les objets concernés.

Remarque : Une étiquette d'ingestion identifie l'analyseur qui normalise les données de journaux brutes au format UDM structuré. Les informations contenues dans ce document s'appliquent à l'analyseur avec l'étiquette d'ingestion SNOWFLAKE.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

• Une instance Google SecOps
• Accès à Snowflake avec un rôle permettant de créer des intégrations de stockage (seul ACCOUNTADMIN dispose de ce droit par défaut), des bases de données, des entrepôts, des zones de préproduction et des tâches
• Pour Cloud Storage V2 : un projet Google Cloud avec l'API Cloud Storage activée, et les autorisations nécessaires pour créer des buckets, créer des rôles Identity and Access Management (IAM) et gérer les stratégies IAM des buckets
• Pour Amazon S3 V2 : accès privilégié à AWS pour créer des buckets S3, des stratégies IAM, des rôles IAM et des utilisateurs IAM

Accorder l'accès aux données d'utilisation du compte Snowflake

Les vues SNOWFLAKE.ACCOUNT_USAGE ne sont lisibles par ACCOUNTADMIN que si l'accès est explicitement accordé. Créez un rôle dédié à l'exportation et attribuez-lui les deux rôles de base de données qui couvrent les vues exportées par ce document.

1. Connectez-vous à Snowflake et ouvrez une feuille de calcul.

2. Créez le rôle d'exportation et accordez-lui un accès en lecture aux vues d'utilisation du compte comme suit :

   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;
   

   Remarque : SNOWFLAKE.SECURITY_VIEWER couvre LOGIN_HISTORY et SNOWFLAKE.GOVERNANCE_VIEWER couvre QUERY_HISTORY. L'attribution de IMPORTED PRIVILEGES ON DATABASE SNOWFLAKE fonctionne également, mais elle expose l'ensemble du schéma, y compris les données au niveau de l'organisation. Privilégiez donc les deux rôles de base de données.

3. Créez la base de données, le schéma et l'entrepôt utilisés par l'exportation, puis accordez-les au rôle comme suit :

   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>;
   

   • Remplacez <YOUR_USER> par l'utilisateur Snowflake propriétaire de l'exportation.

Méthode 1 : Cloud Storage V2 (recommandé)

Créer un bucket Cloud Storage

1. Accédez à la consoleGoogle Cloud .
2. Sélectionnez votre projet ou créez-en un.
3. Dans le menu de navigation, accédez à Cloud Storage > Buckets.
4. Cliquez sur Créer un bucket.

5. Fournissez les informations de configuration suivantes :

   Paramètre	Valeur
   Attribuez un nom au bucket	Saisissez un nom unique (par exemple, snowflake-activity-logs).
   Type d'emplacement	Choisissez celle qui correspond le mieux à vos besoins (régionale, birégionale ou multirégionale).
   Emplacement	Sélectionnez l'emplacement (par exemple, us-central1).
   Classe de stockage	Standard (recommandé pour les journaux fréquemment consultés)
   Access control (Contrôle des accès)	Uniforme (recommandé)
   Outils de protection	Facultatif : Activez la gestion des versions d'objets ou la règle de conservation.

6. Cliquez sur Créer.

Créer un rôle Cloud Storage personnalisé pour Snowflake

1. Dans la console Google Cloud , accédez à IAM et administration > Rôles.
2. Cliquez sur Créer un rôle.
3. Fournissez les informations de configuration suivantes :
   • Titre : saisissez Snowflake Unload.
   • ID : saisissez snowflake_unload.
   • Étape de lancement du rôle : sélectionnez Disponibilité générale.
4. Cliquez sur Ajouter des autorisations, puis ajoutez les autorisations suivantes :
   • storage.buckets.get
   • storage.objects.create
   • storage.objects.delete
   • storage.objects.list

5. Cliquez sur Créer.

   Remarque : Il s'agit de l'ensemble d'autorisations que Snowflake documente pour le déchargement des données. Le chargement de données dans Snowflake nécessite également storage.objects.get, ce dont cette intégration n'a pas besoin.

Créer l'intégration de stockage Snowflake pour Cloud Storage

1. Dans une feuille de calcul Snowflake, créez l'intégration de stockage comme suit :

   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;
   

   • Remplacez snowflake-activity-logs par le nom de votre bucket.

2. Récupérez le compte de service que Snowflake a créé pour l'intégration comme suit :

   DESC STORAGE INTEGRATION SECOPS_GCS_INT;
   

3. Copiez la valeur de la propriété STORAGE_GCP_SERVICE_ACCOUNT. La valeur a le format suivant :

   [e-mail]
   

   Remarque : Snowflake crée un compte de service pour l'ensemble du compte Snowflake. Par conséquent, chaque intégration de stockage Cloud Storage du compte utilise la même valeur.

Accorder au compte de service Snowflake l'accès au bucket

1. Dans la console Google Cloud , accédez à Cloud Storage > Buckets.
2. Cliquez sur le bucket que vous avez créé (par exemple, snowflake-activity-logs).
3. Accédez à l'onglet Autorisations.
4. Cliquez sur Accorder l'accès.
5. Fournissez les informations de configuration suivantes :
   • Ajouter des comptes principaux : collez la valeur STORAGE_GCP_SERVICE_ACCOUNT.
   • Attribuer des rôles : sélectionnez Snowflake Unload.
6. Cliquez sur Enregistrer.

Créer le format de fichier et la zone de préparation externe

1. Dans une feuille de calcul Snowflake, créez le format de fichier et l'étape qui écrit dans le bucket comme suit :

   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;
   

   Remarque : Snowflake compresse par défaut les fichiers déchargés avec gzip. Le bucket reçoit donc des objets .json.gz. Le flux les décompresse lors de l'ingestion.

Créer la table d'état d'exportation

L'exportation suit la progression de la lecture dans chaque vue. Sans ce filigrane, chaque exécution réexporterait l'intégralité de la vue, et les mêmes événements seraient ingérés à nouveau.

1. Créez la table d'état et alimentez-la comme suit :

   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());
   

   Remarque : Les valeurs de graine déterminent la quantité d'historique exportée lors de la première exécution. Les vues d'utilisation du compte conservent 365 jours de données. Un remplissage plus important est donc possible, au prix d'une première exportation volumineuse. Exécutez l'instruction INSERT une fois. Si vous l'exécutez à nouveau, des lignes en double sont ajoutées et l'exportation cesse de progresser correctement.

Créer la procédure d'exportation

1. Créez la procédure qui décharge les deux vues et fait avancer le filigrane comme suit :

   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;
   $$;
   

Chaque élément de la procédure existe pour une raison :

• La fenêtre se ferme trois heures après l'heure actuelle. Snowflake remplit LOGIN_HISTORY avec une latence pouvant atteindre deux heures et QUERY_HISTORY avec une latence pouvant atteindre 45 minutes. Par conséquent, une fenêtre qui se termine maintenant ignorerait les lignes que la vue n'a pas encore matérialisées. Les événements parviennent donc à Google SecOps environ trois heures après leur survenue. Réduire le délai d'attente permet d'obtenir des données plus récentes, mais moins complètes.
• WINDOW_END est écrit dans la table avant le déchargement. Ainsi, la valeur utilisée par l'instruction COPY INTO et la valeur réécrite dans LAST_EXPORTED sont identiques. Le recalcul de l'heure actuelle dans la deuxième instruction ignorerait tout ce qui s'est passé entre-temps.
• Chaque mise à jour LAST_EXPORTED s'exécute après sa propre instruction COPY INTO. Si un déchargement échoue, la procédure s'arrête, le filigrane reste là où il était et l'exécution suivante répète cette fenêtre au lieu de l'ignorer.
• INCLUDE_QUERY_ID = TRUE ajoute un UUID à chaque nom de fichier. Sans cela, les fichiers déchargés sont nommés data_0_0_0 et les exportations répétées vers le même chemin entrent en conflit, ce que Snowflake documente comme une source de données dupliquées dans l'étape.

Planifier la tâche d'exportation

1. Créez et démarrez la tâche comme suit :

   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;
   

   Remarque : Snowflake crée des tâches à l'état suspendu. La tâche ne s'exécute pas tant que ALTER TASK ... RESUME n'est pas exécuté.

2. Exécutez la tâche une fois pour vérifier la configuration sans attendre la planification, comme suit :

   EXECUTE TASK SECOPS_EXPORT_TASK;
   

3. Vérifiez le résultat de l'exécution et les fichiers qui ont atteint l'étape comme suit :

   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;
   

Récupérer le compte de service Google SecOps

Google SecOps utilise un compte de service unique pour lire les données de votre bucket Cloud Storage. Vous devez accorder à ce compte de service l'accès à votre bucket.

1. Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
2. Cliquez sur Ajouter un flux d'actualités.
3. Cliquez sur Configurer un flux unique.
4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Snowflake activity logs).
5. Sélectionnez Google Cloud Storage V2 comme Type de source.
6. Sélectionnez Snowflake comme Type de journal.
7. Cliquez sur Get Service Account (Obtenir un compte de service).

8. Une adresse e-mail de compte de service unique s'affiche, par exemple :

   [e-mail]
   

9. Copiez cette adresse e-mail pour l'utiliser à l'étape suivante.

   Remarque : Chaque instance Google SecOps possède un compte de service unique. N'utilisez pas de comptes de service provenant d'autres documentations ou exemples.

10. Cliquez sur Suivant.

11. Spécifiez les valeurs des paramètres d'entrée suivants :

    • URL du bucket de stockage : saisissez l'URI du bucket Cloud Storage avec le chemin d'accès du préfixe :

      gs://snowflake-activity-logs/snowflake/
      

    Remarque : Incluez toujours la barre oblique finale (/) à la fin de l'URI.

    • Option de suppression de la source : sélectionnez l'option de suppression de votre choix :

      • Ne jamais supprimer les fichiers : ne supprime jamais les fichiers de la source (recommandé pour les tests).
      • Supprimer les fichiers transférés et les répertoires vides : supprimez les fichiers et les répertoires vides de la source une fois la récupération terminée.

    • Âge maximal du fichier : incluez les fichiers modifiés au cours d'un certain nombre de jours (180 jours par défaut).

    • Espace de noms de l'élément : espace de noms de l'élément

    • Étiquettes d'ingestion : étiquette à appliquer aux événements de ce flux.

12. Cliquez sur Suivant.

13. Vérifiez la configuration de votre nouveau flux d'actualités sur l'écran Finaliser, puis cliquez sur Envoyer.

Accorder des autorisations IAM au compte de service Google SecOps

Le compte de service Google SecOps a besoin de deux rôles sur votre bucket Cloud Storage : Storage Object Viewer pour lire les objets de journal et un rôle au niveau du bucket pour lire les métadonnées du bucket.

1. Accédez à Cloud Storage > Buckets.
2. Cliquez sur le nom de votre bucket.
3. Accédez à l'onglet Autorisations.
4. Cliquez sur Accorder l'accès.
5. Fournissez les informations de configuration suivantes :
   • Ajouter des comptes principaux : collez l'adresse e-mail du compte de service Google SecOps.
   • Attribuer des rôles : sélectionnez les deux rôles suivants :
     • Lecteur des objets de l'espace de stockage : lit les objets de journal.
     • Lecteur des anciens buckets Storage : lit les métadonnées du bucket. Si vous avez sélectionné l'option de suppression Supprimer les fichiers transférés et les répertoires vides, sélectionnez plutôt Rédacteur d'ancien bucket Storage, qui accorde également l'autorisation de suppression.
6. Cliquez sur Enregistrer.

Remarque : Attribuez les deux rôles. Storage Object Viewer n'accorde pas l'autorisation au niveau du bucket dont le flux a besoin, et les rôles Storage Legacy Bucket n'accordent pas l'autorisation de lire le contenu des objets.

Méthode 2 : Amazon S3 V2

Utilisez cette méthode lorsque les journaux doivent être stockés dans Amazon S3. La partie Snowflake est identique, à l'exception de l'intégration du stockage et de la zone de préparation. La procédure et la tâche d'exportation de la méthode 1 sont donc réutilisées sans modification.

Configurer un bucket Amazon S3

1. Créez un bucket Amazon S3 en suivant ce guide de l'utilisateur : Créer un bucket.
2. Enregistrez le nom et la région du bucket pour référence ultérieure. Par exemple, snowflake-activity-logs.

Configurer la stratégie IAM AWS Snowflake

1. Connectez-vous à AWS Management Console.
2. Recherchez et sélectionnez IAM.
3. Sélectionnez Paramètres du compte.
4. Sous Security Token Service (STS) dans la liste Endpoints, recherchez la région Snowflake où se trouve votre compte.
5. Si l'état du STS est inactif, activez le bouton Actif.
6. Sélectionnez Règles.
7. Cliquez sur Créer une règle.
8. Dans Éditeur de règles, sélectionnez JSON.

9. Copiez et collez la stratégie suivante, qui accorde à Snowflake les autorisations nécessaires pour décharger des données dans un bucket et un chemin d'accès au dossier :

   {
       "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/*"
                       ]
                   }
               }
           }
       ]
   }
   

10. Cliquez sur Suivant.

11. Saisissez un nom de règle (par exemple, snowflake_access) et une description facultative.

12. Cliquez sur Créer une règle.

Configurer le rôle IAM AWS Snowflake

1. Dans IAM, sélectionnez Rôles.
2. Cliquez sur Créer un rôle.
3. Sélectionnez Compte AWS comme type d'entité de confiance.
4. Sélectionnez Autre compte AWS.
5. Dans le champ ID de compte, saisissez temporairement votre propre ID de compte AWS. Vous modifierez la relation d'approbation ultérieurement et accorderez l'accès à Snowflake.
6. Sélectionnez l'option Exiger un ID externe.
7. Saisissez un ID d'espace réservé, tel que 0000. Vous le remplacerez ultérieurement par l'ID externe de l'intégration de stockage.
8. Cliquez sur Suivant.
9. Sélectionnez la stratégie IAM que vous avez créée précédemment.
10. Cliquez sur Suivant.
11. Saisissez un nom et une description.
12. Cliquez sur Créer un rôle.
13. Sur la page de résumé du rôle, copiez et enregistrez la valeur Role ARN (ARN du rôle).

Créer l'intégration de stockage Snowflake pour Amazon S3

1. Dans une feuille de calcul Snowflake, créez l'intégration de stockage comme suit :

   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;
   

   • Remplacez <IAM_ROLE_ARN> par l'ARN du rôle que vous avez enregistré.

2. Récupérez l'identité AWS créée par Snowflake pour l'intégration comme suit :

   DESC INTEGRATION SECOPS_S3_INT;
   

3. Copiez et enregistrez les valeurs des propriétés suivantes comme suit :

   • STORAGE_AWS_IAM_USER_ARN
   • STORAGE_AWS_EXTERNAL_ID

Accorder à l'utilisateur IAM Snowflake l'accès au bucket

1. Accédez à AWS Management Console.
2. Sélectionnez IAM > Rôles.
3. Sélectionnez le rôle que vous avez créé précédemment.
4. Sélectionnez l'onglet Relations d'approbation.
5. Cliquez sur Modifier la règle d'approbation.

6. Mettez à jour le document de stratégie avec les valeurs de sortie DESC INTEGRATION comme suit :

   {
       "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>"
                   }
               }
           }
       ]
   }
   

7. Cliquez sur Mettre à jour la stratégie.

Créer le format de fichier, la zone de préproduction et les objets d'exportation

1. Dans une feuille de calcul Snowflake, créez le format de fichier et l'étape qui écrit dans le bucket comme suit :

   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;
   

2. Créez la table d'état, la procédure et la tâche exactement comme décrit dans la méthode 1, dans les sections Créer la table d'état d'exportation, Créer la procédure d'exportation et Planifier la tâche d'exportation. Les instructions font référence à l'étape par son nom. Elles n'ont donc pas besoin d'être modifiées.

Configurer AWS IAM pour Google SecOps

1. Connectez-vous à AWS Management Console.
2. Créez un utilisateur en suivant ce guide de l'utilisateur : Créer un utilisateur IAM.
3. Sélectionnez l'utilisateur créé.
4. Sélectionnez l'onglet Identifiants de sécurité.
5. Cliquez sur Create Access Key (Créer une clé d'accès) dans la section Access Keys (Clés d'accès).
6. Sélectionnez Service tiers comme Cas d'utilisation.
7. Cliquez sur Suivant.
8. Facultatif : ajoutez un tag de description.
9. Cliquez sur Créer une clé d'accès.
10. Cliquez sur Download .csv file (Télécharger le fichier .csv) pour enregistrer la clé d'accès et la clé d'accès secrète pour référence ultérieure.
11. Cliquez sur OK.
12. Sélectionnez l'onglet Autorisations.
13. Cliquez sur Ajouter des autorisations dans la section Stratégies d'autorisation.
14. Sélectionnez Ajouter des autorisations.
15. Sélectionnez Associer directement des stratégies.
16. Recherchez et sélectionnez la règle AmazonS3FullAccess.
17. Cliquez sur Suivant.
18. Cliquez sur Ajouter des autorisations.

Configurer un flux dans Google SecOps pour ingérer les journaux Snowflake

1. Accédez à Paramètres > Gestion des données > Flux. Si vous utilisez une plate-forme SIEM uniquement, accédez à Paramètres > Flux.
2. Cliquez sur Ajouter un flux d'actualités.
3. Sur la page suivante, cliquez sur Configurer un seul flux.
4. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Snowflake activity logs).
5. Sélectionnez Amazon S3 V2 comme Type de source.
6. Sélectionnez Snowflake comme Type de journal.
7. Cliquez sur Suivant.

8. Spécifiez les valeurs des paramètres d'entrée suivants :

   • URI S3 : s3://snowflake-activity-logs/snowflake/
   • Option de suppression de la source : sélectionnez l'option de suppression de votre choix.
   • Âge maximal du fichier : incluez les fichiers modifiés au cours d'un certain nombre de jours (180 jours par défaut).
   • ID de clé d'accès : clé d'accès utilisateur permettant d'accéder au bucket S3.
   • Clé d'accès secrète : clé secrète de l'utilisateur ayant accès au bucket S3.
   • Espace de noms de l'élément : espace de noms de l'élément
   • Étiquettes d'ingestion : étiquette à appliquer aux événements de ce flux.

9. Cliquez sur Suivant.

10. Vérifiez la configuration de votre nouveau flux d'actualités sur l'écran Finaliser, puis cliquez sur Envoyer.

Table de mappage UDM

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

Journal des modifications

Afficher le journal des modifications de cet analyseur

Vous avez encore besoin d'aide ? Obtenez des réponses de membres de la communauté et de professionnels Google SecOps.