Mengumpulkan data Cyber Threat Intelligence Team Cymru Scout

Didukung di:

Dokumen ini menjelaskan cara menyerap data Team Cymru Scout Threat Intelligence ke Google Security Operations menggunakan Amazon S3.

Sebelum memulai

Pastikan Anda memiliki prasyarat berikut:

  • Instance Google SecOps
  • Akses istimewa ke tenant Team Cymru Scout
  • Akses istimewa ke AWS (S3, IAM, Lambda, EventBridge)

Mendapatkan prasyarat Team Cymru Scout

  1. Login ke Team Cymru Scout Platform.
  2. Buka API Keys web.
  3. Klik tombol Buat.
  4. Berikan deskripsi untuk kunci, jika diperlukan.
  5. Klik tombol Buat Kunci untuk membuat kunci API.
  6. Salin dan simpan detail berikut di lokasi yang aman:
    • SCOUT_API_KEY - Kunci akses API
    • SCOUT_BASE_URL - URL dasar Scout API

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, team-cymru-scout-ti).
  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 CSV file untuk menyimpan Access Key dan Secret Access Key untuk referensi di masa mendatang.
  12. Klik Done.
  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 Add permissions.

Mengonfigurasi kebijakan dan peran IAM untuk upload S3

  1. Di konsol AWS, buka IAM > Policies.
  2. Klik Buat kebijakan > tab JSON.

  3. Masukkan kebijakan berikut:

    {
"Version": "2012-10-17",
"Statement": [
    {
    "Sid": "AllowPutObjects",
    "Effect": "Allow",
    "Action": "s3:PutObject",
    "Resource": "arn:aws:s3:::team-cymru-scout-ti/*"
    },
    {
    "Sid": "AllowGetStateObject",
    "Effect": "Allow",
    "Action": "s3:GetObject",
    "Resource": "arn:aws:s3:::team-cymru-scout-ti/team-cymru/scout-ti/state.json"
    }
]
}
    • Ganti team-cymru-scout-ti jika Anda memasukkan nama bucket yang berbeda.

  4. Klik Berikutnya > Buat kebijakan.

  5. Buka IAM > Roles > Create role > AWS service > Lambda.

  6. Lampirkan kebijakan yang baru dibuat.

  7. Beri nama peran TeamCymruScoutToS3Role, 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 team_cymru_scout_ti_to_s3
    Runtime Python 3.13
    Arsitektur x86_64
    Peran eksekusi TeamCymruScoutToS3Role

  4. Setelah fungsi dibuat, buka tab Code, hapus stub, lalu masukkan kode berikut (team_cymru_scout_ti_to_s3.py):

    ```python
#!/usr/bin/env python3
# Lambda: Pull Team Cymru Scout Threat Intelligence exports to S3 (no transform)

import os, json, time
from urllib.request import Request, urlopen
from urllib.error import HTTPError, URLError
import boto3

S3_BUCKET    = os.environ["S3_BUCKET"]
S3_PREFIX    = os.environ.get("S3_PREFIX", "team-cymru/scout-ti/")
STATE_KEY    = os.environ.get("STATE_KEY", "team-cymru/scout-ti/state.json")
WINDOW_SEC   = int(os.environ.get("WINDOW_SECONDS", "3600"))
HTTP_TIMEOUT = int(os.environ.get("HTTP_TIMEOUT", "60"))
HTTP_RETRIES = int(os.environ.get("HTTP_RETRIES", "3"))
MODE         = os.environ.get("MODE", "GET").upper()
API_HEADERS  = json.loads(os.environ.get("API_HEADERS", "{}"))
MAX_PAGES    = int(os.environ.get("MAX_PAGES", "10"))

# GET mode
DOWNLOAD_URL_TEMPLATE = os.environ.get("DOWNLOAD_URL_TEMPLATE", "")
# POST_JSON mode
API_URL            = os.environ.get("API_URL", "")
JSON_BODY_TEMPLATE = os.environ.get("JSON_BODY_TEMPLATE", "")

# Team Cymru Scout specific
SCOUT_BASE_URL = os.environ.get("SCOUT_BASE_URL", "https://api.scout.cymru.com")
SCOUT_API_KEY  = os.environ.get("SCOUT_API_KEY", "")

s3 = boto3.client("s3")

def _iso(ts: float) -> str:
    return time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime(ts))

def _get_state() -> dict:
    try:
        obj = s3.get_object(Bucket=S3_BUCKET, Key=STATE_KEY)
        b = obj["Body"].read()
        return json.loads(b) if b else {}
    except Exception:
        return {}

def _put_state(st: dict):
    s3.put_object(
        Bucket=S3_BUCKET, Key=STATE_KEY,
        Body=json.dumps(st, separators=(",", ":")).encode("utf-8"),
        ContentType="application/json",
    )

def _http(url: str, method: str = "GET", body: bytes | None = None) -> tuple[bytes, str]:
    attempt = 0
    while True:
        try:
            req = Request(url, method=method)
            # Add headers
            headers = API_HEADERS.copy()
            if SCOUT_API_KEY and "Authorization" not in headers:
                headers["Authorization"] = f"Bearer {SCOUT_API_KEY}"
            headers.setdefault("Accept", "application/json")

            for k, v in headers.items():
                req.add_header(k, v)

            if body is not None:
                req.add_header("Content-Type", "application/json")

            with urlopen(req, data=body, timeout=HTTP_TIMEOUT) as r:
                return r.read(), r.headers.get("Content-Type", "application/json")
        except HTTPError as e:
            if e.code in (429, 500, 502, 503, 504) and attempt < HTTP_RETRIES:
                delay = 1 + attempt
                try:
                    delay = int(e.headers.get("Retry-After", delay))
                except Exception:
                    pass
                time.sleep(max(1, delay))
                attempt += 1
                continue
            raise
        except URLError:
            if attempt < HTTP_RETRIES:
                time.sleep(1 + attempt)
                attempt += 1
                continue
            raise

def _write(blob: bytes, ctype: str, from_ts: float, to_ts: float, page: int) -> str:
    date_path = time.strftime("%Y/%m/%d", time.gmtime(to_ts))
    key = f"{S3_PREFIX}/{date_path}/scout_ti_{int(from_ts)}_{int(to_ts)}_p{page:03d}.json"
    s3.put_object(Bucket=S3_BUCKET, Key=key, Body=blob, ContentType=ctype or "application/json")
    return key

def _next_cursor(obj: dict) -> str | None:
    if not isinstance(obj, dict):
        return None

    for container in (obj, obj.get("meta", {}) or {}, obj.get("metadata", {}) or {}):
        for k in ("next", "next_cursor", "nextCursor", "nextPageToken", "continuation", "cursor", "pagedResultsCookie"):
            v = container.get(k)
            if v:
                return str(v)
    return None

def _loop(from_ts: float, to_ts: float) -> dict:
    cursor, page, written = None, 0, 0

    while page < MAX_PAGES:
        if MODE == "GET":
            if DOWNLOAD_URL_TEMPLATE:
                url = (DOWNLOAD_URL_TEMPLATE
                    .replace("{FROM}", _iso(from_ts))
                    .replace("{TO}", _iso(to_ts))
                    .replace("{CURSOR}", cursor or ""))
            else:
                # Default Scout API endpoint (adjust based on actual API)
                url = f"{SCOUT_BASE_URL}/v1/threat-intelligence?start={_iso(from_ts)}&end={_iso(to_ts)}"
                if cursor:
                    url += f"&cursor={cursor}"
            blob, ctype = _http(url, method="GET")
        else:
            assert API_URL and JSON_BODY_TEMPLATE, "API_URL and JSON_BODY_TEMPLATE required for MODE=POST_JSON"
            body = (JSON_BODY_TEMPLATE
                    .replace("{FROM}", _iso(from_ts))
                    .replace("{TO}", _iso(to_ts))
                    .replace("{CURSOR}", cursor or "")).encode("utf-8")
            blob, ctype = _http(API_URL, method="POST", body=body)

        # Normalize to JSON bytes for storage
        try:
            parsed = json.loads(blob.decode("utf-8"))
            normalized = json.dumps(parsed, separators=(",", ":")).encode("utf-8")
            ctype_out = "application/json"
        except Exception:
            normalized = blob
            ctype_out = ctype or "application/octet-stream"

        _ = _write(normalized, ctype_out, from_ts, to_ts, page)
        written += 1
        page += 1

        # Follow cursor if JSON and cursor exists
        try:
            if parsed and isinstance(parsed, dict):
                cursor = _next_cursor(parsed)
            if not cursor:
                break
        except Exception:
            break

    return {"pages": page, "objects": written}

def lambda_handler(event=None, context=None):
    st = _get_state()
    now = time.time()
    from_ts = st.get("last_to_ts") or (now - WINDOW_SEC)
    to_ts = now
    res = _loop(from_ts, to_ts)
    st["last_to_ts"] = to_ts
    _put_state(st)
    return {"ok": True, "window": {"from": _iso(from_ts), "to": _iso(to_ts)}, **res}

if __name__ == "__main__":
    print(lambda_handler())
```

  5. Buka Configuration > Environment variables.

  6. Klik Edit > Add new environment variable.

  7. Masukkan variabel lingkungan berikut yang disediakan, lalu ganti dengan nilai Anda.

    Kunci Nilai contoh
    S3_BUCKET team-cymru-scout-ti
    S3_PREFIX team-cymru/scout-ti/
    STATE_KEY team-cymru/scout-ti/state.json
    SCOUT_BASE_URL https://api.scout.cymru.com
    SCOUT_API_KEY your-scout-api-key
    WINDOW_SECONDS 3600
    HTTP_TIMEOUT 60
    HTTP_RETRIES 3
    MODE GET atau POST_JSON
    API_HEADERS {"Authorization":"Bearer <token>","Accept":"application/json"}
    DOWNLOAD_URL_TEMPLATE (Mode GET) Template URL kustom dengan {FROM}, {TO}, {CURSOR}
    API_URL URL endpoint API (mode POST_JSON)
    JSON_BODY_TEMPLATE (mode POST_JSON) Isi JSON dengan {FROM}, {TO}, {CURSOR}
    MAX_PAGES 10

  8. Setelah fungsi dibuat, tetap buka halamannya (atau buka Lambda > Functions > your-function).

  9. Pilih tab Configuration

  10. Di panel General configuration, klik Edit.

  11. Ubah Waktu Tunggu menjadi 5 menit (300 detik), lalu klik Simpan.

