Nous avons réorganisé la structure de navigation de notre documentation pour l'aligner directement sur vos workflows opérationnels. Pour en savoir plus, consultez les notes de version et la vidéo de présentation.

Google utilise la technologie IA pour traduire le contenu dans votre langue préférée. Les traductions générées par IA peuvent contenir des erreurs.

Collecter les journaux Tailscale

Compatible avec :

Google secops SIEM

Ce document explique comment ingérer des journaux Tailscale dans Google Security Operations à l'aide de la fonctionnalité native de diffusion de journaux Amazon S3 de Tailscale. Tailscale génère des données opérationnelles sous forme de journaux d'audit de configuration et de journaux de flux réseau. Cette intégration utilise la fonctionnalité de diffusion S3 intégrée de Tailscale pour envoyer automatiquement ces journaux à Google SecOps à des fins d'analyse et de surveillance.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

Instance Google SecOps
Accès privilégié à la console d'administration Tailscale (rôle de propriétaire, d'administrateur, d'administrateur réseau ou d'administrateur informatique)
Accès privilégié à AWS (S3, IAM)

Collecter les prérequis Tailscale (informations sur le tailnet)

Connectez-vous à la console d'administration Tailscale.
Notez le nom de votre tailnet (par exemple, example.com ou le nom de votre organisation).
Assurez-vous de disposer du forfait requis :
- Diffusion des journaux d'audit de configuration : disponible avec les forfaits Personal, Personal Plus et Enterprise.
- Diffusion des journaux de flux réseau : disponible uniquement avec le forfait Enterprise.

Configurer le bucket AWS S3 et IAM pour Google SecOps

Créez un bucket Amazon S3 en suivant ce guide de l'utilisateur : Créer un bucket
Enregistrez le nom et la région du bucket pour référence ultérieure (par exemple, tailscale-logs).
Créez un utilisateur en suivant ce guide de l'utilisateur : Créer un utilisateur IAM.
Sélectionnez l'utilisateur créé.
Sélectionnez l'onglet Security credentials (Identifiants de sécurité).
Cliquez sur Create Access Key (Créer une clé d'accès) dans la section Access Keys (Clés d'accès).
Sélectionnez Third-party service (Service tiers) comme Use case (Cas d'utilisation).
Cliquez sur Suivant.
Facultatif : ajoutez un tag de description.
Cliquez sur Create access key (Créer une clé d'accès).
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 en vue d'une utilisation ultérieure.
Cliquez sur OK.
Sélectionnez l'onglet Autorisations.
Cliquez sur Add permissions (Ajouter des autorisations) dans la section Permissions policies (Règles d'autorisations).
Sélectionnez Add permissions (Ajouter des autorisations).
Sélectionnez Attach policies directly (Joindre directement des règles).
Recherchez et sélectionnez la règle AmazonS3FullAccess.
Cliquez sur Suivant.
Cliquez sur Add permissions (Ajouter des autorisations).

Configurer la règle et le rôle IAM pour les importations S3

Dans la console AWS, accédez à IAM > Policies > Create policy > JSON tab (IAM > Règles > Créer une règle > Onglet JSON).

Saisissez la règle suivante :

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowTailscalePutObjects",
      "Effect": "Allow",
      "Action": [
        "s3:PutObject",
        "s3:PutObjectAcl"
      ],
      "Resource": "arn:aws:s3:::tailscale-logs/*"
    }
  ]
}

Remplacez tailscale-logs si vous avez saisi un autre nom de bucket.

Cliquez sur Next > Create policy (Suivant > Créer une règle).
Accédez à IAM > Roles > Create role > Custom trust policy (IAM > Rôles > Créer un rôle > Règle d'approbation personnalisée).

Saisissez la règle d'approbation suivante :

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Principal": {
        "AWS": "arn:aws:iam::982722776073:role/tailscale-log-streaming"
      },
      "Action": "sts:AssumeRole",
      "Condition": {
        "StringEquals": {
          "sts:ExternalId": "YOUR_TAILNET_NAME"
        }
      }
    }
  ]
}

