收集 DomainTools Iris Investigate 结果

本文档介绍了如何使用 Amazon S3 将 DomainTools Iris Investigate 结果注入到 Google Security Operations。解析器会将 DomainTools 的 Iris API 中的原始 JSON 数据转换为符合 Google SecOps 的统一数据模型 (UDM) 的结构化格式。它会提取与网域详细信息、联系信息、安全风险、SSL 证书和其他相关属性有关的信息，并将这些信息映射到相应的 UDM 字段，以便进行一致的分析和威胁情报分析。

准备工作

• Google SecOps 实例
• 对 DomainTools 企业账号的特权访问权限（对 Iris Investigate 的 API 访问权限）
• 对 AWS（S3、IAM、Lambda、EventBridge）的特权访问权限

获取 DomainTools API 密钥和端点

1. 登录 DomainTools API 信息中心（只有 API 所有者账号才能重置 API 密钥）。
2. 在我的账号部分，选择账号摘要标签页中的查看 API 信息中心链接。
3. 前往 API 用户名部分，获取您的用户名。
4. 在同一标签页中，找到您的 API 密钥。
5. 复制密钥并将其保存在安全的位置。

6. 如果您需要新密钥，请选择 Reset API Key（重置 API 密钥）。

7. 记下 Iris Investigate 端点：https://api.domaintools.com/v1/iris-investigate/。

为 Google SecOps 配置 AWS S3 存储桶和 IAM

1. 按照以下用户指南创建 Amazon S3 存储桶：创建存储桶
2. 保存存储桶名称和区域以供日后参考（例如 domaintools-iris）。
3. 按照以下用户指南创建用户：创建 IAM 用户。
4. 选择创建的用户。
5. 选择安全凭据标签页。
6. 在访问密钥部分中，点击创建访问密钥。
7. 选择第三方服务作为使用情形。
8. 点击下一步。
9. 可选：添加说明标记。
10. 点击创建访问密钥。
11. 点击 Download CSV file（下载 CSV 文件），保存访问密钥和不公开的访问密钥以供日后使用。
12. 点击完成。
13. 选择权限标签页。
14. 在权限政策部分中，点击添加权限。
15. 选择添加权限。
16. 选择直接附加政策
17. 搜索并选择 AmazonS3FullAccess 政策。
18. 点击下一步。
19. 点击添加权限。

为 S3 上传配置 IAM 政策和角色

1. 在 AWS 控制台中，依次前往 IAM > 政策 > 创建政策 > JSON 标签页。

2. 输入以下政策：

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

   • 如果您输入了其他存储桶名称，请替换 domaintools-iris。

3. 依次点击下一步 > 创建政策。

4. 依次前往 IAM > 角色 > 创建角色 > AWS 服务 > Lambda。

5. 附加新创建的政策。

6. 将角色命名为 WriteDomainToolsIrisToS3Role，然后点击创建角色。

创建 Lambda 函数

1. 在 AWS 控制台中，依次前往 Lambda > 函数 > 创建函数。
2. 点击从头开始创作。

3. 提供以下配置详细信息：

   设置	值
   名称	domaintools_iris_to_s3
   运行时	Python 3.13
   架构	x86_64
   执行角色	WriteDomainToolsIrisToS3Role

4. 创建函数后，打开 Code 标签页，删除桩代码并输入以下代码 (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. 依次前往配置 > 环境变量 > 修改 > 添加新的环境变量。

6. 输入以下环境变量，并替换为您的值：

   键	示例值	说明
   S3_BUCKET	domaintools-iris	将存储数据的 S3 存储桶名称。
   S3_PREFIX	domaintools/iris/	对象的可选 S3 前缀（子文件夹）。
   STATE_KEY	domaintools/iris/state.json	可选的状态/检查点文件密钥。
   DT_API_KEY	DT-XXXXXXXXXXXXXXXXXXXX	DomainTools API 密钥。
   DT_API_SECRET	YYYYYYYYYYYYYYYYYYYYYYYY	DomainTools API 密钥（如果适用）。
   USE_MODE	HASH | DOMAINS | QUERY	选择要使用的模式（一次只能启用一种模式）。
   SEARCH_HASHES	hash1;hash2;hash3	如果 USE_MODE=HASH，则为必需。以英文分号分隔的 Iris 界面中的已保存搜索哈希列表。
   DOMAINS	example.com;domaintools.com	如果 USE_MODE=DOMAINS，则为必需。以英文分号分隔的网域列表。
   QUERY_LIST	ip=1.1.1.1;ip=8.8.8.8;domain=example.org	如果 USE_MODE=QUERY，则为必需。以英文分号分隔的查询字符串列表 (k=v&k2=v2)。
   PAGE_SIZE	500	每页行数（默认值为 500）。
   MAX_PAGES	20	每个请求的页面数上限

7. 创建函数后，请停留在其页面上（或依次打开 Lambda > 函数 > your-function）。

8. 选择配置标签页。

9. 在常规配置面板中，点击修改。

10. 将超时更改为 15 分钟（900 秒），然后点击保存。

创建 EventBridge 计划

1. 依次前往 Amazon EventBridge > 调度程序 > 创建计划。
2. 提供以下配置详细信息：
   • 周期性安排：费率 (1 hour)。
   • 目标：您的 Lambda 函数。
   • 名称：domaintools-iris-1h。
3. 点击创建时间表。

可选：为 Google SecOps 创建只读 IAM 用户和密钥

1. 在 AWS 控制台中，依次前往 IAM > Users，然后点击 Add users。
2. 提供以下配置详细信息：
   • 用户：输入唯一名称（例如 secops-reader）
   • 访问类型：选择访问密钥 - 以程序化方式访问
   • 点击创建用户。
3. 附加最低限度的读取政策（自定义）：用户 > 选择 secops-reader > 权限 > 添加权限 > 直接附加政策 > 创建政策

4. 在 JSON 编辑器中，输入以下政策：

   {
     "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. 将名称设置为 secops-reader-policy。

6. 依次前往创建政策 > 搜索/选择 > 下一步 > 添加权限。

7. 依次前往安全凭据 > 访问密钥 > 创建访问密钥。

8. 下载 CSV（这些值将输入到 Feed 中）。

在 Google SecOps 中配置 Feed 以注入 DomainTools Iris Investigate 结果

1. 依次前往 SIEM 设置> Feed。
2. 点击添加新 Feed。
3. 在Feed 名称字段中，输入 Feed 的名称（例如 DomainTools Iris Investigate）。
4. 选择 Amazon S3 V2 作为来源类型。
5. 选择 DomainTools 威胁情报作为日志类型。
6. 点击下一步。
7. 为以下输入参数指定值：
   • S3 URI：s3://domaintools-iris/domaintools/iris/
   • 来源删除选项：根据您的偏好设置选择删除选项。
   • 文件最长保留时间：默认值为 180 天。
   • 访问密钥 ID：有权访问 S3 存储桶的用户访问密钥。
   • 私有访问密钥：具有 S3 存储桶访问权限的用户私有密钥。
   • 资源命名空间：domaintools.threat_intel
   • 注入标签：要应用于此 Feed 中事件的标签。
8. 点击下一步。
9. 在最终确定界面中查看新的 Feed 配置，然后点击提交。

UDM 映射表

需要更多帮助？从社区成员和 Google SecOps 专业人士那里获得解答。