Mengumpulkan log Akamai SIEM Connector

Didukung di:

Dokumen ini menjelaskan cara menyerap log Akamai SIEM Connector ke Google Security Operations menggunakan Amazon S3. Integrasi SIEM Akamai menyediakan peristiwa keamanan dari platform Akamai dalam format JSON melalui SIEM Integration API. Integrasi ini menggunakan AWS Lambda untuk mengambil peristiwa secara berkala dari Akamai API dan menyimpannya di S3, tempat Google SecOps menyerapnya.

Sebelum memulai

  • Instance Google SecOps
  • Akses istimewa ke Akamai Control Center dengan peran pengguna Manage SIEM
  • Kredensial Akamai API dengan layanan SIEM API yang diaktifkan (tingkat akses BACA-TULIS)
  • Akses istimewa ke AWS (S3, IAM, Lambda, EventBridge)

Mengaktifkan Integrasi SIEM di Akamai Control Center

  1. Login ke Akamai Control Center.
  2. Buka WEB & DATA CENTER SECURITY > Konfigurasi Keamanan.
  3. Buka Konfigurasi keamanan (dan versi yang sesuai) yang datanya ingin Anda kumpulkan ke SIEM.
  4. Klik Setelan lanjutan dan luaskan Pengumpulan data untuk Integrasi SIEM.
  5. Klik Aktif untuk mengaktifkan SIEM.

  6. Pilih kebijakan keamanan yang datanya ingin Anda ekspor:

    • Semua kebijakan keamanan: Mengirim data SIEM untuk peristiwa yang melanggar salah satu atau semua kebijakan keamanan dalam konfigurasi keamanan.
    • Kebijakan keamanan tertentu: Pilih satu atau beberapa kebijakan keamanan tertentu dari daftar dropdown.

  7. Opsional: Jika Anda menggunakan Account Protector dan ingin menyertakan Nama Pengguna yang tidak dienkripsi, aktifkan kotak centang Sertakan nama pengguna.

  8. Opsional: Jika Anda ingin mengecualikan peristiwa yang termasuk dalam jenis dan tindakan perlindungan tertentu, klik Tambahkan pengecualian, pilih perlindungan dan tindakan terkait yang tidak ingin Anda kumpulkan ke SIEM.

  9. Klik Simpan.

  10. Salin dan simpan ID Konfigurasi Keamanan (configId) dari bagian Integrasi SIEM. Anda akan memerlukannya untuk konfigurasi Lambda.

Membuat kredensial Akamai API untuk Integrasi SIEM

  1. Login ke Akamai Control Center.
  2. Buka ACCOUNT ADMIN > Identity & access > API clients.
  3. Klik Buat klien API.

  4. Berikan detail konfigurasi berikut:

    • Nama klien API: Masukkan nama deskriptif (misalnya, Google SecOps Poller).
    • Layanan API: Pilih SIEM dan tetapkan level akses ke READ-WRITE.

  5. Klik Buat klien API.

  6. Salin dan simpan kredensial berikut dengan aman:

    • Token Klien
    • Rahasia Klien
    • Token Akses
    • Host (misalnya, example.luna.akamaiapis.net)

Mengonfigurasi bucket AWS S3 dan IAM untuk Google SecOps

  1. Buat bucket Amazon S3 dengan mengikuti panduan pengguna ini: Membuat bucket
  2. Simpan Name dan Region bucket untuk referensi di masa mendatang (misalnya, akamai-siem-logs).
  3. Buat Pengguna dengan mengikuti panduan pengguna ini: Membuat pengguna IAM.
  4. Pilih Pengguna yang dibuat.
  5. Pilih tab Kredensial keamanan.
  6. Klik Create Access Key di bagian Access Keys.
  7. Pilih Layanan pihak ketiga sebagai Kasus penggunaan.
  8. Klik Berikutnya.
  9. Opsional: Tambahkan tag deskripsi.
  10. Klik Create access key.
  11. Klik Download file .csv untuk menyimpan Kunci Akses dan Kunci Akses Rahasia untuk referensi di masa mendatang.
  12. Klik Selesai.
  13. Pilih tab Permissions.
  14. Klik Tambahkan izin di bagian Kebijakan izin.
  15. Pilih Tambahkan izin.
  16. Pilih Lampirkan kebijakan secara langsung.
  17. Cari kebijakan AmazonS3FullAccess.
  18. Pilih kebijakan.
  19. Klik Berikutnya.
  20. Klik Tambahkan izin.