Remplacez YOUR_TAILNET_NAME par le nom réel de votre tailnet.

Cliquez sur Suivant.
Joignez la règle créée à l'étape 1.
Nommez le rôle TailscaleS3StreamingRole, puis cliquez sur Create role (Créer un rôle).
Copiez l'ARN du rôle pour l'utiliser dans la configuration Tailscale.

Configurer la diffusion native des journaux S3 de Tailscale

Configurer la diffusion des journaux d'audit de configuration

Dans la console d'administration Tailscale, accédez à Logs > Configuration logs (Journaux > Journaux de configuration).
Cliquez sur Start streaming (Démarrer la diffusion).
Sélectionnez Amazon S3 comme destination.
Fournissez les informations de configuration suivantes :
- ID de compte AWS : votre ID de compte AWS.
- Nom du bucket S3 : tailscale-logs.
- ARN du rôle : ARN du rôle IAM que vous avez créé.
- Préfixe de clé S3 : tailscale/configuration/ (facultatif).
Cliquez sur Start streaming (Démarrer la diffusion).
Vérifiez que l'état indique Actif.

Configurer la diffusion des journaux de flux réseau (forfait Enterprise uniquement)

Si ce n'est pas déjà fait, accédez à Settings > Network flow logs (Paramètres > Journaux de flux réseau) et activez les journaux de flux réseau pour votre tailnet.
Accédez à Logs > Network flow logs (Journaux > Journaux de flux réseau).
Cliquez sur Start streaming (Démarrer la diffusion).
Sélectionnez Amazon S3 comme destination.
Fournissez les informations de configuration suivantes :
- ID de compte AWS : votre ID de compte AWS.
- Nom du bucket S3 : tailscale-logs
- ARN du rôle : ARN du rôle IAM que vous avez créé.
- Préfixe de clé S3 : tailscale/network/ (facultatif).
Cliquez sur Start streaming (Démarrer la diffusion).
Vérifiez que l'état indique Actif.

Facultatif : Créer un utilisateur et des clés IAM en lecture seule pour Google SecOps

Dans la console AWS , accédez à IAM > Users > Add users (IAM > Utilisateurs > Ajouter des utilisateurs).
Cliquez sur Add users (Ajouter des utilisateurs).
Fournissez les informations de configuration suivantes :
- Utilisateur : secops-reader
- Type d'accès : Clé d'accès – Accès automatisé
Cliquez sur Créer un utilisateur.
Joignez une règle de lecture minimale (personnalisée) : Users > secops-reader > Permissions > Add permissions > Attach policies directly > Create policy (Utilisateurs > secops-reader > Autorisations > Ajouter des autorisations > Joindre directement des règles > Créer une règle).

Dans l'éditeur JSON, saisissez la règle suivante :

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": ["s3:GetObject"],
      "Resource": "arn:aws:s3:::tailscale-logs/*"
    },
    {
      "Effect": "Allow",
      "Action": ["s3:ListBucket"],
      "Resource": "arn:aws:s3:::tailscale-logs"
    }
  ]
}

Définissez le nom sur secops-reader-policy.
Accédez à Create policy > search/select > Next > Add permissions (Créer une règle > Rechercher/sélectionner > Suivant > Ajouter des autorisations).
Accédez à Security credentials > Access keys > Create access key (Identifiants de sécurité > Clés d'accès > Créer une clé d'accès).
Téléchargez le CSV (ces valeurs sont saisies dans le flux).

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

