DomainTools Iris Investigate-Ergebnisse abrufen

In diesem Dokument wird beschrieben, wie Sie DomainTools Iris Investigate-Ergebnisse mithilfe von Amazon S3 in Google Security Operations aufnehmen. Der Parser wandelt Roh-JSON-Daten aus der Iris API von DomainTools in ein strukturiertes Format um, das dem einheitlichen Datenmodell (Unified Data Model, UDM) von Google SecOps entspricht. Es werden Informationen zu Domaindetails, Kontaktinformationen, Sicherheitsrisiken, SSL-Zertifikaten und anderen relevanten Attributen extrahiert und den entsprechenden UDM-Feldern zugeordnet, um eine konsistente Analyse und Threat Intelligence zu ermöglichen.

Hinweise

• Google SecOps-Instanz
• Privilegierter Zugriff auf das DomainTools-Unternehmenskonto (API-Zugriff auf Iris Investigate)
• Privilegierter Zugriff auf AWS (S3, IAM, Lambda, EventBridge)

DomainTools-API-Schlüssel und ‑Endpunkt abrufen

1. Melden Sie sich im DomainTools API Dashboard an. Nur das Konto des API-Inhabers kann den API-Schlüssel zurücksetzen.
2. Wählen Sie im Bereich Mein Konto auf dem Tab Kontoübersicht den Link API-Dashboard aufrufen aus.
3. Rufen Sie den Abschnitt API-Nutzername auf, um Ihren Nutzernamen zu erhalten.
4. Suchen Sie auf demselben Tab nach Ihrem API-Schlüssel.
5. Kopieren Sie den Schlüssel und speichern Sie ihn an einem sicheren Ort.

6. Wenn Sie einen neuen Schlüssel benötigen, wählen Sie API-Schlüssel zurücksetzen aus.

7. Notieren Sie sich den Endpunkt für Iris Investigate: https://api.domaintools.com/v1/iris-investigate/.

AWS S3-Bucket und IAM für Google SecOps konfigurieren

1. Erstellen Sie einen Amazon S3-Bucket. Folgen Sie dazu dieser Anleitung: Bucket erstellen.
2. Speichern Sie den Namen und die Region des Buckets zur späteren Verwendung (z. B. domaintools-iris).
3. Erstellen Sie einen Nutzer gemäß dieser Anleitung: IAM-Nutzer erstellen.
4. Wählen Sie den erstellten Nutzer aus.
5. Wählen Sie den Tab Sicherheitsanmeldedaten aus.
6. Klicken Sie im Abschnitt Zugriffsschlüssel auf Zugriffsschlüssel erstellen.
7. Wählen Sie als Anwendungsfall Drittanbieterdienst aus.
8. Klicken Sie auf Weiter.
9. Optional: Fügen Sie ein Beschreibungstag hinzu.
10. Klicken Sie auf Zugriffsschlüssel erstellen.
11. Klicken Sie auf CSV-Datei herunterladen, um den Zugriffsschlüssel und den geheimen Zugriffsschlüssel zur späteren Verwendung zu speichern.
12. Klicken Sie auf Fertig.
13. Wählen Sie den Tab Berechtigungen aus.
14. Klicken Sie im Bereich Berechtigungsrichtlinien auf Berechtigungen hinzufügen.
15. Wählen Sie Berechtigungen hinzufügen aus.
16. Wählen Sie Richtlinien direkt anhängen aus.
17. Suchen Sie nach der Richtlinie AmazonS3FullAccess und wählen Sie sie aus.
18. Klicken Sie auf Weiter.
19. Klicken Sie auf Berechtigungen hinzufügen.

IAM-Richtlinie und -Rolle für S3-Uploads konfigurieren

1. Rufen Sie in der AWS-Konsole IAM > Richtlinien > Richtlinie erstellen > JSON-Tab auf.

2. Geben Sie die folgende Richtlinie ein:

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Sid": "AllowPutDomainToolsIrisObjects",
         "Effect": "Allow",
         "Action": "s3:PutObject",
         "Resource": "arn:aws:s3:::domaintools-iris/*"
       }
     ]
   }
   

   • Ersetzen Sie domaintools-iris, wenn Sie einen anderen Bucket-Namen eingegeben haben.

3. Klicken Sie auf Weiter > Richtlinie erstellen.

4. Rufen Sie IAM > Rollen > Rolle erstellen > AWS-Service > Lambda auf.

5. Hängen Sie die neu erstellte Richtlinie an.