Mengonfigurasi kebijakan dan peran IAM untuk upload S3

  1. Di konsol AWS, buka IAM > Policies > Create policy > JSON tab.

  2. Salin dan tempel kebijakan berikut, lalu ganti akamai-siem-logs dengan nama bucket Anda:

    JSON kebijakan:

    {
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "AllowPutObjects",
      "Effect": "Allow",
      "Action": "s3:PutObject",
      "Resource": "arn:aws:s3:::akamai-siem-logs/*"
    },
    {
      "Sid": "AllowGetStateObject",
      "Effect": "Allow",
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::akamai-siem-logs/akamai-siem/state.json"
    }
  ]
}

  3. Klik Berikutnya.

  4. Masukkan nama kebijakan AkamaiSIEMtoS3Policy, lalu klik Buat kebijakan.

  5. Buka IAM > Roles > Create role.

  6. Pilih AWS service.

  7. Pilih Lambda sebagai kasus penggunaan.

  8. Klik Berikutnya.

  9. Cari dan pilih kebijakan AkamaiSIEMtoS3Policy yang baru saja Anda buat.

  10. Klik Berikutnya.

  11. Masukkan nama peran AkamaiSIEMtoS3Role, lalu klik Buat peran.

Buat fungsi Lambda

  1. Di AWS Console, buka Lambda > Functions > Create function.
  2. Klik Buat dari awal.

  3. Berikan detail konfigurasi berikut:

    Setelan Nilai
    Nama AkamaiSIEMtoS3Function
    Runtime Python 3.13
    Arsitektur x86_64
    Peran eksekusi Menggunakan peran yang ada
    Peran yang ada AkamaiSIEMtoS3Role

  4. Klik Create function.

  5. Setelah fungsi dibuat, buka tab Code, hapus stub, dan tempel kode berikut:

    import json
import boto3
import os
import urllib3
import hmac
import hashlib
import base64
from datetime import datetime
from urllib.parse import urlparse, urljoin

# Configuration from environment variables
S3_BUCKET = os.environ['S3_BUCKET']
S3_PREFIX = os.environ.get('S3_PREFIX', 'akamai-siem/')
STATE_KEY = os.environ.get('STATE_KEY', 'akamai-siem/state.json')

AKAMAI_HOST = os.environ['AKAMAI_HOST']
AKAMAI_CLIENT_TOKEN = os.environ['AKAMAI_CLIENT_TOKEN']
AKAMAI_CLIENT_SECRET = os.environ['AKAMAI_CLIENT_SECRET']
AKAMAI_ACCESS_TOKEN = os.environ['AKAMAI_ACCESS_TOKEN']
AKAMAI_CONFIG_IDS = os.environ['AKAMAI_CONFIG_IDS'].split(',')

LIMIT = int(os.environ.get('LIMIT', '10000'))

s3_client = boto3.client('s3')
http = urllib3.PoolManager()

def load_state():
    """Load offset state from S3"""
    try:
        response = s3_client.get_object(Bucket=S3_BUCKET, Key=STATE_KEY)
        return json.loads(response['Body'].read().decode('utf-8'))
    except s3_client.exceptions.NoSuchKey:
        return {}
    except Exception as e:
        print(f"Error loading state: {e}")
        return {}

