Collecter les journaux d'audit Aware

Compatible avec :

Ce document explique comment ingérer des journaux d'audit Aware dans Google Security Operations à l'aide d'Amazon S3.

Avant de commencer

Assurez-vous de remplir les conditions suivantes :

  • Instance Google SecOps
  • Accès privilégié au locataire Aware
  • Accès privilégié à AWS (S3, IAM, Lambda, EventBridge)

Collecter les prérequis Aware (ID, clés API, ID d'organisation, jetons)

  1. Connectez-vous à la console d'administration Aware.
  2. Accédez à Paramètres système> Intégrations> Jetons d'API.
  3. Cliquez sur + Jeton d'API, puis accordez l'autorisation Lecture seule des journaux d'audit.
  4. Copiez et enregistrez les informations suivantes dans un emplacement sécurisé :
    • Jeton d'API
    • URL de base de l'API : https://api.aware.work/external/system/auditlogs/v1

Configurer un bucket AWS S3 et IAM pour Google SecOps

  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, aware-audit-logs).
  3. Créez un utilisateur en suivant ce guide : Créer un utilisateur IAM.
  4. Sélectionnez l'utilisateur créé.
  5. Sélectionnez l'onglet Informations d'identification de sécurité.
  6. Cliquez sur Créer une clé d'accès dans la section Clés d'accès.
  7. Sélectionnez Service tiers comme Cas d'utilisation.
  8. Cliquez sur Suivant.
  9. Facultatif : ajoutez un tag de description.
  10. Cliquez sur Créer une clé d'accès.
  11. 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.
  12. Cliquez sur OK.
  13. Sélectionnez l'onglet Autorisations.
  14. Cliquez sur Ajouter des autorisations dans la section Règles d'autorisation.
  15. Sélectionnez Ajouter des autorisations.
  16. Sélectionnez Joindre directement des règles.
  17. Recherchez et sélectionnez la règle AmazonS3FullAccess.
  18. Cliquez sur Suivant.
  19. Cliquez sur Ajouter des autorisations.

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

  1. Dans la console AWS, accédez à IAM> Stratégies> Créer une stratégie> onglet JSON.

  2. Saisissez la règle suivante :

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowPutObjects",
      "Effect": "Allow",
      "Action": "s3:PutObject",
      "Resource": "arn:aws:s3:::aware-audit-logs/*"
    },
    {
      "Sid": "AllowGetStateObject",
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::aware-audit-logs/aware/state.json"
    }
  ]
}
    • Remplacez aware-audit-logs si vous avez saisi un autre nom de bucket.

  3. Cliquez sur Suivant > Créer une règle.

  4. Accédez à IAM > Rôles > Créer un rôle > Service AWS > Lambda.

  5. Associez la règle que vous venez de créer.

  6. Nommez le rôle AwareAuditLambdaRole, puis cliquez sur Créer un rôle.

Créer la fonction Lambda

  1. Dans la console AWS, accédez à Lambda > Fonctions > Créer une fonction.
  2. Cliquez sur Créer à partir de zéro.
  3. Fournissez les informations de configuration suivantes :
Paramètre Valeur
Nom aware-audit-poller
Durée d'exécution Python 3.13
Architecture x86_64
Rôle d'exécution AwareAuditLambdaRole

  1. Une fois la fonction créée, ouvrez l'onglet Code, supprimez le stub et saisissez le code suivant (aware-audit-poller.py) :

    import boto3, gzip, io, json, os, time, urllib.parse
import urllib.request
from datetime import datetime, timedelta, timezone
from botocore.exceptions import ClientError

AWARE_ENDPOINT = "https://api.aware.work/external/system/auditlogs/v1"
API_TOKEN = os.environ["AWARE_API_TOKEN"]
BUCKET = os.environ["S3_BUCKET"]
PREFIX = os.environ.get("S3_PREFIX", "aware/audit/")
STATE_KEY = os.environ.get("STATE_KEY", "aware/state.json")
MAX_PER_PAGE = int(os.environ.get("MAX_PER_PAGE", "500"))

s3 = boto3.client("s3")

def _load_state():
    try:
        obj = s3.get_object(Bucket=BUCKET, Key=STATE_KEY)
        return json.loads(obj["Body"].read().decode("utf-8"))
    except ClientError as e:
        if e.response.get("Error", {}).get("Code") == "NoSuchKey":
            return {}
        raise

def _save_state(state):
    s3.put_object(Bucket=BUCKET, Key=STATE_KEY, Body=json.dumps(state).encode("utf-8"))

