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 d'indicateurs de compromission Palo Alto Networks

Compatible avec :

Google SecOps SIEM

Ce document explique comment ingérer des indicateurs de compromission (IOC) Palo Alto Networks dans Google Security Operations à l'aide de STIX sur TAXII. Le script d'ingestion stix_taxii (une fonction Cloud Run) extrait les indicateurs d'un serveur Palo Alto TAXII 2.1 selon une planification et les envoie à Google SecOps à l'aide du type de journal STIX.

Palo Alto Networks expose les IOC sous la forme d'un flux STIX 2.1 sur TAXII à partir de Cortex XSOAR ou de XSIAM Threat Intelligence Management (TIM). L'analyseur STIX dans Google SecOps mappe les types d'indicateurs courants (adresses IPv4, domaines, URL, hachages de fichiers et adresses e-mail) à l'UDM.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

Une instance Google SecOps, le fichier d'authentification de l'ingestion Google SecOps (le fichier JSON du compte de service) et l'ID client.
Un projet Google Cloud avec la facturation activée et les autorisations nécessaires pour créer des comptes de service, des secrets Secret Manager, des fonctions Cloud Run et des jobs Cloud Scheduler.
Palo Alto Cortex XSOAR ou XSIAM avec une licence Threat Intelligence Management (TIM) et un accès privilégié pour configurer les intégrations.

Remarque : Le flux d'Intelligence Unit 42 actuel est fourni sous la forme d'une intégration gérée par Palo dans Cortex XSOAR ou XSIAM, et n'expose pas de point de terminaison TAXII autonome. Pour ingérer des indicateurs Unit 42 ou vos propres indicateurs agrégés, publiez-les depuis Cortex TIM à l'aide de l'intégration du serveur TAXII2 décrite dans la section suivante.

Configurer le flux Palo Alto TAXII 2.1 dans Cortex TIM

L'intégration Serveur TAXII2 publie vos indicateurs Cortex XSOAR ou XSIAM en tant que flux TAXII 2.1 sortant que le script d'ingestion extrait.

Dans Cortex XSOAR ou XSIAM, installez le pack de contenu TAXII Server depuis Settings & Info> Settings> Integrations> Marketplace.
Accédez à Paramètres> Intégrations > Instances, recherchez Serveur TAXII2, puis cliquez sur Ajouter une instance.
Fournissez les informations de configuration suivantes :
- Nom : saisissez un nom pour l'instance (par exemple, SecOps-TAXII).
- Instance à longue durée d'exécution : activez cette option.
- Version du serveur TAXII2 : sélectionnez 2.1.
- Identifiants : définissez le nom d'utilisateur et le mot de passe que le script d'ingestion utilise pour l'authentification HTTP de base.

Dans le champ Collection JSON, collez le code suivant. Il publie une collection nommée SecOpsIOCs qui contient les types d'indicateurs compatibles avec l'analyseur STIX :

{
    "SecOpsIOCs": {
        "query": "type:IP or type:Domain or type:URL or type:File or type:Email",
        "description": "Indicators exported to Google SecOps"
    }
}

Cliquez sur Enregistrer et quitter, puis activez l'instance. Vérifiez que l'état de l'instance est "En cours d'exécution".
Dans l'atelier Google SecOps ou la barre de commandes de l'intégration, exécutez les commandes suivantes et enregistrez le résultat :
```
!taxii-server-info
!taxii-server-list-collections
```
Dans le résultat de la commande, enregistrez les valeurs suivantes pour l'étape de déploiement :
- URL Discovery : URL racine de l'API renvoyée par !taxii-server-info (par exemple, https://ext-TENANT.crtx.REGION.paloaltonetworks.com/xsoar/instance/execute/SecOps-TAXII/threatintel/).
- Nom de la collection : SecOpsIOCs.
- Nom d'utilisateur et Mot de passe : identifiants d'authentification de base que vous avez définis.

Activer les API Google Cloud requises

Dans la console Google Cloud , ouvrez Cloud Shell et exécutez la commande suivante :

gcloud services enable \
    cloudfunctions.googleapis.com \
    cloudbuild.googleapis.com \
    cloudscheduler.googleapis.com \
    secretmanager.googleapis.com

Stocker les identifiants dans Secret Manager

Le script lit le fichier JSON du compte de service Google SecOps et le mot de passe TAXII depuis Secret Manager.

Créez le secret du compte de service d'ingestion Google SecOps à partir de votre fichier d'authentification d'ingestion :
```
gcloud secrets create secops-ingestion-sa --data-file=./ingestion-auth.json
```

Créez le secret du mot de passe TAXII :

printf '%s' 'YOUR_TAXII_PASSWORD' | gcloud secrets create taxii-password --data-file=-

Enregistrez les deux noms de ressources au format projects/PROJECT_ID/secrets/SECRET_NAME/versions/latest. Vous les utilisez dans .env.yml.

Créer un compte de service pour la fonction

Créez un compte de service d'exécution pour la fonction Cloud Run :

gcloud iam service-accounts create stix-taxii-sa \
    --display-name="STIX/TAXII ingestion function"

Accordez-lui l'accès aux deux secrets :

gcloud secrets add-iam-policy-binding secops-ingestion-sa \
    --member="serviceAccount:stix-taxii-sa@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/secretmanager.secretAccessor"