def save_state(state):
    """Save offset state to S3"""
    try:
        s3_client.put_object(
            Bucket=S3_BUCKET,
            Key=STATE_KEY,
            Body=json.dumps(state, indent=2).encode('utf-8'),
            ContentType='application/json'
        )
    except Exception as e:
        print(f"Error saving state: {e}")

def make_edgegrid_auth_header(url, method='GET'):
    """Create EdgeGrid authentication header"""
    timestamp = datetime.utcnow().strftime('%Y%m%dT%H:%M:%S+0000')
    nonce = base64.b64encode(os.urandom(16)).decode('utf-8')

    parsed_url = urlparse(url)
    relative_url = parsed_url.path
    if parsed_url.query:
        relative_url += '?' + parsed_url.query

    auth_header = f'EG1-HMAC-SHA256 ' \
                f'client_token={AKAMAI_CLIENT_TOKEN};' \
                f'access_token={AKAMAI_ACCESS_TOKEN};' \
                f'timestamp={timestamp};' \
                f'nonce={nonce};'

    data_to_sign = '\t'.join([
        method,
        parsed_url.scheme,
        parsed_url.netloc,
        relative_url,
        '',  # Request body for GET
        '',  # No additional headers
    ])

    signing_key = hmac.new(
        AKAMAI_CLIENT_SECRET.encode('utf-8'),
        timestamp.encode('utf-8'),
        hashlib.sha256
    ).digest()

    auth_signature = base64.b64encode(
        hmac.new(
            signing_key,
            (data_to_sign + auth_header).encode('utf-8'),
            hashlib.sha256
        ).digest()
    ).decode('utf-8')

    return auth_header + f'signature={auth_signature}'

def fetch_akamai_events(config_id, offset=None):
    """Fetch events from Akamai SIEM API"""
    base_url = f'https://{AKAMAI_HOST}'
    endpoint = f'/siem/v1/configs/{config_id}'

    params = f'limit={LIMIT}'
    if offset:
        params += f'&offset={offset}'

    url = f'{base_url}{endpoint}?{params}'

    try:
        headers = {
            'Authorization': make_edgegrid_auth_header(url)
        }

        response = http.request('GET', url, headers=headers, timeout=120)

        if response.status != 200:
            print(f"Error response {response.status}: {response.data.decode('utf-8')}")
            return [], offset

        # Parse multi-JSON response (newline-delimited JSON)
        lines = response.data.decode('utf-8').strip().split('\n')
        events = []
        new_offset = offset

        for line in lines:
            if not line.strip():
                continue
            try:
                obj = json.loads(line)

                # Check if this is offset context (metadata object with offset)
                if 'offset' in obj and ('total' in obj or 'responseContext' in obj):
                    new_offset = obj.get('offset')
                    continue

                # This is an event
                events.append(obj)
            except json.JSONDecodeError as e:
                print(f"Warning: Failed to parse line: {e}")
                continue

        return events, new_offset

    except Exception as e:
        print(f"Error fetching events for config {config_id}: {e}")
        return [], offset