def handler(event, context):
    tz_utc = timezone.utc
    now = datetime.now(tz=tz_utc)

    state = _load_state()
    start_date = (
        datetime.fromisoformat(state["last_date"]).date() if "last_date" in state
        else (now - timedelta(days=1)).date()
    )
    end_date = now.date()

    total = 0
    day = start_date
    while day <= end_date:
        day_str = day.strftime("%Y-%m-%d")
        params = {"filter": f"startDate:{day_str},endDate:{day_str}", "limit": str(MAX_PER_PAGE)}
        offset = 1

        out = io.BytesIO()
        gz = gzip.GzipFile(filename="aware_audit.jsonl", mode="wb", fileobj=out)
        wrote_any = False

        while True:
            q = urllib.parse.urlencode({**params, "offset": str(offset)})
            req = urllib.request.Request(f"{AWARE_ENDPOINT}?{q}")
            req.add_header("X-Aware-Api-Key", API_TOKEN)
            with urllib.request.urlopen(req, timeout=30) as resp:
                payload = json.loads(resp.read().decode("utf-8"))
            items = (payload.get("value") or {}).get("auditLogData") or []
            if not items:
                break
            for item in items:
                gz.write((json.dumps(item, separators=(",", ":")) + "n").encode("utf-8"))
                total += 1
                wrote_any = True
            offset += 1
            time.sleep(0.2)

        gz.close()
        if wrote_any:
            key = f"{PREFIX}{day.strftime('%Y/%m/%d')}/aware_audit_{now.strftime('%Y%m%d_%H%M%S')}.jsonl.gz"
            s3.put_object(
                Bucket=BUCKET,
                Key=key,
                Body=out.getvalue(),
                ContentType="application/json",
                ContentEncoding="gzip",
            )

        _save_state({"last_date": day.isoformat()})
        day += timedelta(days=1)

    return {"status": "ok", "written": total}

  2. Accédez à Configuration> Variables d'environnement> Modifier> Ajouter une variable d'environnement.

  3. Saisissez les variables d'environnement suivantes en remplaçant les valeurs par les vôtres :

    Clé Exemple de valeur
    S3_BUCKET aware-audit-logs
    S3_PREFIX aware/audit/
    STATE_KEY aware/state.json
    AWARE_API_TOKEN <your-aware-api-token>
    MAX_PER_PAGE 500

  4. Une fois la fonction créée, restez sur sa page (ou ouvrez Lambda > Functions > votre-fonction).

  5. Accédez à l'onglet Configuration.

  6. Dans le panneau Configuration générale, cliquez sur Modifier.

  7. Définissez le délai avant expiration sur 5 minutes (300 secondes), puis cliquez sur Enregistrer.

Créer une programmation EventBridge

  1. Accédez à Amazon EventBridge> Scheduler> Create schedule (Créer une programmation).
  2. Fournissez les informations de configuration suivantes :
    • Planning récurrent : Tarif (1 hour).
    • Cible : votre fonction Lambda aware-audit-poller.
    • Nom : aware-audit-poller-1h.
  3. Cliquez sur Créer la programmation.

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

  1. Dans la console AWS, accédez à IAM > Utilisateurs > Ajouter des utilisateurs.
  2. Cliquez sur Add users (Ajouter des utilisateurs).
  3. Fournissez les informations de configuration suivantes :
    • Utilisateur : secops-reader.
    • Type d'accès : Clé d'accès – Accès programmatique.
  4. Cliquez sur Créer un utilisateur.
  5. Associez une stratégie de lecture minimale (personnalisée) : Utilisateurs > secops-reader > Autorisations > Ajouter des autorisations > Associer des stratégies directement > Créer une stratégie.

  6. Dans l'éditeur JSON, saisissez la stratégie suivante :

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

  7. Définissez le nom sur secops-reader-policy.

  8. Accédez à Créer une règle > recherchez/sélectionnez > Suivant > Ajouter des autorisations.

  9. Accédez à Identifiants de sécurité > Clés d'accès > Créer une clé d'accès.

  10. Téléchargez le CSV (ces valeurs sont saisies dans le flux).

Configurer un flux dans Google SecOps pour ingérer les journaux d'audit Aware

  1. Accédez à Paramètres SIEM> Flux.
  2. Cliquez sur + Ajouter un flux.
  3. Dans le champ Nom du flux, saisissez un nom pour le flux (par exemple, Aware Audit logs).
  4. Sélectionnez Amazon S3 V2 comme type de source.
  5. Sélectionnez Audit Aware comme Type de journal.
  6. Cliquez sur Suivant.
  7. Spécifiez les valeurs des paramètres d'entrée suivants :
    • URI S3 : s3://aware-audit-logs/aware/audit/
    • Options de suppression de la source : sélectionnez l'option de suppression de votre choix.
    • Â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 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.
  8. Cliquez sur Suivant.
  9. Vérifiez la configuration de votre nouveau flux sur l'écran Finaliser, puis cliquez sur Envoyer.

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