Accédez à Paramètres SIEM > Flux.
Cliquez sur + Add New Feed (+ Ajouter un flux).
Dans le champ Feed name (Nom du flux), saisissez un nom pour le flux (par exemple, Tailscale logs).
Sélectionnez Amazon S3 V2 comme Source type (Type de source).
Sélectionnez Tailscale comme Log type (Type de journal).
Cliquez sur Suivant.
Spécifiez les valeurs des paramètres d'entrée suivants :
- URI S3: s3://tailscale-logs/tailscale/
- Source deletion options (Options de suppression de la source) : sélectionnez l'option de suppression de votre choix.
- Maximum File Age (Âge maximal des fichiers) : incluez les fichiers modifiés au cours des derniers jours. La valeur par défaut est de 180 jours.
- ID de clé d'accès : clé d'accès utilisateur avec accès au bucket S3.
- Clé d'accès secrète : clé secrète utilisateur avec accès au bucket S3.
- Espace de noms de l'élément : espace de noms de l'élément.
- Libellés d'ingestion : libellé appliqué aux événements de ce flux.
Cliquez sur Suivant.
Vérifiez la configuration de votre nouveau flux dans l'écran Finalize (Finaliser), puis cliquez sur Submit (Envoyer).

Table de mappage UDM

Champ du journal	Mappage UDM	Logique
`exit_traf_src_port_label`	`additional.fields`	Fusionné
`exit_traf_txBytes_label`	`additional.fields`	Fusionné
`exit_traf_txPkts_label`	`additional.fields`	Fusionné
`nodeId_label`	`additional.fields`	Fusionné
`origin_label`	`additional.fields`	Fusionné
`phy_traf_rxBytes_label`	`additional.fields`	Fusionné
`phy_traf_rxPkts_label`	`additional.fields`	Fusionné
`phy_traf_txBytes_label`	`additional.fields`	Fusionné
`phy_traf_txPkts_label`	`additional.fields`	Fusionné
`target1_id_label`	`additional.fields`	Fusionné
`target1_type_label`	`additional.fields`	Fusionné
`vir_traf_rxBytes_label`	`additional.fields`	Fusionné
`vir_traf_rxPkts_label`	`additional.fields`	Fusionné
`vir_traf_txBytes_label`	`additional.fields`	Fusionné
`vir_traf_txPkts_label`	`additional.fields`	Fusionné
`action`	`extensions.auth.type`	Mappé : `LOGIN` → `AUTHTYPE_UNSPECIFIED`
`start`	`metadata.event_timestamp`	Analysé comme `ISO8601`
`event_type`	`metadata.event_type`	Mappé directement
`exit_traf.txPkts`	`network.received_bytes`	Mappé directement
`index`	`network.received_bytes`	Mappé : `0` → `uinteger`
`phy_traf.rxBytes`	`network.received_bytes`	Mappé directement
`phy_traf.rxPkts`	`network.received_bytes`	Mappé directement
`exit_traf.txBytes`	`network.sent_bytes`	Mappé directement
`index`	`network.sent_bytes`	Mappé : `0` → `uinteger`
`phy_traf.txBytes`	`network.sent_bytes`	Mappé directement
`phy_traf.txPkts`	`network.sent_bytes`	Mappé directement
`target1.name`	`principal.asset.hostname`	Mappé directement
`src_ip`	`principal.asset.ip`	Fusionné
`target1.name`	`principal.hostname`	Mappé directement
`src_ip`	`principal.ip`	Fusionné
`src_port`	`principal.port`	Mappé directement
`action`	`security_result.action_details`	Mappé directement
`action_details_label`	`security_result.detection_fields`	Fusionné
`eventGroupID_label`	`security_result.detection_fields`	Fusionné
`dst_ip`	`target.asset.ip`	Fusionné
`dst_ip`	`target.ip`	Fusionné
`dst_port`	`target.port`	Mappé directement
`actor_loginName`	`target.user.email_addresses`	Fusionné
`actor_display_name`	`target.user.user_display_name`	Mappé directement
`actor_id`	`target.user.userid`	Mappé directement
N/A	`extensions.auth.type`	Constante : `AUTHTYPE_UNSPECIFIED`
N/A	`metadata.event_type`	Constante : `GENERIC_EVENT`

Journal des modifications

Consulter le journal des modifications de ce parseur

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