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 streaming 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 conditions préalables de 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 :
- Streaming des journaux d'audit de configuration : disponible avec les forfaits Personnel, Personnel Plus et Enterprise.
- Streaming des journaux de flux réseau : disponible uniquement avec le forfait Enterprise.

Configurer un 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 : Créer un utilisateur IAM.
Sélectionnez l'utilisateur créé.
Sélectionnez l'onglet Identifiants de sécurité.
Cliquez sur Créer une clé d'accès dans la section Clés d'accès.
Sélectionnez Service tiers comme Cas d'utilisation.
Cliquez sur Suivant.
Facultatif : ajoutez un tag de description.
Cliquez sur Créer une clé d'accès.
Cliquez sur Télécharger le fichier CSV pour enregistrer la clé d'accès et la clé d'accès secrète pour une utilisation ultérieure.
Cliquez sur OK.
Sélectionnez l'onglet Autorisations.
Cliquez sur Ajouter des autorisations dans la section Règles d'autorisation.
Sélectionnez Ajouter des autorisations.
Sélectionnez Associer directement les règles.
Recherchez et sélectionnez la règle AmazonS3FullAccess.
Cliquez sur Suivant.
Cliquez sur Ajouter des autorisations.

Configurer la stratégie et le rôle IAM pour les importations S3

Dans la console AWS, accédez à IAM > Stratégies > Créer une stratégie > 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 Suivant > Créer une règle.
Accédez à IAM > Rôles > Créer un rôle > Stratégie d'approbation personnalisée.

Saisissez la stratégie de confiance 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.
Associez la règle créée à l'étape 1.
Nommez le rôle TailscaleS3StreamingRole, puis cliquez sur Créer un rôle.
Copiez l'ARN du rôle pour l'utiliser dans la configuration Tailscale.

Configurer le streaming natif des journaux S3 de Tailscale

Configurer le streaming des journaux d'audit de configuration

Dans la console d'administration Tailscale, accédez à Journaux > Journaux de configuration.
Cliquez sur Démarrer la diffusion.
Sélectionnez Amazon S3 comme destination.
Fournissez les informations de configuration suivantes :
- ID de compte AWS : ID de votre 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 Démarrer la diffusion.
Vérifiez que l'état est défini sur Actif.

Configurer le streaming des journaux de flux réseau (forfait Enterprise uniquement)

Si ce n'est pas déjà fait, accédez à Paramètres > Journaux de flux réseau et activez les journaux de flux réseau pour votre tailnet.
Accédez à Journaux > Journaux de flux réseau.
Cliquez sur 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 Démarrer la diffusion.
Vérifiez que l'état est défini sur Actif.

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

Dans la console AWS, accédez à 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 programmatique
Cliquez sur Create User (Créer un utilisateur).
Associez la règle de lecture minimale (personnalisée) : Utilisateurs > secops-reader > Autorisations > Ajouter des autorisations > Associer des règles directement > 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 à Créer une règle > recherchez/sélectionnez > Suivant > Ajouter des autorisations.
Accédez à 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 + Ajouter un flux.
Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Tailscale logs).
Sélectionnez Amazon S3 V2 comme Type de source.
Sélectionnez Tailscale comme Type de journal.
Cliquez sur Suivant.
Spécifiez les valeurs des paramètres d'entrée suivants :
- URI S3 : s3://tailscale-logs/tailscale/
- Options 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. La valeur par défaut est de 180 jours.
- 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é appliqué aux événements de ce flux.
Cliquez sur Suivant.
Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur 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é en tant que `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

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.