6. Geben Sie der Rolle den Namen WriteDomainToolsIrisToS3Role und klicken Sie auf Rolle erstellen.

Lambda-Funktion erstellen

1. Rufen Sie in der AWS Console Lambda > Funktionen > Funktion erstellen auf.
2. Klicken Sie auf Von Grund auf erstellen.

3. Geben Sie die folgenden Konfigurationsdetails an:

   Einstellung	Wert
   Name	domaintools_iris_to_s3
   Laufzeit	Python 3.13
   Architektur	x86_64
   Ausführungsrolle	WriteDomainToolsIrisToS3Role

4. Nachdem die Funktion erstellt wurde, öffnen Sie den Tab Code, löschen Sie den Stub und geben Sie den folgenden Code ein (domaintools_iris_to_s3.py):

   #!/usr/bin/env python3
   # Lambda: Pull DomainTools Iris Investigate results to S3 (no transform)
   
   import os, json, time, urllib.parse
   from urllib.request import Request, urlopen
   from urllib.error import HTTPError
   import boto3
   
   # --- Environment ---
   S3_BUCKET    = os.environ["S3_BUCKET"].strip()
   S3_PREFIX    = os.environ.get("S3_PREFIX", "domaintools/iris/").strip()
   STATE_KEY    = os.environ.get("STATE_KEY", "domaintools/iris/state.json").strip()
   
   DT_API_KEY   = os.environ["DT_API_KEY"].strip()
   DT_API_SECRET= os.environ.get("DT_API_SECRET", "").strip()  # optional if your account uses key-only auth
   
   USE_MODE     = os.environ.get("USE_MODE", "HASH").strip().upper()  # HASH | DOMAINS | QUERY
   SEARCH_HASHES= [h.strip() for h in os.environ.get("SEARCH_HASHES", "").split(";") if h.strip()]
   DOMAINS      = [d.strip() for d in os.environ.get("DOMAINS", "").split(";") if d.strip()]
   QUERY_LIST   = [q.strip() for q in os.environ.get("QUERY_LIST", "").split(";") if q.strip()]
   
   PAGE_SIZE    = int(os.environ.get("PAGE_SIZE", "500"))
   MAX_PAGES    = int(os.environ.get("MAX_PAGES", "20"))
   USE_NEXT     = os.environ.get("USE_NEXT", "true").lower() == "true"
   HTTP_TIMEOUT = int(os.environ.get("HTTP_TIMEOUT", "60"))
   RETRIES      = int(os.environ.get("HTTP_RETRIES", "2"))
   
   BASE_URL = "https://api.domaintools.com/v1/iris-investigate/"
   HDRS = {
       "X-Api-Key": DT_API_KEY,
       "Accept": "application/json",
   }
   if DT_API_SECRET:
       HDRS["X-Api-Secret"] = DT_API_SECRET
   
   s3 = boto3.client("s3")
   
   # --- HTTP helpers ---
   
   def _http_get(url: str) -> dict:
       req = Request(url, method="GET")
       for k, v in HDRS.items():
           req.add_header(k, v)
       attempt = 0
       while True:
           try:
               with urlopen(req, timeout=HTTP_TIMEOUT) as r:
                   return json.loads(r.read().decode("utf-8"))
           except HTTPError as e:
               if e.code in (429, 500, 502, 503, 504) and attempt < RETRIES:
                   delay = int(e.headers.get("Retry-After", "2"))
                   time.sleep(max(1, delay))
                   attempt += 1
                   continue
               raise
   
   def _build_url(params: dict) -> str:
       return BASE_URL + ("?" + urllib.parse.urlencode(params, doseq=True) if params else "")
   
   # --- S3 helpers ---
   
   def _write_page(obj: dict, label: str, page: int) -> str:
       ts = time.strftime("%Y/%m/%d/%H%M%S", time.gmtime())
       key = f"{S3_PREFIX.rstrip('/')}/{ts}-{label}-p{page:05d}.json"
       s3.put_object(
           Bucket=S3_BUCKET, Key=key,
           Body=json.dumps(obj, separators=(",", ":")).encode("utf-8"),
           ContentType="application/json",
       )
       return key
   
   # --- Iris paging ---
   
   def _first_page_params() -> dict:
       params: dict[str, object] = {"page_size": str(PAGE_SIZE)}
       if USE_NEXT:
           params["next"] = "true"
       return params
   
   def _paginate(label: str, params: dict) -> tuple[int, int]:
       pages = 0
       total = 0
       url = _build_url(params)
       while pages < MAX_PAGES:
           data = _http_get(url)
           _write_page(data, label, pages)
   
           resp = data.get("response") or {}
           results = resp.get("results") or []
           total += len(results)
           pages += 1
   
           # Prefer `next` absolute URL if present
           next_url = resp.get("next") if isinstance(resp, dict) else None
           if next_url:
               url = next_url
               continue
   
           # Fallback: position pager when `next=true` not used/supported
           if resp.get("has_more_results") and resp.get("position"):
               base = _first_page_params()
               base.pop("next", None)
               base["position"] = resp["position"]
               url = _build_url(base)
               continue
   
           break
       return pages, total
   
   # --- Mode runners ---
   
   def run_hashes(hashes: list[str]) -> dict:
       agg_pages = agg_results = 0
       for h in hashes:
           params = _first_page_params()
           params["search_hash"] = h
           p, r = _paginate(f"hash-{h}", params)
           agg_pages += p
           agg_results += r
       return {"pages": agg_pages, "results": agg_results}
   
   def run_domains(domains: list[str]) -> dict:
       agg_pages = agg_results = 0
       for d in domains:
           params = _first_page_params()
           # DomainTools accepts `domain` as a filter in Investigate search
           params["domain"] = d
           p, r = _paginate(f"domain-{d}", params)
           agg_pages += p
           agg_results += r
       return {"pages": agg_pages, "results": agg_results}
   
   def run_queries(queries: list[str]) -> dict:
       agg_pages = agg_results = 0
       for q in queries:
           # Merge arbitrary k=v pairs from the query string
           base = _first_page_params()
           for k, v in urllib.parse.parse_qsl(q, keep_blank_values=True):
               base.setdefault(k, v)
           p, r = _paginate(f"query-{q.replace('=','-')}", base)
           agg_pages += p
           agg_results += r
       return {"pages": agg_pages, "results": agg_results}
   
   # --- Entry point ---
   
   def lambda_handler(event=None, context=None):
       if USE_MODE == "HASH" and SEARCH_HASHES:
           res = run_hashes(SEARCH_HASHES)
       elif USE_MODE == "DOMAINS" and DOMAINS:
           res = run_domains(DOMAINS)
       elif USE_MODE == "QUERY" and QUERY_LIST:
           res = run_queries(QUERY_LIST)
       else:
           raise ValueError("Invalid USE_MODE or missing parameters. Set USE_MODE to HASH | DOMAINS | QUERY and provide SEARCH_HASHES | DOMAINS | QUERY_LIST accordingly.")
   
       return {"ok": True, "mode": USE_MODE, **res}
   
   if __name__ == "__main__":
       print(json.dumps(lambda_handler(), indent=2))
   

