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 à l'aide de deux méthodes : Cloud Storage V2 (recommandée) 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 un emplacement 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 du 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 de ce document s'appliquent au parseur avec le libellé 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éparation et des tâches
• Pour Cloud Storage V2 : un projet Google Cloud avec l'API Cloud Storage activée, ainsi que les autorisations permettant de créer des buckets, des rôles Identity and Access Management (IAM) et de 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 jusqu'à ce que l'accès soit explicitement accordé. Créez un rôle dédié à l'exportation et accordez-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 l'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. Vous pouvez également accorder IMPORTED PRIVILEGES ON DATABASE SNOWFLAKE, mais cela expose l'ensemble du schéma, y compris les données au niveau de l'organisation. Il est donc préférable d'utiliser 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-leur le 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ée)

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 en fonction de vos besoins (région, birégion, multirégion).
   Emplacement	Sélectionnez l'emplacement (par exemple, us-central1).
   Classe de stockage	Standard (recommandé pour les journaux auxquels vous accédez fréquemment)
   Access control (Contrôle des accès)	Uniforme (recommandé)
   Outils de protection	Facultatif : Activez la gestion des versions des 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, dont cette intégration n'a pas besoin.

Créer l'intégration du 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 :

   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 dans le 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 la zone de préparation 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 les fichiers déchargés avec gzip par défaut. Le bucket reçoit donc des objets .json.gz. Le flux les décompresse lors de l'ingestion.

Créer la table d'état des exportations

L'exportation indique la distance parcourue 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 initialisez-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 départ déterminent l'historique exporté lors de la première exécution. Les vues de l'utilisation du compte conservent les données pendant 365 jours. Il est donc possible d'effectuer un remplissage plus important, mais cela entraînera une première exportation volumineuse. Exécutez l'instruction INSERT une seule fois. Si vous l'exécutez à nouveau, des lignes en double sont ajoutées et l'exportation ne progresse plus 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 précise :

• La fenêtre se ferme trois heures après l'heure actuelle. Snowflake remplit LOGIN_HISTORY avec une latence maximale de deux heures et QUERY_HISTORY avec une latence maximale de 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. En réduisant le décalage, vous privilégiez la fraîcheur à l'exhaustivité.
• WINDOW_END est écrit dans la table avant le déchargement. La valeur utilisée par l'instruction COPY INTO et la valeur réécrite dans LAST_EXPORTED sont donc identiques. Si vous recalculiez l'heure actuelle dans la deuxième instruction, vous ignoreriez tout ce qui s'est passé entre-temps.
• Chaque mise à jour de 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 à sa place et la prochaine exécution répète cette fenêtre au lieu de la passer.
• 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 d'accès entrent en conflit, ce que Snowflake documente comme une source de données en double dans la zone de préparation.

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 que lorsque ALTER TASK ... RESUME est exécuté.

2. Exécutez la tâche une fois pour vérifier la configuration sans attendre la programmation :

   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 SIEM> Flux.
2. Cliquez sur Ajouter un flux.
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 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 documents 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 au préfixe :

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

    Remarque : Incluez toujours la barre oblique (/) à 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 supprimez jamais les fichiers de la source (recommandé pour les tests).
      • Supprimer les fichiers transférés et les répertoires vides : supprime les fichiers et les répertoires vides de la source une fois l'extraction réussie.

    • Âge maximal du fichier : incluez les fichiers modifiés au cours des derniers jours (180 jours par défaut).

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

    • Libellés d'ingestion : libellé à appliquer aux événements de ce flux

12. Cliquez sur Suivant.

13. Vérifiez la configuration de votre nouveau flux 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 journaux 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 Storage : lit les objets journaux.
     • 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 de bucket Storage hérité, qui accorde également l'autorisation de suppression.
6. Cliquez sur Enregistrer.

Remarque : Accordez 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. Le côté 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 Points de terminaison, recherchez la région Snowflake où se trouve votre compte.
5. Si l'état du STS est "Inactif", basculez sur Actif.
6. Sélectionnez Règles.
7. Cliquez sur Créer une règle.
8. Dans l'éditeur de règles, sélectionnez JSON.

9. Copiez et collez le règlement suivant, qui accorde à Snowflake les autorisations dont il a besoin pour décharger les 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 la règle (par exemple, snowflake_access) et ajoutez éventuellement une description.

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

Configurer le rôle Snowflake AWS IAM

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 modifiez la relation de confiance ultérieurement et accordez 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 règle 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 récapitulative du rôle, copiez et enregistrez la valeur 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 que Snowflake a créée pour l'intégration comme suit :

   DESC INTEGRATION SECOPS_S3_INT;
   

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

   • STORAGE_AWS_IAM_USER_ARN
   • STORAGE_AWS_EXTERNAL_ID

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

1. Accédez à la console de gestion AWS.
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 règles avec les valeurs de résultat 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, préparer et exporter des objets

1. Dans une feuille de calcul Snowflake, créez le format de fichier et la zone de préparation 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. Aucune modification n'est donc nécessaire.

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 Créer une clé d'accès dans la section 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 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 Règles d'autorisation.
14. Sélectionnez Ajouter des autorisations.
15. Sélectionnez Associer directement les règles.
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 SIEM> Flux.
2. Cliquez sur Ajouter un flux.
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 des derniers jours (180 jours par défaut).
   • ID de clé d'accès : clé d'accès utilisateur ayant accès 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
   • Libellés d'ingestion : libellé à appliquer aux événements de ce flux

9. Cliquez sur Suivant.

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

Table de mappage UDM

Champ de 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	Mappé directement
has_principal	metadata.event_type	Mappé : true → NETWORK_CONNECTION, true → STATUS_UPDATE, true → USER_LOGIN
has_principal_user	metadata.event_type	Mappé : true → USER_UNCATEGORIZED
column10	metadata.product_event_type	Mappé directement
QUERY_ID	metadata.product_log_id	Mappé directement
column1	metadata.product_log_id	Mappé directement
column6	metadata.product_version	Mappé directement
SESSION_ID	network.http.session_id	Mappé directement
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	Mappé directement
data.user_name	principal.asset.hostname	Mappé directement
CLIENT_IP	principal.asset.ip	Fusionné
IP	principal.asset.ip	Fusionné
column5	principal.asset.ip	Fusionné
SOURCE_REGION	principal.cloud.availability_zone	Mappé directement
SOURCE_CLOUD	principal.cloud.environment	Mappé : (?i)azure → MICROSOFT_AZURE, (?i)amazon → AMAZON_WEB_SERVICES, (?i)google…
data.user_name	principal.hostname	Mappé directement
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	Mappé directement
SOURCE_CLOUD_label	principal.resource.attribute.labels	Fusionné
roles	principal.user.attribute.roles	Fusionné
data.role_name	principal.user.role_name	Mappé directement
column9	principal.user.user_display_name	Mappé directement
USER_NAME	principal.user.userid	Mappé directement
column10	principal.user.userid	Mappé directement
column3	principal.user.userid	Mappé directement
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	Mappé directement
column11	security_result.action_details	Mappé directement
column3	security_result.action_details	Mappé directement
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	Mappé directement
STATUS	security_result.summary	Mappé directement
column17	security_result.summary	Mappé directement
TARGET_REGION	target.cloud.availability_zone	Mappé directement
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	Mappé directement
column4	target.user.userid	Mappé directement
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 pour ce parseur

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