Membuat jadwal EventBridge

  1. Buka Amazon EventBridge > Scheduler > Create schedule.
  2. Berikan detail konfigurasi berikut:
    • Jadwal berulang: Tarif (1 hour).
    • Target: Fungsi Lambda Anda team_cymru_scout_ti_to_s3.
    • Name: team-cymru-scout-ti-1h.
  3. Klik Buat jadwal.

Opsional: Buat pengguna & kunci IAM hanya baca untuk Google SecOps

  1. Buka Konsol AWS > IAM > Pengguna > Tambahkan pengguna.
  2. Klik Add users.
  3. Berikan detail konfigurasi berikut:
    • Pengguna: Masukkan secops-reader.
    • Jenis akses: Pilih Kunci akses – Akses terprogram.
  4. Klik Buat pengguna.
  5. Lampirkan kebijakan baca minimal (kustom): Pengguna > secops-reader > Izin > Tambahkan izin > Lampirkan kebijakan secara langsung > Buat kebijakan.

  6. Di editor JSON, masukkan kebijakan berikut:

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

  7. Tetapkan nama ke secops-reader-policy.

  8. Buka Buat kebijakan > cari/pilih > Berikutnya > Tambahkan izin.

  9. Buka Kredensial keamanan > Kunci akses > Buat kunci akses.

  10. Download CSV (nilai ini dimasukkan ke dalam feed).