5. Klicken Sie auf Konfiguration> Umgebungsvariablen> Bearbeiten> Neue Umgebungsvariable hinzufügen.

6. Geben Sie die folgenden Umgebungsvariablen ein und ersetzen Sie die Platzhalter durch Ihre Werte:

   Schlüssel	Beispielwert	Beschreibung
   S3_BUCKET	domaintools-iris	Name des S3-Buckets, in dem die Daten gespeichert werden.
   S3_PREFIX	domaintools/iris/	Optionales S3-Präfix (Unterordner) für Objekte.
   STATE_KEY	domaintools/iris/state.json	Optionaler Schlüssel für die Datei mit dem Status/Checkpoint.
   DT_API_KEY	DT-XXXXXXXXXXXXXXXXXXXX	DomainTools-API-Schlüssel.
   DT_API_SECRET	YYYYYYYYYYYYYYYYYYYYYYYY	DomainTools API-Secret (falls zutreffend).
   USE_MODE	HASH | DOMAINS | QUERY	Wählen Sie den gewünschten Modus aus. Es kann jeweils nur ein Modus aktiv sein.
   SEARCH_HASHES	hash1;hash2;hash3	Erforderlich, wenn USE_MODE=HASH. Eine durch Semikolons getrennte Liste der Hashes gespeicherter Suchanfragen aus der Iris-Benutzeroberfläche.
   DOMAINS	example.com;domaintools.com	Erforderlich, wenn USE_MODE=DOMAINS. Durch Semikolons getrennte Liste von Domains.
   QUERY_LIST	ip=1.1.1.1;ip=8.8.8.8;domain=example.org	Erforderlich, wenn USE_MODE=QUERY. Eine durch Semikolons getrennte Liste von Abfragestrings (k=v&k2=v2).
   PAGE_SIZE	500	Zeilen pro Seite (Standardwert: 500).
   MAX_PAGES	20	Maximale Anzahl von Seiten pro Anfrage