def lambda_handler(event, context):
    """Lambda handler - fetches Akamai events and writes to S3"""
    print(f"Starting Akamai SIEM fetch at {datetime.utcnow().isoformat()}Z")

    state = load_state()
    total_events = 0

    for config_id in AKAMAI_CONFIG_IDS:
        config_id = config_id.strip()
        if not config_id:
            continue

        print(f"Fetching events for config: {config_id}")

        current_offset = state.get(config_id)
        events, new_offset = fetch_akamai_events(config_id, current_offset)

        if events:
            print(f"Fetched {len(events)} events for config {config_id}")

            # Write events to S3 as newline-delimited JSON
            timestamp = datetime.utcnow().strftime('%Y%m%d_%H%M%S')
            s3_key = f'{S3_PREFIX}{config_id}/{timestamp}.json'

            payload = '\n'.join(json.dumps(event) for event in events)

            try:
                s3_client.put_object(
                    Bucket=S3_BUCKET,
                    Key=s3_key,
                    Body=payload.encode('utf-8'),
                    ContentType='application/json'
                )
                print(f"Wrote {len(events)} events to s3://{S3_BUCKET}/{s3_key}")

                # Update offset only after successful write
                if new_offset:
                    state[config_id] = new_offset
                    total_events += len(events)
            except Exception as e:
                print(f"Error writing to S3: {e}")
        else:
            print(f"No new events for config {config_id}")

    # Save updated state
    save_state(state)

    return {
        'statusCode': 200,
        'body': json.dumps({
            'message': f'Successfully processed {total_events} events',
            'configs_processed': len(AKAMAI_CONFIG_IDS)
        })
    }

  6. Klik Deploy untuk menyimpan kode.

  7. Buka Configuration > Environment variables.

  8. Klik Edit.

  9. Klik Tambahkan variabel lingkungan untuk setiap variabel berikut:

    Variabel lingkungan

    Kunci Nilai contoh
    S3_BUCKET akamai-siem-logs
    S3_PREFIX akamai-siem/
    STATE_KEY akamai-siem/state.json
    AKAMAI_HOST example.luna.akamaiapis.net
    AKAMAI_CLIENT_TOKEN your-client-token
    AKAMAI_CLIENT_SECRET your-client-secret
    AKAMAI_ACCESS_TOKEN your-access-token
    AKAMAI_CONFIG_IDS 12345,67890
    LIMIT 10000

  10. Klik Simpan.

  11. Buka Konfigurasi > Konfigurasi umum.

  12. Klik Edit.

  13. Ubah Waktu tunggu menjadi 5 menit (300 detik).

  14. Klik Simpan.

Membuat jadwal EventBridge

  1. Buka Amazon EventBridge > Scheduler > Create schedule.

  2. Berikan detail konfigurasi berikut:

    • Nama jadwal: Masukkan AkamaiSIEMtoS3-5min.
    • Pola jadwal: Pilih Jadwal berulang.
    • Jenis jadwal: Pilih Jadwal berbasis tarif.
    • Ekspresi kecepatan: Masukkan 5 dan pilih Menit.

  3. Klik Berikutnya.

  4. Berikan detail konfigurasi berikut:

    • Target: Pilih AWS Lambda Invoke.
    • Fungsi Lambda: Pilih AkamaiSIEMtoS3Function.

  5. Klik Berikutnya.

  6. Klik Berikutnya (lewati setelan opsional).

  7. Tinjau, lalu klik Buat jadwal.

Mengonfigurasi feed di Google SecOps untuk menyerap log Akamai SIEM Connector

  1. Buka Setelan SIEM > Feed.
  2. Klik + Tambahkan Feed Baru.
  3. Di kolom Nama feed, masukkan nama untuk feed (misalnya, Akamai SIEM Connector).
  4. Pilih Amazon S3 V2 sebagai Jenis sumber.
  5. Pilih Akamai SIEM Connector sebagai Jenis log.
  6. Klik Berikutnya.

  7. Tentukan nilai untuk parameter input berikut:

    • URI S3: s3://akamai-siem-logs/akamai-siem/
    • Opsi penghapusan sumber: Pilih opsi penghapusan sesuai preferensi Anda.
    • Usia File Maksimum: Menyertakan file yang diubah dalam beberapa hari terakhir. Defaultnya adalah 180 hari.
    • ID Kunci Akses: Kunci akses pengguna dengan akses ke bucket S3.
    • Kunci Akses Rahasia: Kunci rahasia pengguna dengan akses ke bucket S3.
    • Namespace aset: Namespace aset.
    • Label penyerapan: Label yang diterapkan ke peristiwa dari feed ini.

  8. Klik Berikutnya.

  9. Tinjau konfigurasi feed baru Anda di layar Selesaikan, lalu klik Kirim.

Perlu bantuan lebih lanjut? Dapatkan jawaban dari anggota Komunitas dan profesional Google SecOps.