Mengonfigurasi feed di Google SecOps untuk menyerap Team Cymru Scout Threat Intelligence

  1. Buka Setelan SIEM > Feed.
  2. Klik Tambahkan Feed Baru.
  3. Di kolom Nama feed, masukkan nama untuk feed (misalnya, Team Cymru Scout Threat Intelligence).
  4. Pilih Amazon S3 V2 sebagai Jenis sumber.
  5. Pilih Team Cymru Scout Threat Intelligence sebagai Jenis log.
  6. Klik Berikutnya.
  7. Tentukan nilai untuk parameter input berikut:
    • URI S3: s3://team-cymru-scout-ti/team-cymru/scout-ti/
    • Opsi penghapusan sumber: Pilih opsi penghapusan sesuai preferensi Anda.
    • Usia File Maksimum: Menyertakan file yang diubah dalam jumlah 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.

Format log Team Cymru Scout Threat Intelligence yang didukung

Parser Team Cymru Scout Threat Intelligence mendukung log dalam format KV (LEEF) dan CSV.

Log contoh Cyber Threat Intelligence Team Cymru Scout yang didukung

  • JSON

    {
  "account_name": "dummy_secops_user",
  "account_type": "basic_auth",
  "used_queries": 1414,
  "remaining_queries": 48586,
  "used_queries_percentage": 2.828,
  "query_limit": 50000,
  "used_foundation_queries": 4224,
  "remaining_foundation_queries": 5776,
  "foundation_query_limit": 10000,
  "used_foundation_queries_percentage": 42.24,
  "event_type": "account_usage"
}

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