7. Bleiben Sie nach dem Erstellen der Funktion auf der zugehörigen Seite oder öffnen Sie Lambda > Funktionen > Ihre Funktion.

8. Wählen Sie den Tab Konfiguration aus.

9. Klicken Sie im Bereich Allgemeine Konfiguration auf Bearbeiten.

10. Ändern Sie Timeout in 15 minutes (900 seconds) (15 Minuten (900 Sekunden)) und klicken Sie auf Save (Speichern).

EventBridge-Zeitplan erstellen

1. Gehen Sie zu Amazon EventBridge > Scheduler > Create schedule (Amazon EventBridge > Scheduler > Zeitplan erstellen).
2. Geben Sie die folgenden Konfigurationsdetails an:
   • Wiederkehrender Zeitplan: Preis (1 hour).
   • Ziel: Ihre Lambda-Funktion.
   • Name: domaintools-iris-1h.
3. Klicken Sie auf Zeitplan erstellen.

Optional: IAM-Nutzer mit Lesezugriff und Schlüssel für Google SecOps erstellen

1. Rufen Sie in der AWS-Konsole IAM > Nutzer auf und klicken Sie auf Nutzer hinzufügen.
2. Geben Sie die folgenden Konfigurationsdetails an:
   • Nutzer: Geben Sie einen eindeutigen Namen ein, z. B. secops-reader.
   • Zugriffstyp: Wählen Sie Zugriffsschlüssel – programmatischer Zugriff aus.
   • Klicken Sie auf Nutzer erstellen.
3. Richtlinie mit minimalen Leseberechtigungen anhängen (benutzerdefiniert): Nutzer > secops-reader auswählen > Berechtigungen > Berechtigungen hinzufügen > Richtlinien direkt anhängen > Richtlinie erstellen

4. Geben Sie im JSON-Editor die folgende Richtlinie ein:

   {
     "Version": "2012-10-17",
     "Statement": [
       {
         "Effect": "Allow",
         "Action": ["s3:GetObject"],
         "Resource": "arn:aws:s3:::<your-bucket>/*"
       },
       {
         "Effect": "Allow",
         "Action": ["s3:ListBucket"],
         "Resource": "arn:aws:s3:::<your-bucket>"
       }
     ]
   }
   

5. Legen Sie secops-reader-policy als Name fest.

6. Gehen Sie zu Richtlinie erstellen> suchen/auswählen > Weiter > Berechtigungen hinzufügen.

7. Rufen Sie Sicherheitsanmeldedaten > Zugriffsschlüssel > Zugriffsschlüssel erstellen auf.

8. Laden Sie die CSV herunter (diese Werte werden in den Feed eingegeben).

Feed in Google SecOps konfigurieren, um DomainTools Iris Investigate-Ergebnisse aufzunehmen

1. Rufen Sie die SIEM-Einstellungen > Feeds auf.
2. Klicken Sie auf Neuen Feed hinzufügen.
3. Geben Sie im Feld Feed name (Feedname) einen Namen für den Feed ein, z. B. DomainTools Iris Investigate.
4. Wählen Sie Amazon S3 V2 als Quelltyp aus.
5. Wählen Sie DomainTools Threat Intelligence als Logtyp aus.
6. Klicken Sie auf Weiter.
7. Geben Sie Werte für die folgenden Eingabeparameter an:
   • S3-URI: s3://domaintools-iris/domaintools/iris/
   • Optionen zum Löschen der Quelle: Wählen Sie die gewünschte Option zum Löschen aus.
   • Maximales Dateialter: Standardmäßig 180 Tage.
   • Zugriffsschlüssel-ID: Zugriffsschlüssel des Nutzers mit Zugriff auf den S3-Bucket.
   • Secret Access Key (Geheimer Zugriffsschlüssel): Geheimer Nutzersicherheitsschlüssel mit Zugriff auf den S3-Bucket.
   • Asset-Namespace: domaintools.threat_intel
   • Aufnahmelabels: Das Label, das auf die Ereignisse aus diesem Feed angewendet werden soll.
8. Klicken Sie auf Weiter.
9. Prüfen Sie die neue Feedkonfiguration auf dem Bildschirm Abschließen und klicken Sie dann auf Senden.

UDM-Zuordnungstabelle

Benötigen Sie weitere Hilfe? Antworten von Community-Mitgliedern und Google SecOps-Experten erhalten