gcloud secrets add-iam-policy-binding taxii-password \
    --member="serviceAccount:stix-taxii-sa@PROJECT_ID.iam.gserviceaccount.com" \
    --role="roles/secretmanager.secretAccessor"

Déployer le script d'ingestion

Le script d'ingestion stix_taxii est une fonction Cloud Run qui extrait les indicateurs du serveur TAXII et les transmet à Google SecOps à l'aide de l'API Ingestion. Il ingère toujours les données à l'aide du type de journal STIX.

Dans Cloud Shell, clonez le dépôt de scripts d'ingestion :

git clone https://github.com/chronicle/ingestion-scripts.git
cp -r ingestion-scripts/common ingestion-scripts/stix_taxii/common
cd ingestion-scripts/stix_taxii

Créez un fichier nommé .env.yml avec le contenu suivant : Remplacez les valeurs d'espace réservé par celles que vous avez enregistrées précédemment :

CHRONICLE_CUSTOMER_ID: "YOUR_CUSTOMER_ID"
CHRONICLE_REGION: "us"
CHRONICLE_SERVICE_ACCOUNT: "projects/PROJECT_ID/secrets/secops-ingestion-sa/versions/latest"
TAXII_VERSION: "2.1"
TAXII_DISCOVERY_URL: "https://ext-TENANT.crtx.REGION.paloaltonetworks.com/xsoar/instance/execute/SecOps-TAXII/threatintel/"
TAXII_COLLECTION_NAMES: "SecOpsIOCs"
TAXII_USERNAME: "YOUR_TAXII_USERNAME"
TAXII_PASSWORD_SECRET_PATH: "projects/PROJECT_ID/secrets/taxii-password/versions/latest"
POLL_INTERVAL: "60"

Déployez la fonction :

gcloud functions deploy stix-taxii-ingestion \
    --gen2 \
    --entry-point main \
    --trigger-http \
    --runtime python312 \
    --region us-central1 \
    --service-account stix-taxii-sa@PROJECT_ID.iam.gserviceaccount.com \
    --timeout 540 \
    --memory 512MB \
    --no-allow-unauthenticated \
    --env-vars-file .env.yml

Enregistrez l'URL de déclenchement de la fonction à partir du résultat du déploiement (par exemple, https://us-central1-PROJECT_ID.cloudfunctions.net/stix-taxii-ingestion).

Planifier la fonction avec Cloud Scheduler

Accordez au compte de service l'autorisation d'appeler la fonction :

gcloud functions add-invoker-policy-binding stix-taxii-ingestion \
    --region=us-central1 \
    --member="serviceAccount:stix-taxii-sa@PROJECT_ID.iam.gserviceaccount.com"

Créez une tâche Scheduler qui appelle la fonction toutes les heures (faites correspondre la fréquence à POLL_INTERVAL) :

gcloud scheduler jobs create http stix-taxii-scheduler \
    --location=us-central1 \
    --schedule="0 */1 * * *" \
    --uri="FUNCTION_TRIGGER_URL" \
    --http-method=POST \
    --oidc-service-account-email="stix-taxii-sa@PROJECT_ID.iam.gserviceaccount.com" \
    --oidc-token-audience="FUNCTION_TRIGGER_URL"

Vérifier le déploiement

Déclenchez une exécution initiale :

gcloud scheduler jobs run stix-taxii-scheduler --location=us-central1

Examinez les journaux de la fonction :

gcloud functions logs read stix-taxii-ingestion --region=us-central1 --gen2 --limit=50

Dans Google SecOps, recherchez les événements avec le type de journal STIX pour confirmer que les indicateurs sont ingérés.

Table de mappage UDM

Champ de journal	Mappage UDM	Logique
`observable.object.properties.type`	`categorization`	Mappé directement
`type`	`categorization`	Mappé directement
`x_ctix_confidence_score`	`confidence_score`	Renommé/Mappé
`name`	`domain_and_ports.domain`	Mappé directement
`observable.object.properties.value`	`domain_and_ports.domain`	Mappé directement
`value`	`domain_and_ports.domain`	Mappé directement
`type`	`feed_name`	Mappé : `"ipv4","ipv4-addr", "scan_ip", "mal_ip"` → `STIX-IOC`, "phish_domain", "domain", "...
`src_ip`	`ip_and_ports.ip_address`	Mappé directement
`value`	`ip_and_ports.ip_address`	Mappage direct
`src_port`	`ip_and_ports.ports`	Fusionné
`type`	`ip_and_ports.ports`	Mapped: `"ipv4","ipv4-addr", "scan_ip", "mal_ip"` → `src_port`, `ipv4-addr` → `src_port`
`created`	`metadata.event_timestamp`	Analysé en tant que `ISO8601`
`modified`	`metadata.event_timestamp`	Analysé en tant que `ISO8601`
`timestamp`	`metadata.event_timestamp`	Analysé en tant que `ISO8601`
`valid_from`	`metadata.event_timestamp`	Analysé en tant que `ISO8601`
`valid_until`	`metadata.event_timestamp`	Analysé en tant que `ISO8601`
N/A	`feed_name`	Constante : `STIX-IOC`

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.