蓝队防御实战：SIEM与SOAR构建安全运营中心（万字详解+实战配置）

【合规声明】 本文所有技术内容仅用于授权安全测试、防御能力建设和安全学习研究。所有检测规则、配置示例和脚本均在隔离靶场环境中验证。未经授权对任何系统进行安全测试均属违法行为。读者应确保在合法授权范围内使用本文所述技术，并遵守当地法律法规。

1. 蓝队防御与SOC概述

1.1 为什么需要安全运营中心

在网络安全攻防对抗日益激烈的今天，攻击者的手法层出不穷，从自动化漏洞扫描到APT高级持续性威胁，从勒索软件到供应链攻击。单靠防火墙、IDS/IPS等传统边界防护设备已无法满足纵深防御需求。安全运营中心（Security Operations Center, SOC）作为企业安全防御的"大脑"，承担着实时监控、威胁检测、事件响应和安全运营的核心职责。

蓝队（Blue Team）是防御方的核心力量，与红队（Red Team，攻击方）形成对抗关系。蓝队的目标是在攻击发生时能够快速发现、精准分析、有效响应并持续改进防御体系。SIEM（Security Information and Event Management）和SOAR（Security Orchestration, Automation and Response）是支撑蓝队工作的两大技术支柱。

【提示】 SOC不是一堆工具的堆砌，而是"人员+流程+技术"三位一体的运营体系。工具只是手段，流程是骨架，人才是灵魂。

1.2 本文目标读者与学习路径

本文面向安全运营工程师、SOC分析师、蓝队工程师、安全架构师以及对SOC建设感兴趣的安全从业者。阅读本文后，你将掌握：

SOC体系架构设计与成熟度评估方法
日志收集、标准化与解析的完整管道
SIEM平台（ELK/Splunk/Sentinel）的部署与配置
检测规则编写（Sigma/SPL/KQL）与常见攻击检测
UEBA用户行为分析与威胁情报集成
SOAR自动化响应与Playbook设计
安全度量、报表与运营最佳实践
完整SOC靶场搭建实战

2. 蓝队基础与SOC体系

2.1 蓝队定义与职责

蓝队是企业安全防御的核心团队，负责检测、分析、响应和恢复安全事件。与红队的进攻视角不同，蓝队以防守视角审视整个安全态势。

职责领域	核心工作	关键产出	依赖工具
检测（Detection）	监控安全日志、网络流量、端点行为，识别潜在威胁	实时告警、检测规则	SIEM、IDS/IPS、EDR
分析（Analysis）	对告警进行研判，确定威胁真实性、影响范围和攻击路径	事件分析报告、IOC	威胁情报平台、沙箱
响应（Response）	执行遏制、根除和恢复操作，阻断攻击链	处置动作、事件报告	SOAR、EDR、防火墙
恢复（Recovery）	恢复受影响系统和服务，验证业务连续性	恢复验证报告	备份系统、容灾平台
改进（Improvement）	复盘事件，优化检测规则、流程和防御策略	改进建议、新规则	知识库、复盘报告

2.2 SOC架构与层级

成熟的SOC通常采用分层运营模式，将告警按复杂度和严重程度分配给不同层级的分析师。

层级	名称	职责	技能要求	告警处理
Tier 1	监控分析师（L1 Analyst）	7x24实时监控、告警初筛、误报过滤、基础事件分派	日志分析基础、SIEM操作、常见攻击识别	处理60%-70%低中风险告警
Tier 2	事件分析师（L2 Analyst）	深度分析、攻击链还原、影响评估、遏制建议	恶意代码分析、网络取证、威胁情报应用	处理20%-30%中高风险告警
Tier 3	安全专家（L3 Specialist）	复杂事件调查、威胁狩猎、APT追踪、检测规则开发	逆向工程、高级取证、ATT&CK映射、ML/AI	处理5%-10%高风险/复杂事件
Tier 4	SOC经理/架构师	流程优化、团队管理、技术选型、报告汇报	安全管理、项目管理、沟通能力	不直接处理告警

【提示】 小型团队可将Tier 1和Tier 2合并，但至少保留一名Tier 3级别专家负责复杂事件和规则开发。7x24监控可通过轮班或托管SOC（MSSP）实现。

2.3 NIST网络安全框架（CSF）功能组件

NIST CSF是美国国家标准与技术研究院提出的网络安全框架，被广泛应用于SOC能力建设。它定义了五个核心功能，形成"识别-保护-检测-响应-恢复"的闭环。

功能	定义	SOC对应工作	关键控制点
识别（Identify）	识别组织资产、风险和供应链	资产盘点、风险评估、攻击面管理	资产清单、漏洞扫描、风险登记
保护（Protect）	实施防护措施降低风险	访问控制、加密、安全配置	MFA、补丁管理、数据加密
检测（Detect）	发现安全事件和异常	日志监控、威胁检测、UEBA	SIEM、IDS、异常检测
响应（Respond）	对检测到的事件采取行动	事件响应、遏制、取证	IR计划、SOAR、取证工具
恢复（Recover）	恢复受影响的服务和能力	系统恢复、业务连续性	备份恢复、灾备切换

2.4 Kill Chain vs MITRE ATT&CK vs Diamond Model对比

这三大模型是蓝队进行攻击分析和检测设计的理论基础，各有侧重。

对比维度	Cyber Kill Chain	MITRE ATT&CK	Diamond Model
提出方	Lockheed Martin	MITRE	SARA/CSD
核心视角	攻击阶段流程	攻击技术与战术	攻击者-受害者关系
结构	7个阶段	14战术/200+技术/400+子技术	4个核心特征（对手/基础设施/能力/受害者）
主要用途	攻击链还原、防御阶段映射	检测覆盖评估、红蓝对抗标尺	事件关联分析、威胁溯源
优势	直观展示攻击完整流程	细粒度技术映射，社区生态强大	适合情报关联和事件溯源
劣势	较粗粒度，难以应对现代攻击	矩阵庞大，初学者上手难	实施复杂，依赖情报质量
SOC应用	事件复盘与攻击路径分析	检测规则设计与覆盖度评估	威胁情报分析与APT溯源

【提示】 在SOC实践中，通常将三者结合使用：用Kill Chain还原攻击整体流程，用ATT&CK标注每个阶段的精确技术，用Diamond Model分析攻击者与受害者的关联关系，实现立体化的事件分析。

2.5 安全运营成熟度模型

SOC的建设是一个渐进式过程，以下成熟度模型帮助组织评估自身水平并规划演进路径。

等级	名称	特征	检测方式	响应方式	典型工具
L1	初始级（Initial）	被动响应，无统一日志	基于签名的设备告警	人工手动处置	防火墙、IDS
L2	可重复级（Repeatable）	集中日志收集，基础SIEM	基于规则的集中告警	人工+简单脚本	基础SIEM、Syslog
L3	已定义级（Defined）	完整SIEM，标准化流程	规则+威胁情报+基线	半自动化响应	成熟SIEM、TIP
L4	已管理级（Managed）	SOAR自动化，UEBA分析	行为分析+机器学习	自动化Playbook	SIEM+SOAR+UEBA
L5	优化级（Optimizing）	AI赋能，持续威胁狩猎	预测性检测+主动狩猎	全自动编排+AI辅助	全栈安全平台+AI

【提示】 大多数企业SOC处于L2-L3阶段，向L4-L5演进需要持续投入。不要盲目追求最高等级，应根据自身威胁场景和资源合理规划。

2.6 完整SOC架构设计

一个完整的SOC技术架构包含以下核心组件：

复制代码

┌─────────────────────────────────────────────────────────────┐
│                      数据源层（Data Sources）                 │
│  网络设备 │ 主机/端点 │ 应用/中间件 │ 云服务 │ SaaS │ IoT/OT  │
└───────────────────────┬─────────────────────────────────────┘
                        │ 日志收集
┌───────────────────────▼─────────────────────────────────────┐
│                  数据采集与传输层（Collection）               │
│  Filebeat │ Winlogbeat │ Syslog │ Fluentd │ Kafka │ Logstash│
└───────────────────────┬─────────────────────────────────────┘
                        │ 标准化与解析
┌───────────────────────▼─────────────────────────────────────┐
│                数据处理与存储层（Processing & Storage）       │
│  Elasticsearch集群 / Splunk Indexer / Sentinel Log Analytics │
│  Index Template │ Mapping │ ILM │ Data Stream │ Enrichment   │
└──────────┬────────────────────────┬──────────────────────────┘
           │                        │
┌──────────▼──────────┐  ┌──────────▼──────────────────────────┐
│   检测与分析层       │  │        威胁情报层                    │
│  Sigma规则 │ SPL   │  │  OpenCTI │ MISP │ STIX/TAXII │ 商业TIP│
│  UEBA │ ML异常检测  │  │  IOC匹配 │ TTPs映射 │ 富化查询       │
└──────────┬──────────┘  └──────────┬──────────────────────────┘
           │                        │
┌──────────▼─────────────────────────▼────────────────────────┐
│                  告警与事件管理层                              │
│  告警聚合 │ 优先级排序 │ 事件工单 │ SLA追踪 │ 升级转派        │
└───────────────────────┬─────────────────────────────────────┘
                        │ 编排与自动化
┌───────────────────────▼─────────────────────────────────────┐
│              SOAR自动化响应层（Orchestration）                 │
│  Playbook │ 条件分支 │ 人工审核 │ 隔离/封禁/禁用/阻断/取证     │
└───────────────────────┬─────────────────────────────────────┘
                        │
┌───────────────────────▼─────────────────────────────────────┐
│              运营与度量层（Operations & Metrics）             │
│  Kibana/Grafana看板 │ KPI报表 │ MTTD/MTTR │ 威胁狩猎 │ 知识库 │
└─────────────────────────────────────────────────────────────┘

3. 日志收集与标准化

3.1 日志源分类

SIEM的核心价值在于"看得见才能防得住"。全面的日志收集是SOC的基础。以下是企业环境中的主要日志源分类。

日志类别	具体来源	日志格式	关键字段	价值
网络设备	防火墙、交换机、路由器、IDS/IPS、WAF	Syslog、NetFlow	src_ip, dst_ip, port, action	网络边界监控
主机/端点	Windows安全日志、Linux auditd、EDR	EVTX、JSON	user, process, file, registry	端点行为监控
应用/中间件	Web服务器（Nginx/Apache）、数据库、应用日志	JSON、文本	url, method, status, query	应用层攻击检测
云服务	AWS CloudTrail、Azure Activity Log、阿里云ActionTrail	JSON	eventSource, eventName, userIdentity	云审计与合规
SaaS	Office 365、Google Workspace、Salesforce	JSON、API	actor, action, object	SaaS活动监控
IoT/OT	工业控制系统、物联网设备	专有协议	device_id, command, value	工控安全监控
身份认证	AD、LDAP、SSO、VPN	Syslog、JSON	user, auth_method, result	身份安全监控

3.2 日志收集协议对比

选择合适的日志收集工具对SOC性能至关重要。

工具	语言	协议	优势	劣势	适用场景
Syslog	C	UDP/TCP 514	轻量、标准协议、设备原生支持	无结构化、不可靠（UDP）、无加密	网络设备、传统系统
Syslog-NG	C	TCP/TLS	支持TLS、模板化、可靠性高	配置复杂、功能有限	需要可靠传输的场景
Filebeat	Go	HTTP/Lumberjack	轻量、与ELK原生集成、支持多种模块	仅文件日志收集	ELK环境主机日志收集
Winlogbeat	Go	HTTP/Lumberjack	Windows事件日志原生支持、配置简单	仅Windows平台	Windows环境日志收集
Fluentd	Ruby/C	HTTP/TCP	插件丰富（800+）、多输入输出源	Ruby性能瓶颈、内存占用	混合云、多源日志聚合
Logstash	JRuby	多协议	强大解析能力（Grok/KV/Mutate）、丰富过滤器	JVM内存占用大、吞吐瓶颈	日志解析与富化中间件
Kafka	Scala/Java	TCP	高吞吐、分布式缓冲、解耦生产消费	运维复杂、需额外组件	大规模日志流缓冲

【提示】 生产环境推荐架构：Filebeat/Winlogbeat采集 → Kafka缓冲 → Logstash解析富化 → Elasticsearch存储。Filebeat的轻量级agent适合大规模部署，Kafka解决峰值流量问题。

3.3 日志格式标准化

不同设备产生的日志格式各异，标准化是实现高效检索和关联分析的前提。常见标准化格式如下。

格式	提出方	结构	典型字段	适用平台
CEF	Micro Focus（ArcSight）	键值对	CEF:Version	Vendor
LEEF	IBM	键值对	LEEF:Version	Vendor
JSON	标准	嵌套对象	{"src_ip":"1.1.1.1","dst_port":80,...}	Elasticsearch、Sentinel
XML	标准	标签树	1.1.1.1	Windows事件日志

以下是一个将Nginx日志标准化为JSON格式的Logstash配置示例：

ruby 复制代码

# logstash.conf - Nginx日志标准化配置
input {
  beats {
    port => 5044
  }
}

filter {
  if [type] == "nginx-access" {
    grok {
      match => {
        "message" => '%{IP:src_ip} - %{DATA:user} \[%{HTTPDATE:timestamp}\] "%{WORD:method} %{URIPATHPARAM:uri} HTTP/%{NUMBER:http_version}" %{NUMBER:status} %{NUMBER:bytes} "%{DATA:referer}" "%{DATA:user_agent}"'
      }
      remove_field => ["message"]
    }
    
    # 标准化字段命名
    mutate {
      rename => {
        "src_ip" => "source.ip"
        "method" => "http.request.method"
        "uri" => "url.path"
        "status" => "http.response.status_code"
        "bytes" => "http.response.bytes"
        "user_agent" => "user_agent.original"
        "referer" => "http.request.referrer"
      }
    }
    
    # GeoIP富化
    geoip {
      source => "source.ip"
      target => "source.geo"
    }
    
    # 时间戳解析
    date {
      match => ["timestamp", "dd/MMM/yyyy:HH:mm:ss Z"]
      target => "@timestamp"
      remove_field => ["timestamp"]
    }
    
    # 添加标准化标签
    mutate {
      add_field => {
        "event.category" => "network"
        "event.type" => "access"
        "event.module" => "nginx"
      }
    }
  }
}

output {
  elasticsearch {
    hosts => ["https://localhost:9200"]
    index => "nginx-access-%{+YYYY.MM.dd}"
    user => "elastic"
    password => "${ES_PASSWORD}"
    ssl => true
    cacert => "/etc/logstash/certs/ca.crt"
  }
}

3.4 日志解析与字段映射

日志解析是将非结构化或半结构化日志转换为结构化字段的过程。字段映射应遵循ECS（Elastic Common Schema）或CIM（Common Information Model）等标准，确保跨数据源的一致性。

以下是一个Windows安全事件4624（成功登录）的标准化字段映射示例：

json 复制代码

{
  "event": {
    "code": "4624",
    "module": "security",
    "action": "logon-success",
    "outcome": "success",
    "category": "authentication"
  },
  "user": {
    "name": "administrator",
    "domain": "CORP",
    "id": "S-1-5-21-xxx-500"
  },
  "source": {
    "ip": "10.0.0.15",
    "port": 49213
  },
  "winlog": {
    "logon_type": 3,
    "authentication_package": "NTLM",
    "workstation_name": "WORKSTATION01"
  },
  "@timestamp": "2026-08-24T10:30:00.000Z"
}

3.5 日志量规划与存储策略

日志量规划直接影响SIEM的性能和成本。以下是一个中型企业（500台服务器、2000个端点）的日志量评估示例。

日志源	设备数	单设备EPS	总EPS	日存储量	年存储量
防火墙日志	5	200	1,000	0.5GB	180GB
Windows安全日志	500	50	25,000	12GB	4.3TB
Linux auditd	200	30	6,000	3GB	1TB
Web服务器日志	20	500	10,000	5GB	1.8TB
DNS日志	2	1000	2,000	1GB	365GB
EDR日志	2000	10	20,000	10GB	3.6TB
云审计日志	-	-	-	2GB	730GB
合计	-	-	~64,000	~33.5GB/天	~12TB/年

存储策略建议：

yaml 复制代码

# Elasticsearch ILM（Index Lifecycle Management）策略
# 热数据：0-7天，SSD存储，全副本
# 温数据：7-30天，HDD存储，单副本
# 冷数据：30-90天，可搜索快照
# 归档：90天以上，对象存储（S3/OSS）

ilm_policy:
  hot:
    min_age: 0ms
    actions:
      rollover:
        max_age: 1d
        max_primary_shard_size: 50gb
      set_priority:
        priority: 100
  warm:
    min_age: 7d
    actions:
      set_priority:
        priority: 50
      allocate:
        number_of_replicas: 1
        include:
          box_type: warm
  cold:
    min_age: 30d
    actions:
      set_priority:
        priority: 0
      searchable_snapshot:
        cold_snapshot_repository: cold-snapshots
  delete:
    min_age: 90d
    actions:
      delete:
        delete_searchable_snapshot: true

3.6 完整日志收集管道架构

复制代码

┌──────────┐  ┌──────────┐  ┌──────────┐  ┌──────────┐
│ 网络设备  │  │ Windows  │  │ Linux    │  │ Web/App  │
│ Syslog   │  │ Winlog-  │  │ Filebeat │  │ Filebeat│
│          │  │ beat     │  │          │  │          │
└────┬─────┘  └────┬─────┘  └────┬─────┘  └────┬─────┘
     │              │             │             │
     │         ┌─────▼─────────────▼─────────────▼─────┐
     └────────►│        Kafka 消息缓冲集群              │
               │    topic: security-logs (3分区)       │
               └─────────────────┬────────────────────┘
                                 │
                ┌────────────────▼────────────────┐
                │      Logstash 解析与富化集群      │
                │  Grok解析 → 字段映射 → GeoIP富化  │
                │  → 威胁情报富化 → 资产信息富化    │
                └────────────────┬────────────────┘
                                 │
                ┌────────────────▼────────────────┐
                │   Elasticsearch 集群（3节点）     │
                │   Hot-Warm-Cold 分层存储 + ILM   │
                └────────────────┬────────────────┘
                                 │
                ┌────────────────▼────────────────┐
                │      Kibana 可视化与看板         │
                │   SIEM检测规则 → 告警 → SOAR     │
                └─────────────────────────────────┘

4. SIEM平台部署实战

4.1 SIEM平台对比

选择合适的SIEM平台是SOC建设的关键决策。以下对主流SIEM平台进行对比。

平台	厂商	部署方式	数据存储	查询语言	优势	劣势	适用规模
Splunk Enterprise	Splunk	本地/云	自研索引	SPL	生态强大、查询性能优、社区成熟	授权费用高、资源消耗大	大型企业
ELK Stack	Elastic	本地/云	Elasticsearch	KQL/ESQL	开源免费、可扩展性强、灵活度高	运维复杂、安全功能需自建	中大型企业
IBM QRadar	IBM	本地/云	自研	AQL	检测能力强、UEBA内置	界面老旧、定制化受限	大型企业
Microsoft Sentinel	Microsoft	云(SaaS)	Azure Log Analytics	KQL	云原生、按量计费、与M365深度集成	数据出口费用高、依赖Azure	云优先企业
LogRhythm	LogRhythm	本地	自研	LQL	UEBA内置、报告功能强	市场份额下降	中型企业
Micro Focus ArcSight	Micro Focus	本地	Oracle/自研	AQL	企业级稳定、合规报告强	界面老旧、部署复杂	大型企业/合规

【提示】 开源环境首选ELK Stack，预算充足的大型企业选Splunk，云优先企业选Microsoft Sentinel，国内企业可考虑阿里云SLS+安全中心。

4.2 ELK Stack部署实战

4.2.1 Elasticsearch集群部署

yaml 复制代码

# elasticsearch.yml - 集群配置（3节点）
cluster.name: soc-elk-cluster
node.name: node-1
node.roles: [master, data, data_content, data_hot, ingest]

# 网络配置
network.host: 0.0.0.0
http.port: 9200
transport.port: 9300

# 集群发现
discovery.seed_hosts: ["10.0.0.11:9300", "10.0.0.12:9300", "10.0.0.13:9300"]
cluster.initial_master_nodes: ["node-1", "node-2", "node-3"]

# 安全配置
xpack.security.enabled: true
xpack.security.transport.ssl.enabled: true
xpack.security.transport.ssl.verification_mode: certificate
xpack.security.transport.ssl.key: /etc/elasticsearch/certs/node-1.key
xpack.security.transport.ssl.certificate: /etc/elasticsearch/certs/node-1.crt
xpack.security.transport.ssl.certificate_authorities: /etc/elasticsearch/certs/ca.crt

xpack.security.http.ssl.enabled: true
xpack.security.http.ssl.key: /etc/elasticsearch/certs/node-1.key
xpack.security.http.ssl.certificate: /etc/elasticsearch/certs/node-1.crt
xpack.security.http.ssl.certificate_authorities: /etc/elasticsearch/certs/ca.crt

# 存储路径
path.data: /data/elasticsearch
path.logs: /var/log/elasticsearch

# 内存设置
bootstrap.memory_lock: true

# 索引生命周期
xpack.security.authc.realms:
  native:
    native1:
      order: 0

JVM调优配置：

bash 复制代码

# /etc/elasticsearch/jvm.options
-Xms16g
-Xmx16g
-XX:+UseG1GC
-XX:MaxGCPauseMillis=200
-XX:InitiatingHeapOccupancyPercent=35
-XX:+AlwaysPreTouch

4.2.2 Kibana部署

yaml 复制代码

# kibana.yml
server.port: 5601
server.host: "0.0.0.0"
server.name: "soc-kibana"

elasticsearch.hosts: ["https://10.0.0.11:9200", "https://10.0.0.12:9200", "https://10.0.0.13:9200"]
elasticsearch.username: "kibana_system"
elasticsearch.password: "${KIBANA_PASSWORD}"
elasticsearch.ssl.certificateAuthorities: ["/etc/kibana/certs/ca.crt"]

# 安全功能
xpack.security.encryptionKey: "your-32-char-encryption-key-here"
xpack.encryptedSavedObjects.encryptionKey: "another-32-char-key-here"

# 告警功能
xpack.alerting.enabled: true
xpack.alerting.rules.timeout: "5m"

4.2.3 Logstash部署

ruby 复制代码

# logstash.yml
node.name: logstash-1
path.data: /var/lib/logstash
path.config: /etc/logstash/conf.d
path.logs: /var/log/logstash

# 管道配置
pipeline.workers: 8
pipeline.batch.size: 125
pipeline.batch.delay: 50

# 监控
http.host: "0.0.0.0"
http.port: 9600
xpack.monitoring.enabled: true
xpack.monitoring.elasticsearch.hosts: ["https://10.0.0.11:9200"]

4.2.4 Beats采集部署

yaml 复制代码

# filebeat.yml - 多源日志采集
filebeat.inputs:
  # Linux系统日志
  - type: filestream
    id: syslog
    paths:
      - /var/log/syslog
      - /var/log/messages
    fields:
      type: syslog
      event.module: system
  
  # Nginx访问日志
  - type: filestream
    id: nginx-access
    paths:
      - /var/log/nginx/access.log
    fields:
      type: nginx-access
      event.module: nginx
  
  # Nginx错误日志
  - type: filestream
    id: nginx-error
    paths:
      - /var/log/nginx/error.log
    fields:
      type: nginx-error
      event.module: nginx

  # auditd日志
  - type: filestream
    id: auditd
    paths:
      - /var/log/audit/audit.log
    fields:
      type: auditd
      event.module: audit

processors:
  - add_host_metadata:
      when.not.contains.tags: forwarded
  - add_fields:
      fields:
        soc.environment: production
  - decode_json_fields:
      fields: ["message"]
      process_array: false
      target: ""
      overwrite_keys: false

output.kafka:
  hosts: ["10.0.0.21:9092", "10.0.0.22:9092", "10.0.0.23:9092"]
  topic: "security-logs"
  partition.round_robin:
    reachable_only: true
  required_acks: 1

logging.level: info
logging.to_files: true
logging.files:
  path: /var/log/filebeat
  name: filebeat
  keepfiles: 7

yaml 复制代码

# winlogbeat.yml - Windows事件日志采集
winlogbeat.event_logs:
  - name: Security
    id: security
    ignore_older: 72h
    forwarded: false
  
  - name: System
    id: system
    ignore_older: 72h
  
  - name: Application
    id: application
    ignore_older: 72h
  
  - name: Microsoft-Windows-Sysmon/Operational
    id: sysmon
    ignore_older: 72h
  
  - name: Microsoft-Windows-PowerShell/Operational
    id: powershell
    ignore_older: 72h
  
  - name: Windows PowerShell
    id: powershell-classic
    ignore_older: 72h

  - name: Microsoft-Windows-WMI-Activity/Operational
    id: wmi
    ignore_older: 72h

output.kafka:
  hosts: ["10.0.0.21:9092", "10.0.0.22:9092", "10.0.0.23:9092"]
  topic: "security-logs"
  required_acks: 1

logging.level: info

4.3 Splunk部署与配置

4.3.1 Forwarder配置

ini 复制代码

# inputs.conf - 采集配置（Universal Forwarder）
[monitor://C:\Program Files\Microsoft\Exchange Server\*\Logging\*\*.log]
index = exchange
sourcetype = exchange:log

[monitor://C:\Windows\System32\winevt\logs\Security.evtx]
index = windows_security
sourcetype = WinEventLog:Security

[monitor://C:\Windows\System32\winevt\logs\System.evtx]
index = windows_system
sourcetype = WinEventLog:System

[monitor://C:\Windows\System32\winevt\logs\Application.evtx]
index = windows_application
sourcetype = WinEventLog:Application

[monitor://C:\Windows\System32\winevt\logs\Microsoft-Windows-Sysmon%4Operational.evtx]
index = sysmon
sourcetype = XmlWinEventLog:Microsoft-Windows-Sysmon/Operational

ini 复制代码

# outputs.conf - 转发配置
[tcpout]
defaultGroup = indexers
maxQueueSize = 20MB

[tcpout:indexers]
server = idx01:9997, idx02:9997, idx03:9997
autoLBFrequency = 30
useACK = true

4.3.2 Indexer配置

ini 复制代码

# indexes.conf - 索引配置（Indexer）
[windows_security]
coldPath = /splunk/colddb/windows_security
homePath = /splunk/hotdb/windows_security
thawedPath = /splunk/thaweddb/windows_security
maxDataSize = 1024
maxHotSpanSecs = 86400
maxHotBuckets = 10
enableOnlineBucketRepair = true
frozenTimePeriodInSecs = 7776000   # 90天

[sysmon]
coldPath = /splunk/colddb/sysmon
homePath = /splunk/hotdb/sysmon
thawedPath = /splunk/thaweddb/sysmon
maxDataSize = 512
frozenTimePeriodInSecs = 2592000   # 30天

[firewall]
coldPath = /splunk/colddb/firewall
homePath = /splunk/hotdb/firewall
thawedPath = /splunk/thaweddb/firewall
maxDataSize = 2048
frozenTimePeriodInSecs = 7776000

ini 复制代码

# props.conf - 解析配置
[source::WinEventLog:Security]
SHOULD_LINEMERGE = false
pulldown_type = true
MAX_TIMESTAMP_LOOKAHEAD = 32

[sysmon]
SHOULD_LINEMERGE = false
KV_MODE = xml

[firewall_log]
SHOULD_LINEMERGE = false
TIME_FORMAT = %Y-%m-%d %H:%M:%S
TIME_PREFIX = ^timestamp=

4.3.3 Search Head配置

ini 复制代码

# savedsearches.conf - 保存的搜索（告警规则）
[Alert - Multiple Failed Logins]
search = index=windows_security EventCode=4625 | stats count as failures by user, src_ip | where failures > 5
dispatch.earliest_time = -15m
dispatch.latest_time = now
alert.schedule_period = 5m
alert.severity = 3
alert.suppress = 1
alert.suppress.period = 1h
alert.suppress.fields = user, src_ip
alert.action = email
alert.action = webhook

4.4 Microsoft Sentinel部署

kql 复制代码

// Sentinel 数据连接器配置示例
// 通过 KQL 查询设置检测规则

// 检测规则：异常登录位置
let threshold = 5;
SigninLogs
| where TimeGenerated > ago(24h)
| where ResultType == 0  // 成功登录
| summarize successful_logins = count(), locations = dcount(Location), 
         distinct_ips = dcount(IPAddress) by UserPrincipalName
| where locations > threshold or distinct_ips > threshold
| join kind=inner (
    SigninLogs
    | where TimeGenerated > ago(7d)
    | where ResultType == 0
    | summarize normal_locations = make_set(Location) by UserPrincipalName
) on UserPrincipalName
| mv-expand current_location = todynamic(locations)
| where current_location !in (normal_locations)
| project TimeGenerated, UserPrincipalName, current_location, IPAddress, successful_logins

4.5 阿里云SLS日志服务

yaml 复制代码

# 阿里云SLS日志服务配置
# 日志项目
project: soc-security-project
  # 日志库
  logstore: security-logs
    retention: 90    # 保留90天
    shard: 10        # 10个分片
    
  logstore: audit-logs
    retention: 180
    shard: 5

# 采集配置
machine_groups:
  - name: windows-servers
    configs:
      - type: event_log
        category: Security
        event_id: "4624,4625,4688,4698,7045"
  - name: linux-servers
    configs:
      - type: file_log
        path: /var/log/audit/audit.log

5. 日志解析与数据建模

5.1 Elasticsearch数据建模

良好的数据建模是高效检索的基础。Elasticsearch使用Index Template、Mapping和Data Stream来管理数据结构。

json 复制代码

// Index Template - 安全日志索引模板
PUT _index_template/security-logs
{
  "index_patterns": ["firewall-*", "windows-*", "linux-*", "web-*"],
  "template": {
    "settings": {
      "number_of_shards": 1,
      "number_of_replicas": 1,
      "index.refresh_interval": "5s",
      "index.lifecycle.name": "security-logs-policy",
      "index.lifecycle.rollover_alias": "security-logs",
      "analysis": {
        "analyzer": {
          "ip_analyzer": {
            "type": "custom",
            "tokenizer": "keyword"
          }
        }
      }
    },
    "mappings": {
      "dynamic": "false",
      "properties": {
        "@timestamp": { "type": "date" },
        "event": {
          "properties": {
            "id": { "type": "keyword" },
            "category": { "type": "keyword" },
            "type": { "type": "keyword" },
            "action": { "type": "keyword" },
            "module": { "type": "keyword" },
            "outcome": { "type": "keyword" },
            "code": { "type": "keyword" }
          }
        },
        "source": {
          "properties": {
            "ip": { "type": "ip" },
            "port": { "type": "integer" },
            "geo": {
              "properties": {
                "country_name": { "type": "keyword" },
                "city_name": { "type": "keyword" },
                "location": { "type": "geo_point" },
                "asn": { "type": "keyword" }
              }
            }
          }
        },
        "destination": {
          "properties": {
            "ip": { "type": "ip" },
            "port": { "type": "integer" }
          }
        },
        "user": {
          "properties": {
            "name": { "type": "keyword" },
            "domain": { "type": "keyword" },
            "id": { "type": "keyword" }
          }
        },
        "process": {
          "properties": {
            "name": { "type": "keyword" },
            "pid": { "type": "long" },
            "command_line": { "type": "text" },
            "parent": {
              "properties": {
                "name": { "type": "keyword" },
                "pid": { "type": "long" }
              }
            }
          }
        },
        "network": {
          "properties": {
            "protocol": { "type": "keyword" },
            "transport": { "type": "keyword" },
            "bytes": { "type": "long" },
            "packets": { "type": "long" }
          }
        },
        "http": {
          "properties": {
            "request": {
              "properties": {
                "method": { "type": "keyword" },
                "path": { "type": "wildcard" }
              }
            },
            "response": {
              "properties": {
                "status_code": { "type": "integer" },
                "bytes": { "type": "long" }
              }
            }
          }
        },
        "url": {
          "properties": {
            "original": { "type": "wildcard" },
            "domain": { "type": "keyword" },
            "path": { "type": "wildcard" }
          }
        },
        "threat": {
          "properties": {
            "intel": {
              "properties": {
                "indicator": {
                  "properties": {
                    "type": { "type": "keyword" },
                    "first_seen": { "type": "date" },
                    "last_seen": { "type": "date" }
                  }
                },
                "matched": {
                  "properties": {
                    "type": { "type": "keyword" },
                    "value": { "type": "keyword" }
                  }
                }
              }
            }
          }
        }
      }
    }
  },
  "priority": 200,
  "version": 1
}

5.2 Splunk数据模型（CIM）

Splunk的CIM（Common Information Model）通过数据模型将不同来源的日志映射到统一格式，实现跨数据源的搜索。

ini 复制代码

# datamodels.conf - 认证数据模型
[Authentication]
fields = action, src, dest, user, app, reason, signature

[Authentication.subjects]
default = ALL

[Authentication.objects]
label = Authentication
fields = action, src, dest, user, app, reason, signature, severity

# 字段映射
[Authentication.object.fields]
action = eval(field=action)
src = eval(field=src_ip)
dest = eval(field=dest_ip)
user = eval(field=user_name)
app = eval(field=app_name)
reason = eval(field=failure_reason)
signature = eval(field=signature_id)

5.3 字段提取

5.3.1 Grok模式提取（Logstash）

ruby 复制代码

# Grok模式定义文件
# /etc/logstash/patterns/security_patterns
USERNAME [a-zA-Z0-9._-]+
WINDOWS_EVENT 4624
AUTH_PACKAGE (NTLM|Kerberos|Negotiate)

# Logstash Grok配置
filter {
  if [type] == "windows-security" and [winlog][event_id] == "4624" {
    grok {
      match => {
        "message" => [
          "Subject:.*?Security ID:\s*%{NOTWIN:user.id:withspace}\s*Account Name:\s*%{USERNAME:user.name}\s*Account Domain:\s*%{NOTWINDOMAIN:user.domain}\s*Logon ID:.*?Logon Type:\s*%{NUMBER:winlog.logon_type:int}\s*",
          "New Logon:.*?Account Name:\s*%{USERNAME:target_user.name}\s*Account Domain:\s*%{NOTWINDOMAIN:target_user.domain}\s*Logon ID:.*?Network Information:.*?Source Network Address:\s*%{IP:source.ip}\s*Source Port:\s*%{NUMBER:source.port:int}\s*"
        ]
      }
      tag_on_failure => ["_grokparsefailure"]
    }
  }
}

5.3.2 KV Filter提取

ruby 复制代码

filter {
  if [type] == "firewall" {
    kv {
      source => "message"
      field_split => ","
      value_split => "="
      trim_key => " "
      trim_value => "\" "
      target => "firewall"
    }
  }
}

5.3.3 Regex提取

ruby 复制代码

filter {
  if [type] == "auditd" {
    grok {
      match => {
        "message" => [
          "type=%{WORD:auditd.type} msg=audit\(%{NUMBER:auditd.epoch}\.\d+:\d+\): %{GREEDYDATA:auditd.message}"
        ]
      }
    }
    
    # 使用regex提取特定字段
    if [auditd][type] == "SYSCALL" {
      grok {
        match => {
          "auditd.message" => "arch=%{HEX:auditd.arch} syscall=%{WORD:auditd.syscall} success=%{WORD:auditd.success} exit=%{NUMBER:auditd.exit} .* a0=%{HEX:auditd.a0} .* ppid=%{NUMBER:process.parent.pid} pid=%{NUMBER:process.pid} auid=%{NUMBER:user.audit_id} uid=%{NUMBER:user.uid} gid=%{NUMBER:user.gid} .* exe=\"%{DATA:process.executable}\""
        }
      }
    }
  }
}

5.3.4 SPL字段提取

sql 复制代码

# Splunk SPL - 使用rex和eval提取字段
index=firewall sourcetype=fortigate
| rex "srcip=(?P<src_ip>\d+\.\d+\.\d+\.\d+)"
| rex "dstip=(?P<dst_ip>\d+\.\d+\.\d+\.\d+)"
| rex "dstport=(?P<dst_port>\d+)"
| eval action=if(match(action, "deny"), "blocked", "allowed")
| eval severity=case(
    match(dst_port, "^(22|3389|445|135|139)$"), "high",
    match(dst_port, "^(80|443)$"), "low",
    1=1, "medium"
)
| table _time src_ip dst_ip dst_port action severity

5.4 日志富化

日志富化是在原始日志基础上添加上下文信息，增强检测和分析能力。

ruby 复制代码

# Logstash 富化管道
filter {
  # GeoIP富化 - 添加地理位置信息
  geoip {
    source => "source.ip"
    target => "source.geo"
    database => "/etc/logstash/geoip/GeoLite2-City.mmdb"
    fields => ["country_name", "city_name", "region_name", "latitude", "longitude", "asn"]
  }
  
  # ASN富化 - 添加自治系统信息
  geoip {
    source => "source.ip"
    target => "source.as"
    database => "/etc/logstash/geoip/GeoLite2-ASN.mmdb"
    fields => ["autonomous_system_number", "autonomous_system_organization"]
  }
  
  # 威胁情报富化 - 匹配恶意IP
  elasticsearch {
    hosts => ["https://localhost:9200"]
    index => "threat-intel-*"
    query => "threat.indicator.ip:%{[source][ip]}"
    fields => {
      "threat.intel.description" => "threat.intel.description"
      "threat.intel.confidence" => "threat.intel.confidence"
      "threat.intel.source" => "threat.intel.source"
    }
    result_container => "threat.matched"
  }
  
  # 资产信息富化 - 查询CMDB
  elasticsearch {
    hosts => ["https://localhost:9200"]
    index => "cmdb-assets"
    query => "asset.ip:%{[destination][ip]}"
    fields => {
      "asset.hostname" => "destination.hostname"
      "asset.os" => "destination.os"
      "asset.owner" => "destination.owner"
      "asset.criticality" => "destination.criticality"
    }
  }
  
  # 用户信息富化 - 查询AD
  elasticsearch {
    hosts => ["https://localhost:9200"]
    index => "ad-users"
    query => "user.samaccountname:%{[user][name]}"
    fields => {
      "user.department" => "user.department"
      "user.title" => "user.title"
      "user.manager" => "user.manager"
      "user.last_logon" => "user.last_logon"
    }
  }
}

5.5 数据保留与ILM策略

json 复制代码

// 创建ILM策略
PUT _ilm/policy/security-logs-policy
{
  "policy": {
    "phases": {
      "hot": {
        "min_age": "0ms",
        "actions": {
          "rollover": {
            "max_age": "1d",
            "max_primary_shard_size": "50gb"
          },
          "set_priority": {
            "priority": 100
          },
          "forcemerge": {
            "max_num_segments": 1
          }
        }
      },
      "warm": {
        "min_age": "7d",
        "actions": {
          "set_priority": {
            "priority": 50
          },
          "allocate": {
            "number_of_replicas": 1,
            "include": { "box_type": "warm" }
          },
          "shrink": {
            "number_of_shards": 1
          }
        }
      },
      "cold": {
        "min_age": "30d",
        "actions": {
          "set_priority": {
            "priority": 0
          },
          "searchable_snapshot": {
            "snapshot_repository": "cold-snapshots"
          }
        }
      },
      "frozen": {
        "min_age": "60d",
        "actions": {
          "searchable_snapshot": {
            "snapshot_repository": "frozen-snapshots"
          }
        }
      },
      "delete": {
        "min_age": "90d",
        "actions": {
          "delete": {
            "delete_searchable_snapshot": true
          }
        }
      }
    }
  }
}

6. 检测规则编写

6.1 检测规则类型对比

规则类型	平台	语法	优势	劣势	适用场景
Sigma	通用	YAML	跨平台、开源生态、社区维护	需要转换、原生不支持	规则库管理、跨SIEM部署
SPL	Splunk	SPL语法	强大统计与关联、管道式	Splunk专有	Splunk环境
KQL	Sentinel/ELK	KQL语法	简洁直观、易学	统计能力弱于SPL	Sentinel/ELK环境
EQL	Elastic	EQL语法	事件序列匹配、适合行为检测	生态较小	Elasticsearch环境
Correlation Rule	QRadar	AQL	关联能力强	界面配置、难以版本管理	QRadar环境

6.2 Sigma规则语法详解

Sigma是SOC Analyst规则编写的事实标准，使用YAML格式定义检测逻辑，可转换为各平台原生语法。

yaml 复制代码

# Sigma规则示例：检测Mimikatz凭据转储行为
title: Mimikatz LSASS Memory Dump Attempt
id: 0eb2107b-a596-422e-b7a5-48cf81aa0eea
status: stable
description: |
  Detects attempts to dump LSASS process memory using Mimikatz or similar tools.
  This technique is commonly used for credential theft and is associated with
  MITRE ATT&CK technique T1003.001 (OS Credential Dumping: LSASS Memory).
references:
  - https://attack.mitre.org/techniques/T1003/001/
  - https://github.com/sigmaoc/sigma-rules
author: SOC Team
date: 2026/08/24
modified: 2026/08/24
tags:
  - attack.credential_access
  - attack.t1003.001
  - attack.s0002
logsource:
  product: windows
  category: process_creation
detection:
  selection_mimikatz:
    CommandLine|contains:
      - 'sekurlsa::logonpasswords'
      - 'sekurlsa::minidump'
      - 'sekurlsa::dump'
      - 'lsadump::dcsync'
      - 'privilege::debug'
  filter_false_positives:
    CommandLine|contains:
      - '# mimikatz'
      - 'mimikatz.exe help'
  condition: selection_mimikatz and not filter_false_positives
fields:
  - CommandLine
  - ComputerName
  - User
  - ImagePath
falsepositives:
  - Authorized security testing in controlled environment
  - Security research with explicit permission
level: high

Sigma规则关键字段说明：

字段	说明	示例
title	规则标题	Mimikatz LSASS Dump
id	唯一标识（UUID）	0eb2107b-a596-...
status	规则状态	stable/experimental/test
description	规则描述	检测Mimikatz凭据转储
logsource	日志来源	product: windows
detection	检测逻辑	selection/condition
fields	输出字段	CommandLine, ComputerName
level	严重等级	critical/high/medium/low
tags	ATT&CK标签	attack.t1003.001
falsepositives	误报场景	安全测试
references	参考链接	ATT&CK链接

6.3 Sigma规则转换

Sigma规则可以通过sigma-cli工具转换为各平台的原生语法：

bash 复制代码

# 安装sigma-cli
pip install sigmatools

# 转换为Splunk SPL
sigma convert -t splunk -c splunk-windows mimikatz_lsass_dump.yml

# 转换为Elasticsearch KQL
sigma convert -t kibana -c es-ecs mimikatz_lsass_dump.yml

# 转换为Elasticsearch ESQL
sigma convert -t esql mimikatz_lsass_dump.yml

# 转换为Sentinel KQL
sigma convert -t azure mimikatz_lsass_dump.yml

# 批量转换整个规则库
sigma convert -t splunk -c splunk-windows -r /opt/sigma/rules/windows/

转换后的Splunk SPL示例：

sql 复制代码

index=windows sourcetype="WinEventLog:Security" (CommandLine="*sekurlsa::logonpasswords*" OR CommandLine="*sekurlsa::minidump*" OR CommandLine="*sekurlsa::dump*" OR CommandLine="*lsadump::dcsync*") NOT (CommandLine="*# mimikatz*" OR CommandLine="*mimikatz.exe help*")
| eval severity="high", technique="T1003.001"
| table _time, ComputerName, User, CommandLine

6.4 Splunk SPL查询编写

SPL（Search Processing Language）是Splunk的查询语言，支持管道式处理。

sql 复制代码

# 1. 基础搜索与统计 - 检测暴力破解
index=windows EventCode=4625
| stats count as failures, dc(src_ip) as distinct_ips by user
| where failures > 10 and distinct_ips > 3
| sort - failures
| eval risk_score = failures * 10 + distinct_ips * 5
| table user, failures, distinct_ips, risk_score

# 2. 使用eval进行条件计算
index=firewall action=blocked
| eval severity=case(
    match(dest_port, "^(22|3389|445|135|139)$"), "critical",
    match(dest_port, "^(1433|3306|5432|1521)$"), "high",
    match(dest_port, "^(80|443)$"), "low",
    1=1, "medium"
)
| stats count by severity, dest_port
| sort severity, -count

# 3. 使用lookup进行富化
index=dns
| lookup dns_whitelist domain AS query OUTPUT is_whitelisted
| search NOT is_whitelisted=true
| lookup threat_intel_domains domain AS query OUTPUT threat_type, threat_confidence
| search threat_type=*

# 4. 使用join关联多个数据源
index=windows EventCode=4624 Logon_Type=10
| rename src_ip as user_src_ip, user as user_name
| join user_src_ip [search index=firewall action=allowed | stats count by src_ip | rename src_ip as user_src_ip ]
| stats count, values(dest_ip) by user_name

# 5. 使用tstats进行快速统计
| tstats count from datamodel=Authentication where Authentication.action=failure by Authentication.user, Authentication.src
| where count > 50
| sort - count

# 6. 使用stats进行时序聚合
index=web sourcetype=nginx_access
| bucket _time span=1h
| stats count as requests, dc(src_ip) as unique_ips by _time, status
| where status >= 500
| eval requests_per_ip = requests / unique_ips

6.5 Elasticsearch KQL/ESQL查询

kql 复制代码

// KQL - Kibana Query Language
// 检测异常PowerShell执行
event.module: "windows" AND event.code: "4104" AND 
  process.name: "powershell.exe" AND 
  process.command_line: (
    "*DownloadString*" OR 
    "*DownloadFile*" OR 
    "*Invoke-Expression*" OR 
    "*IEX*" OR 
    "*EncodedCommand*" OR 
    "*Bypass*" OR
    "*Hidden*"
  ) AND NOT user.name: ("SYSTEM" OR "NetworkService")

// ESQL - Elasticsearch Query Language
// 检测DNS隧道
FROM logs-*
| WHERE event.category == "dns" 
| STATS query_length = MAX(LENGTH(dns.question.name)) BY source.ip
| WHERE query_length > 50
| SORT query_length DESC
| KEEP source.ip, query_length

6.6 完整检测规则集

以下是一套涵盖常见攻击场景的检测规则集，每条规则都标注了对应的MITRE ATT&CK技术。

yaml 复制代码

# 规则1: 检测可疑PowerShell编码命令执行
title: Suspicious PowerShell Encoded Command Execution
logsource:
  product: windows
  category: process_creation
detection:
  selection:
    Image|endswith: '\powershell.exe'
    CommandLine|contains:
      - '-EncodedCommand'
      - '-enc '
      - '-e '
  condition: selection
level: high
tags:
  - attack.execution
  - attack.t1059.001

# 规则2: 检测CMD从临时目录执行
title: Command Execution from Temp Directory
logsource:
  product: windows
  category: process_creation
detection:
  selection:
    Image|endswith: '\cmd.exe'
    CommandLine|contains:
      - '%TEMP%'
      - '%APPDATA%'
      - 'C:\Users\Public'
  condition: selection
level: medium
tags:
  - attack.execution
  - attack.t1059.003

# 规则3: 检测注册表持久化
title: Registry Run Key Persistence
logsource:
  product: windows
  category: registry_event
detection:
  selection:
    TargetObject|contains:
      - '\SOFTWARE\Microsoft\Windows\CurrentVersion\Run'
      - '\SOFTWARE\Microsoft\Windows\CurrentVersion\RunOnce'
      - '\SOFTWARE\Microsoft\Windows\CurrentVersion\RunServices'
    Details|contains:
      - 'powershell'
      - 'cmd.exe'
      - 'wscript'
      - 'rundll32'
  condition: selection
level: high
tags:
  - attack.persistence
  - attack.t1060

# 规则4: 检测新建服务安装
title: Suspicious Service Installation
logsource:
  product: windows
  service: system
detection:
  selection:
    EventID: 7045
  filter:
    ServiceName|contains:
      - 'Microsoft'
      - 'Windows'
  condition: selection and not filter
level: medium
tags:
  - attack.persistence
  - attack.t1543.003

# 规则5: 检测PsExec远程执行
title: PsExec Remote Execution
logsource:
  product: windows
  category: process_creation
detection:
  selection:
    Image|endswith: '\psexec.exe'
  condition: selection
level: medium
tags:
  - attack.lateral_movement
  - attack.t1569.002

# 规则6: 检测可疑SMB共享访问
title: Suspicious SMB Share Access
logsource:
  product: windows
  service: security
detection:
  selection:
    EventID: 5140
    ShareName|endswith: '\\C$'
  filter:
    SubjectUserName|contains:
      - 'admin'
      - 'SYSTEM'
  condition: selection and not filter
level: medium
tags:
  - attack.lateral_movement
  - attack.t1021.002

7. 常见攻击检测规则

7.1 检测场景分类

攻击类别	检测场景	ATT&CK战术	关键日志源	典型事件ID
身份认证	暴力破解、凭据填充、异常登录	TA0006凭据访问	Windows安全、VPN	4624/4625/4648
权限提升	令牌窃取、UAC绕过、组策略滥用	TA0004权限提升	Windows安全、Sysmon	4673/4688/4672
横向移动	远程服务、Pass-the-Hash、WMI	TA0008横向移动	Windows安全、Sysmon	4624/4688/5140
持久化	注册表自启、计划任务、服务安装	TA0003持久化	Windows安全、Sysmon	4698/7045/13
数据外泄	异常DNS、大文件传输、云存储上传	TA0010外传	DNS、防火墙、代理	-
C2通信	Beacon通信、DNS隧道、异常出站	TA0011C2	防火墙、DNS、EDR	-

7.2 MITRE ATT&CK映射检测规则集

以下规则集按照MITRE ATT&CK矩阵进行组织，覆盖初始访问、执行、持久化、权限提升、凭据访问、横向移动、外传等主要战术。

yaml 复制代码

# ATT&CK T1003.001 - LSASS内存转储
title: LSASS Memory Access by Suspicious Process
logsource:
  product: windows
  category: process_access
detection:
  selection:
    TargetImage|endswith: '\lsass.exe'
  filter:
    SourceImage|endswith:
      - '\svchost.exe'
      - '\csrss.exe'
      - '\wininit.exe'
  condition: selection and not filter
level: critical
tags: [attack.t1003.001, attack.credential_access]

# ATT&CK T1055 - 进程注入
title: Potential Process Injection via CreateRemoteThread
logsource:
  product: windows
  category: process_creation
detection:
  selection:
    ParentImage|endswith: '\rundll32.exe'
  condition: selection
level: high
tags: [attack.t1055, attack.privilege_escalation]

# ATT&CK T1486 - 数据加密勒索
title: Rapid File Modification Pattern - Potential Ransomware
logsource:
  product: windows
  category: file_event
detection:
  selection:
    TargetFilename|endswith:
      - '.locked'
      - '.encrypted'
      - '.crypted'
      - '.enc'
  timeframe: 1m
  condition: selection | count(TargetFilename) > 50
level: critical
tags: [attack.t1486, attack.impact]

# ATT&CK T1071.004 - DNS隧道C2通信
title: DNS Tunneling Detection
logsource:
  product: dns
detection:
  selection_long:
    query|re: '.{50,}'
  selection_txt:
    record_type: 'TXT'
  condition: selection_long or selection_txt
level: high
tags: [attack.t1071.004, attack.command_and_control]

# ATT&CK T1566 - 钓鱼邮件附件执行
title: Suspicious Office Document Macro Execution
logsource:
  product: windows
  category: process_creation
detection:
  selection:
    ParentImage|endswith:
      - '\winword.exe'
      - '\excel.exe'
      - '\powerpnt.exe'
    Image|endswith:
      - '\powershell.exe'
      - '\cmd.exe'
      - '\wscript.exe'
      - '\cscript.exe'
  condition: selection
level: critical
tags: [attack.t1566, attack.initial_access]

7.3 Windows安全事件检测

事件ID	事件名称	安全意义	检测要点
4624	成功登录	身份认证成功	关注Logon Type、源IP、异常时间
4625	登录失败	认证失败	阈值告警、同IP多账号
4648	显式凭据登录	凭据可能被盗用	非预期账户使用
4672	特权登录	高权限账户登录	关注来源IP和时间
4688	进程创建	新进程启动	关注可疑命令行
4698	计划任务创建	可能持久化	关注任务名和命令
4706	新建信任域	SID历史注入	非授权域信任变更
4720	账户创建	可能后门账户	关注新账户和创建者
4724	密码重置	可能账户接管	关注非自助重置
4732	成员加入安全组	权限提升	关注特权组成员变更
7045	服务安装	可能持久化	关注服务名和路径

sql 复制代码

# Splunk SPL - Windows安全事件检测规则集

# 检测1: 暴力破解攻击（5分钟内同一IP超过20次失败）
index=windows EventCode=4625
| bucket _time span=5m
| stats count as failures, values(user) as target_users by src_ip, _time
| where failures > 20
| eval alert_type="brute_force", severity="high"
| table _time, src_ip, target_users, failures

# 检测2: 异常时间登录（非工作时间管理员登录）
index=windows EventCode=4624 Logon_Type IN (2,10,11) user IN (*admin*, *root*)
| eval hour=strftime(_time, "%H")
| where hour < 6 OR hour > 22
| eval alert_type="off_hours_login", severity="medium"
| table _time, user, src_ip, ComputerName, Logon_Type

# 检测3: 横向移动检测（同一用户多主机登录）
index=windows EventCode=4624 Logon_Type=3
| bucket _time span=10m
| stats dc(ComputerName) as host_count, values(ComputerName) as hosts by user, _time
| where host_count > 5
| eval alert_type="lateral_movement", severity="high"
| table _time, user, hosts, host_count

# 检测4: 特权账户异常使用
index=windows EventCode=4672
| stats count by user, src_ip, ComputerName
| where count > 50
| eval alert_type="privilege_abuse", severity="high"

# 检测5: 可疑计划任务创建
index=windows EventCode=4698
| search NOT (TaskContent="*Microsoft*" OR TaskContent="*Google*")
| eval alert_type="persistence_scheduled_task", severity="high"
| table _time, user, TaskName, TaskContent

# 检测6: 可疑服务安装
index=windows EventCode=7045
| eval suspicious=if(match(ServiceFileName, "(powershell|cmd|wscript|rundll32|cscript)"), "yes", "no")
| search suspicious=yes
| eval alert_type="persistence_service", severity="high"
| table _time, ServiceName, ServiceFileName, ServiceType, ServiceStartType

7.4 Linux日志检测

bash 复制代码

# 检测1: SSH暴力破解
# /var/log/auth.log 分析
grep "Failed password" /var/log/auth.log | awk '{print $(NF-3)}' | sort | uniq -c | sort -rn | head -20

# Elasticsearch KQL 检测
# 检测同一IP 5分钟内超过20次SSH失败
event.module: "system" AND process.name: "sshd" AND 
  system.auth.ssh.event: "Failed"

kql 复制代码

// Elasticsearch EQL - SSH暴力破解序列检测
sequence by source.ip with maxspan=5m
  [ process where process.name == "sshd" and event.action == "ssh-login-failed" ]
  [ process where process.name == "sshd" and event.action == "ssh-login-failed" ]
  [ process where process.name == "sshd" and event.action == "ssh-login-failed" ]
  [ process where process.name == "sshd" and event.action == "ssh-login-failed" ]
  [ process where process.name == "sshd" and event.action == "ssh-login-failed" ]
| stats failures = count(*) by source.ip
| where failures >= 20

bash 复制代码

# 检测2: auditd 检测可疑命令执行
# 检测whoami/id/uname等信息收集命令
ausearch -k suspicious_commands | grep -E "(whoami|id|uname|ifconfig|netstat|ps aux)"

# auditd规则配置 /etc/audit/rules.d/suspicious.rules
-a always,exit -F arch=b64 -S execve -F path=/usr/bin/whoami -k suspicious_cmd
-a always,exit -F arch=b64 -S execve -F path=/usr/bin/id -k suspicious_cmd
-a always,exit -F arch=b64 -S execve -F path=/bin/uname -k suspicious_cmd
-a always,exit -F arch=b64 -S execve -F path=/usr/bin/nmap -k suspicious_cmd
-a always,exit -F arch=b64 -S execve -F path=/usr/bin/nc -k suspicious_cmd
-a always,exit -F arch=b64 -S execve -F path=/usr/bin/wget -k suspicious_cmd
-a always,exit -F arch=b64 -S execve -F path=/usr/bin/curl -k suspicious_cmd

sql 复制代码

# 检测3: sudo权限滥用
index=linux sourcetype=auditd key=sudo
| stats count by user, exe, host
| where count > 50
| eval alert_type="sudo_abuse", severity="medium"

# 检测4: 文件权限变更（可能植入后门）
index=linux sourcetype=auditd syscall=chmod
| search (a2="4755" OR a2="2755" OR a2="4777")
| eval alert_type="suid_set", severity="high"
| table _time, user, a0, a1, a2, host

# 检测5: crontab持久化
index=linux sourcetype=auditd key=cron
| search NOT (user IN (root, www-data, mysql))
| eval alert_type="cron_persistence", severity="medium"
| table _time, user, a0, host

7.5 网络流量检测

sql 复制代码

# Splunk SPL - 网络流量检测规则

# 检测1: DNS隧道检测（长域名+高频TXT查询）
index=dns
| eval query_length=len(query)
| where query_length > 50
| stats count, max(query_length) as max_len, dc(query) as distinct_queries by src_ip
| where count > 100 OR max_len > 100
| eval alert_type="dns_tunneling", severity="high"

# 检测2: 异常出站连接（非标准端口C2通信）
index=firewall action=allowed direction=outbound
| search NOT (dest_port IN (80, 443, 53, 25, 587, 993, 995, 22))
| stats count, values(dest_ip) as dest_ips, dc(dest_ip) as distinct_dests by src_ip
| where distinct_dests > 10
| eval alert_type="c2_communication", severity="high"

# 检测3: 端口扫描检测
index=firewall action=denied
| bucket _time span=1m
| stats dc(dest_port) as port_count, values(dest_port) as ports by src_ip, _time
| where port_count > 50
| eval alert_type="port_scan", severity="medium"

# 检测4: 数据外泄检测（大流量出站）
index=firewall direction=outbound
| bucket _time span=1h
| stats sum(bytes_out) as total_bytes by src_ip, _time
| where total_bytes > 1073741824  # > 1GB
| eval alert_type="data_exfiltration", severity="high"
| eval data_mb=round(total_bytes/1048576, 2)
| table _time, src_ip, data_mb

# 检测5: 可疑协议使用（ICMP隧道）
index=firewall protocol=icmp
| stats count, avg(bytes) as avg_size by src_ip, dest_ip
| where avg_size > 1000  # ICMP包通常很小
| eval alert_type="icmp_tunneling", severity="medium"

7.6 Web日志攻击检测

sql 复制代码

# Splunk SPL - Web日志攻击检测

# 检测1: SQL注入检测
index=web sourcetype=nginx_access
| regex uri="(?i)(union.*select|select.*from|insert.*into|delete.*from|drop.*table|exec(\s|\+|%20)|information_schema|--|%27|%22)"
| eval alert_type="sqli_attempt", severity="high"
| table _time, src_ip, uri, status, user_agent

# 检测2: XSS跨站脚本检测
index=web sourcetype=nginx_access
| regex uri="(?i)(<script|javascript:|onerror=|onload=|onclick=|<img.*src|<iframe|document\.cookie|alert\(|%3Cscript)"
| eval alert_type="xss_attempt", severity="high"
| table _time, src_ip, uri, status

# 检测3: SSRF服务端请求伪造检测
index=web sourcetype=nginx_access
| regex uri="(?i)(127\.0\.0\.1|localhost|169\.254\.|10\.|192\.168\.|172\.(1[6-9]|2[0-9]|3[01])\.|metadata|169\.254\.169\.254|file://|dict://|gopher://)"
| eval alert_type="ssrf_attempt", severity="critical"
| table _time, src_ip, uri, status

# 检测4: Webshell访问检测
index=web sourcetype=nginx_access
| regex uri="(?i)(cmd\.php|shell\.php|c99\.php|r57\.php|wso\.php|eval\.php|1\.php|test\.php|\.php\?(cmd|exec|command|c)=)"
| eval alert_type="webshell_access", severity="critical"
| table _time, src_ip, uri, status, user_agent

# 检测5: 目录遍历攻击检测
index=web sourcetype=nginx_access
| regex uri="(?i)(\.\./|\.\.\\\\|/etc/passwd|/etc/shadow|c:\\windows\\system32|%2e%2e%2f|%2e%2e/|\.\.%2f)"
| eval alert_type="directory_traversal", severity="high"
| table _time, src_ip, uri, status

# 检测6: Webshell上传检测（POST到可疑PHP文件）
index=web sourcetype=nginx_access method=POST status=200
| regex uri="(?i)\.(php|jsp|asp|aspx)$"
| stats count by src_ip, uri
| where count < 3  # 新上传的文件访问次数少
| eval alert_type="webshell_upload", severity="critical"

8. UEBA用户行为分析

8.1 UEBA原理与价值

UEBA（User and Entity Behavior Analytics，用户与实体行为分析）通过机器学习和统计分析建立正常行为基线，自动发现偏离基线的异常行为。传统基于规则的检测依赖已知攻击模式，对未知威胁和内部威胁检测能力有限。UEBA通过分析"正常是什么"来推断"什么是不正常的"，弥补了规则检测的不足。

【提示】 UEBA不是替代规则检测，而是补充。规则检测擅长已知威胁的精准匹配，UEBA擅长未知威胁和内部威胁的行为异常发现。两者结合形成"规则+行为"的双层检测体系。

8.2 行为基线建立

行为基线是UEBA的核心，通过历史数据建立用户和实体的正常行为模式。

基线维度	监控指标	基线方法	异常判定
登录时间	登录时间分布、时间段频率	时间序列建模（ARIMA/Prophet）	非工作时间异常登录
登录IP	常用IP列表、IP地理分布	白名单+频率统计	新IP/异地登录
地理位置	登录城市、移动速度	地理距离+时间差计算	不可能旅行
操作频率	文件访问、数据查询、命令执行	Z-score/IQR统计	频率显著偏离
资源访问	访问的数据类型、敏感系统	分类模型	访问异常资源
网络行为	连接目标、流量大小	聚类分析	异常连接模式

8.3 异常检测算法对比

算法类型	代表算法	优势	劣势	适用场景
统计分析	Z-score、IQR、EWMA	简单直观、可解释	仅适合单维度、假设正态分布	基础基线检测
机器学习	Isolation Forest、LOF、One-Class SVM	多维度异常检测、自适应	需要训练数据、参数调优	复杂行为异常
深度学习	Autoencoder、LSTM、GAN	时序异常检测、非结构化数据	计算成本高、需大量数据	高级行为序列分析
图分析	图聚类、中心度、社群发现	关系挖掘、隐蔽通道发现	图构建复杂、计算开销大	横向移动、团伙检测

8.4 风险评分模型

UEBA将多个异常信号融合为一个综合风险评分，便于告警优先级排序。

复制代码

风险评分 = Σ(异常信号权重 × 异常程度系数)

示例风险评分模型：
  登录时间异常    权重=15  系数=0-1（偏离程度）
  新IP登录        权重=20  系数=0-1
  异地登录        权重=25  系数=0-1
  不可能旅行      权重=30  系数=0-1
  操作频率异常    权重=15  系数=0-1
  敏感资源访问    权重=20  系数=0-1
  恶意软件关联    权重=40  系数=0-1
  威胁情报命中    权重=35  系数=0-1

总分 0-100:
  0-30:   低风险（信息记录）
  31-60:  中风险（关注观察）
  61-80:  高风险（调查处置）
  81-100: 严重风险（立即响应）

8.5 UEBA规则编写

8.5.1 Elastic ML异常检测

json 复制代码

// Elasticsearch ML Job - 用户登录行为异常检测
PUT _ml/anomaly_detectors/user-login-anomaly
{
  "description": "Detect anomalous user login behavior",
  "analysis_config": {
    "bucket_span": "1h",
    "detectors": [
      {
        "function": "non_zero_count",
        "field_name": "event.action",
        "by_field_name": "user.name",
        "detector_description": "Login count per user per hour"
      },
      {
        "function": "low_non_zero_count",
        "field_name": "event.action",
        "by_field_name": "user.name",
        "detector_description": "Unusually low login count"
      },
      {
        "function": "distinct_count",
        "field_name": "source.ip",
        "by_field_name": "user.name",
        "detector_description": "Distinct source IPs per user"
      }
    ],
    "summary_count_field_name": "event.count"
  },
  "data_description": {
    "time_field": "@timestamp",
    "time_format": "epoch_ms"
  },
  "analysis_limits": {
    "max_model_memory": "500mb",
    "categorization_examples_limit": 5
  },
  "model_plot_config": {
    "enabled": true,
    "annotations_enabled": true
  },
  "custom_settings": {
    "created_by": "SOC_UEBA",
    "custom_urls": [
      {
        "name": "Kibana User Dashboard",
        "url": "kibana#/dashboard/user-ueba?_a=(query:(match:(user.name:'$user.name$')))"
      }
    ]
  }
}

8.5.2 Splunk ML Toolkit异常检测

sql 复制代码

// Splunk ML Toolkit - 不可能旅行检测
// 步骤1: 提取用户登录地点和时间
index=windows EventCode=4624 Logon_Type=10
| iplocation src_ip
| eval coords = City . "," . Country
| table _time, user, src_ip, City, Country, lat, lon
| sort _time

// 步骤2: 计算连续登录之间的距离和速度
| streamstats current=f window=1 last(_time) as prev_time, 
    last(City) as prev_city, last(lat) as prev_lat, last(lon) as prev_lon by user
| where isnotnull(prev_lat)
| eval time_diff = (_time - prev_time) / 3600  // 小时
| eval distance = sqrt(
    pow((lat - prev_lat) * 111, 2) + 
    pow((lon - prev_lon) * 111 * cos(radians(lat)), 2)
)  // 千米
| eval speed = if(time_diff > 0, distance / time_diff, 99999)  // km/h
| where speed > 900  // 商业航班最大约900km/h
| eval alert_type="impossible_travel", severity="high"
| table _time, user, prev_city, City, distance, speed, time_diff

sql 复制代码

// Splunk ML - 使用DensityPoint算法检测异常登录时间
index=windows EventCode=4624
| fit DensityPoint _time by user dist_from_center=true
| where dist_from_center > 2.5
| eval alert_type="anomalous_login_time", severity="medium"

8.5.3 自定义UEBA检测

python 复制代码

# 自定义UEBA引擎 - Python实现
import pandas as pd
import numpy as np
from sklearn.ensemble import IsolationForest
from datetime import datetime, timedelta

class UEBAEngine:
    """用户行为异常检测引擎"""
    
    def __init__(self, es_client):
        self.es = es_client
        self.baseline_period = 30  # 30天基线
        
    def build_login_baseline(self, user):
        """构建用户登录行为基线"""
        query = {
            "size": 10000,
            "query": {
                "bool": {
                    "must": [
                        {"term": {"event.action": "logon-success"}},
                        {"term": {"user.name": user}},
                        {"range": {"@timestamp": {
                            "gte": f"now-{self.baseline_period}d"
                        }}}
                    ]
                }
            }
        }
        results = self.es.search(index="security-*", body=query)
        logins = [hit["_source"] for hit in results["hits"]["hits"]]
        
        if len(logins) < 10:
            return None
        
        df = pd.DataFrame(logins)
        df["@timestamp"] = pd.to_datetime(df["@timestamp"])
        df["hour"] = df["@timestamp"].dt.hour
        df["day_of_week"] = df["@timestamp"].dt.dayofweek
        
        baseline = {
            "common_hours": df["hour"].value_counts().head(5).index.tolist(),
            "common_days": df["day_of_week"].value_counts().head(5).index.tolist(),
            "common_ips": df["source.ip"].value_counts().head(10).index.tolist(),
            "avg_logins_per_day": len(df) / self.baseline_period,
            "login_hours_std": df["hour"].std()
        }
        return baseline
    
    def detect_anomalies(self, user, events):
        """检测用户行为异常"""
        baseline = self.build_login_baseline(user)
        if not baseline:
            return []
        
        anomalies = []
        for event in events:
            risk_score = 0
            risk_factors = []
            
            # 检查登录时间异常
            event_hour = event["@timestamp"].hour
            if event_hour not in baseline["common_hours"]:
                risk_score += 15
                risk_factors.append(f"unusual_hour_{event_hour}")
            
            # 检查新IP登录
            if event.get("source", {}).get("ip") not in baseline["common_ips"]:
                risk_score += 20
                risk_factors.append("new_source_ip")
            
            # 检查不可能旅行
            # (需要前一登录记录的位置信息)
            
            if risk_score >= 30:
                anomalies.append({
                    "user": user,
                    "event": event,
                    "risk_score": risk_score,
                    "risk_factors": risk_factors,
                    "timestamp": event["@timestamp"]
                })
        
        return sorted(anomalies, key=lambda x: x["risk_score"], reverse=True)

# 使用Isolation Forest进行多维异常检测
def detect_behavior_anomalies(events_df):
    """使用Isolation Forest检测行为异常"""
    features = ["hour", "login_count", "distinct_ips", "data_access_volume"]
    X = events_df[features].values
    
    model = IsolationForest(
        contamination=0.05,  # 预期5%异常
        n_estimators=100,
        random_state=42
    )
    events_df["anomaly_score"] = model.decision_function(X)
    events_df["is_anomaly"] = model.predict(X)
    
    anomalies = events_df[events_df["is_anomaly"] == -1]
    return anomalies.sort_values("anomaly_score")

9. 威胁情报集成

9.1 威胁情报源接入

威胁情报（Threat Intelligence）为SIEM提供IOC（Indicator of Compromise）和TTPs（Tactics, Techniques, and Procedures），增强检测和溯源能力。

情报源	类型	格式	覆盖范围	接入方式	适用场景
商业TIP	商业	STIX/TAXII	广泛、高质量	API订阅	大型企业
OpenCTI	开源	STIX 2.1	可定制	自建平台	自主可控
MISP	开源	MISP JSON	社区贡献	API同步	社区情报
AlienVault OTX	社区	STIX/JSON	广泛	API	免费情报
AbuseIPDB	社区	REST API	恶意IP	API查询	IP信誉
VirusTotal	商业	REST API	文件/域名/IP	API查询	样本分析
微步在线	商业	STIX	中国APT	API	国内威胁
奇安信威胁情报	商业	STIX	国内威胁	API	国内威胁

9.2 IOC自动匹配与告警

python 复制代码

# 威胁情报自动匹配引擎
import requests
import json
from elasticsearch import Elasticsearch

class ThreatIntelEngine:
    """威胁情报匹配与富化引擎"""
    
    def __init__(self, es_config, intel_sources):
        self.es = Elasticsearch(**es_config)
        self.intel_sources = intel_sources
    
    def sync_intel_to_es(self):
        """将威胁情报同步到Elasticsearch"""
        # 从MISP获取情报
        misp_iocs = self.fetch_misp_iocs()
        # 从OpenCTI获取情报
        opencti_iocs = self.fetch_opencti_iocs()
        # 从AbuseIPDB获取恶意IP
        abuseipdb_iocs = self.fetch_abuseipdb_iocs()
        
        all_iocs = misp_iocs + opencti_iocs + abuseipdb_iocs
        
        # 批量写入ES
        actions = []
        for ioc in all_iocs:
            doc = {
                "threat.indicator.type": ioc["type"],
                "threat.indicator.ip": ioc.get("value"),
                "threat.indicator.description": ioc.get("description"),
                "threat.indicator.confidence": ioc.get("confidence", "medium"),
                "threat.indicator.source": ioc.get("source"),
                "threat.indicator.first_seen": ioc.get("first_seen"),
                "threat.indicator.last_seen": ioc.get("last_seen"),
                "threat.indicator.tags": ioc.get("tags", []),
                "@timestamp": datetime.utcnow().isoformat()
            }
            actions.append(doc)
        
        self.es.bulk_index(index="threat-intel-latest", body=actions)
    
    def match_ioc_in_logs(self, log_event):
        """在日志事件中匹配IOC"""
        ioc_fields = ["source.ip", "destination.ip", "url.domain", 
                       "dns.question.name", "file.hash.md5", "file.hash.sha256"]
        
        matches = []
        for field in ioc_fields:
            value = self.get_nested(log_event, field)
            if not value:
                continue
            
            query = {
                "query": {
                    "term": {
                        f"threat.indicator.{field.split('.')[-1]}": value
                    }
                }
            }
            result = self.es.search(index="threat-intel-latest", body=query)
            
            if result["hits"]["total"]["value"] > 0:
                for hit in result["hits"]["hits"]:
                    matches.append({
                        "matched_field": field,
                        "matched_value": value,
                        "intel": hit["_source"]
                    })
        
        return matches
    
    def enrich_with_threat_intel(self, log_event):
        """使用威胁情报富化日志事件"""
        matches = self.match_ioc_in_logs(log_event)
        if matches:
            log_event["threat"] = {
                "matched": matches,
                "intel": {
                    "indicator": matches[0]["intel"].get("threat.indicator"),
                    "description": matches[0]["intel"].get("threat.indicator.description"),
                    "confidence": matches[0]["intel"].get("threat.indicator.confidence")
                }
            }
        return log_event
    
    def fetch_misp_iocs(self):
        """从MISP获取IOC"""
        headers = {"Authorization": self.intel_sources["misp"]["key"],
                   "Content-Type": "application/json",
                   "Accept": "application/json"}
        body = {
            "returnFormat": "json",
            "type": ["ip-src", "ip-dst", "domain", "md5", "sha256"],
            "tags": ["TLP:WHITE", "TLP:GREEN"],
            "last": "30d"
        }
        resp = requests.post(
            f"{self.intel_sources['misp']['url']}/attributes/restSearch",
            headers=headers, json=body, verify=False
        )
        iocs = []
        for attr in resp.json().get("response", {}).get("Attribute", []):
            iocs.append({
                "type": attr["type"],
                "value": attr["value"],
                "description": attr.get("comment", ""),
                "tags": [t["name"] for t in attr.get("Tag", [])],
                "source": "MISP",
                "first_seen": attr.get("first_seen"),
                "last_seen": attr.get("last_seen"),
                "confidence": "high" if any("apt" in t.lower() for t in [x["name"] for x in attr.get("Tag", [])]) else "medium"
            })
        return iocs

9.3 威胁情报富化查询

ruby 复制代码

# Logstash - 威胁情报富化过滤器
filter {
  # 查询威胁情报索引，富化源IP
  elasticsearch {
    hosts => ["https://localhost:9200"]
    index => "threat-intel-latest"
    query => "threat.indicator.ip:%{[source][ip]}"
    result_container => "threat"
    fields => {
      "threat.indicator.description" => "[threat][intel][description]"
      "threat.indicator.confidence" => "[threat][intel][confidence]"
      "threat.indicator.source" => "[threat][intel][source]"
      "threat.indicator.tags" => "[threat][intel][tags]"
    }
    add_tag => ["threat_intel_match"]
  }
  
  # 如果匹配到威胁情报，提升告警级别
  if "threat_intel_match" in [tags] {
    mutate {
      add_field => {
        "alert.severity" => "high"
        "alert.type" => "threat_intel_match"
      }
    }
  }
}

9.4 APT TTPs检测

yaml 复制代码

# Sigma规则 - 基于APT TTPs的检测
# 检测APT29（Cozy Bear）常用工具集
title: APT29 Toolset Detection
id: a29b5fd3-d8e5-4f2a-9b8c-1a2b3c4d5e6f
status: stable
description: |
  Detects tools and techniques commonly used by APT29 (Cozy Bear/Nobelium).
  Based on MITRE ATT&CK and threat intelligence reports.
references:
  - https://attack.mitre.org/groups/G0016
author: SOC Threat Intel Team
date: 2026/08/24
tags:
  - attack.g0016
  - attack.t1071.001
logsource:
  product: windows
  category: process_creation
detection:
  selection_cobalt_strike:
    CommandLine|contains:
      - 'Invoke-CimMethod'
      - 'Invoke-WmiMethod'
      - 'cmd.exe /c powershell'
      - 'powershell -nop -w hidden'
  selection_adfind:
    Image|endswith: '\adfind.exe'
  selection_anydesk:
    Image|endswith: '\anydesk.exe'
  condition: selection_cobalt_strike or selection_adfind or selection_anydesk
falsepositives:
  - Legitimate remote administration tools
level: critical

9.5 情报与SIEM联动配置

python 复制代码

# 完整威胁情报联动配置 - intel_pipeline.py
import schedule
import time
from datetime import datetime

class IntelSyncScheduler:
    """威胁情报同步调度器"""
    
    def __init__(self, engine):
        self.engine = engine
    
    def run_daily_sync(self):
        """每日全量同步"""
        print(f"[{datetime.now()}] Starting daily intel sync...")
        self.engine.sync_intel_to_es()
        print(f"[{datetime.now()}] Daily sync complete.")
    
    def run_hourly_delta_sync(self):
        """每小时增量同步"""
        print(f"[{datetime.now()}] Starting hourly delta sync...")
        # 只同步最近1小时新增的情报
        self.engine.sync_intel_to_es(delta_hours=1)
        print(f"[{datetime.now()}] Delta sync complete.")
    
    def start(self):
        schedule.every().day.at("02:00").do(self.run_daily_sync)
        schedule.every().hour.at(":30").do(self.run_hourly_delta_sync)
        
        while True:
            schedule.run_pending()
            time.sleep(60)

if __name__ == "__main__":
    es_config = {
        "hosts": ["https://localhost:9200"],
        "http_auth": ("elastic", "your_password"),
        "verify_certs": False
    }
    intel_sources = {
        "misp": {"url": "https://misp.local", "key": "your_misp_key"},
        "opencti": {"url": "https://opencti.local", "key": "your_opencti_key"},
        "abuseipdb": {"url": "https://api.abuseipdb.com", "key": "your_key"}
    }
    engine = ThreatIntelEngine(es_config, intel_sources)
    scheduler = IntelSyncScheduler(engine)
    scheduler.start()

10. SOAR自动化响应

10.1 SOAR平台对比

SOAR（Security Orchestration, Automation and Response）平台将安全工具、流程和人员编排起来，实现安全运营的自动化和标准化。

平台	厂商	部署方式	编排语言	优势	劣势	适用规模
Splunk SOAR	Splunk	本地/云	Python	与Splunk深度集成、社区App丰富	授权成本高、学习曲线陡	大型企业
Cortex XSOAR	Palo Alto	本地/云	Python（Ding）	内容库庞大（350+集成）、免费版	重型部署、资源消耗大	中大型企业
IBM Resilient	IBM	本地/云	Python	企业级稳定、案例管理强	界面老旧、定制化受限	大型企业
Tines	Tines	云(SaaS)	YAML/JSON	无代码/低代码、直观易用	功能受限于SaaS	中小企业
Swimlane	Swimlane	本地/云	JSON	低代码可视化、可视化编排	社区生态较小	中型企业
Shuffle	Shuffle	本地/云	Python/YAML	开源免费、可定制	功能不如商业平台	中小企业/靶场

【提示】 靶场和中小型SOC推荐开源的Shuffle；深度Splunk用户选Splunk SOAR；追求快速上手的团队选Tines；国内企业可考虑奇安信NGSOC的编排能力。

10.2 Playbook设计方法论

Playbook是SOAR的核心，定义了从触发到响应的完整自动化流程。一个良好的Playbook应包含以下要素。

要素	说明	示例
触发条件（Trigger）	什么事件启动Playbook	SIEM告警级别>=High
上下文采集（Context）	收集事件相关数据	查询资产库、威胁情报、历史事件
条件分支（Decision）	根据条件决定执行路径	是否确认恶意？
自动动作（Action）	执行自动化响应	隔离主机、封禁IP
人工审核（Approval）	关键操作需人工确认	大范围封禁前确认
通知（Notification）	通知相关人员	邮件/IM通知SOC团队
记录（Audit）	记录所有操作	时间线审计日志
结束（Close）	关闭或转人工	标记为已解决/转调查

10.3 自动化响应动作

动作类别	具体动作	执行方式	影响范围	可逆性
隔离主机	EDR网络隔离	EDR API	单台主机	可逆
封禁IP	防火墙阻断	防火墙API	全网入口	可逆
禁用账号	AD禁用用户	AD/LDAP API	单用户	可逆
阻断域名	DNS sinkhole	DNS服务器API	全网DNS	可逆
终止进程	EDR kill process	EDR API	单主机单进程	不可逆
采集证据	EDR文件收集	EDR API	单主机	不可逆
邮件隔离	邮件服务器隔离	Exchange API	邮箱	可逆
WAF阻断	添加WAF规则	WAF API	Web应用	可逆

10.4 Playbook编写示例

以下是一个完整的SOAR Playbook（Python脚本），实现了从告警触发到自动响应的全流程。

python 复制代码

"""
Playbook: 暴力破解自动响应
触发条件: SIEM告警 - 同一IP 5分钟内超过20次登录失败
响应动作: 查询威胁情报 → 判断风险 → 自动封禁IP → 通知团队 → 记录审计
"""

def playbook_brute_force_response(alert_data):
    """暴力破解自动响应Playbook"""
    
    incident = {
        "id": generate_incident_id(),
        "type": "brute_force",
        "severity": alert_data.get("severity", "high"),
        "status": "investigating",
        "created_at": datetime.utcnow().isoformat(),
        "timeline": []
    }
    
    src_ip = alert_data["src_ip"]
    target_users = alert_data.get("target_users", [])
    failure_count = alert_data.get("failure_count", 0)
    
    log_action(incident, f"Playbook triggered: brute force from {src_ip}, "
                         f"failures={failure_count}, targets={len(target_users)}")
    
    # 步骤1: 上下文采集 - 查询威胁情报
    intel_result = query_threat_intel(src_ip)
    log_action(incident, f"Threat intel query: {intel_result}")
    
    # 步骤2: 上下文采集 - 查询历史事件
    history = query_incident_history(src_ip, days=30)
    log_action(incident, f"Historical incidents: {len(history)} in last 30 days")
    
    # 步骤3: 风险评分
    risk_score = calculate_risk_score(
        failure_count=failure_count,
        intel_match=intel_result.get("is_malicious", False),
        history_count=len(history),
        target_user_count=len(target_users),
        is_critical_user=any(u in CRITICAL_USERS for u in target_users)
    )
    log_action(incident, f"Risk score calculated: {risk_score}")
    
    # 步骤4: 条件分支 - 决定响应动作
    if risk_score >= 80:
        # 高风险 - 需要人工审核后执行
        incident["status"] = "pending_approval"
        log_action(incident, "Risk score >= 80, requesting manual approval")
        
        approval = request_manual_approval(
            incident_id=incident["id"],
            action="block_ip",
            target=src_ip,
            reason=f"Brute force: {failure_count} failures, "
                   f"intel_match={intel_result.get('is_malicious')}, "
                   f"risk={risk_score}",
            timeout=900  # 15分钟超时
        )
        
        if approval["approved"]:
            # 执行封禁
            result = block_ip_firewall(src_ip, duration="24h",
                                       reason=f"Brute force - Incident {incident['id']}")
            log_action(incident, f"IP blocked: {result}")
            
            # 如果匹配威胁情报，延长封禁时间
            if intel_result.get("is_malicious"):
                extend_block_duration(src_ip, "7d")
                log_action(incident, "Block extended to 7 days due to intel match")
            
            # 如果针对关键用户，禁用可能泄露的账号
            if any(u in CRITICAL_USERS for u in target_users):
                for user in target_users:
                    if user in CRITICAL_USERS:
                        force_password_reset(user)
                        log_action(incident, f"Password reset enforced for {user}")
            
            incident["status"] = "resolved_auto"
        else:
            incident["status"] = "rejected"
            log_action(incident, f"Approval rejected: {approval.get('reason')}")
    
    elif risk_score >= 50:
        # 中风险 - 自动封禁
        result = block_ip_firewall(src_ip, duration="4h",
                                   reason=f"Brute force - Incident {incident['id']}")
        log_action(incident, f"IP auto-blocked for 4h: {result}")
        incident["status"] = "resolved_auto"
    
    else:
        # 低风险 - 记录并观察
        log_action(incident, f"Low risk score ({risk_score}), monitoring only")
        incident["status"] = "monitoring"
    
    # 步骤5: 通知
    notify_soc_team(incident)
    if incident["status"] == "resolved_auto":
        notify_asset_owner(src_ip, "IP blocked due to brute force")
    
    # 步骤6: 审计记录
    incident["resolved_at"] = datetime.utcnow().isoformat()
    save_incident(incident)
    log_action(incident, "Playbook execution complete")
    
    return incident


def calculate_risk_score(failure_count, intel_match, history_count, 
                          target_user_count, is_critical_user):
    """计算风险评分"""
    score = 0
    score += min(failure_count * 2, 40)  # 失败次数权重
    score += 30 if intel_match else 0  # 威胁情报匹配
    score += min(history_count * 5, 15)  # 历史记录
    score += min(target_user_count * 3, 10)  # 目标用户数
    score += 15 if is_critical_user else 0  # 关键用户
    return min(score, 100)


def block_ip_firewall(ip, duration, reason):
    """通过防火墙API封禁IP"""
    fw_config = load_config("firewall")
    headers = {"X-Auth-Token": fw_config["api_key"],
               "Content-Type": "application/json"}
    payload = {
        "action": "block",
        "source_ip": ip,
        "duration": duration,
        "reason": reason,
        "rule_name": f"SOAR_Auto_Block_{ip}"
    }
    resp = requests.post(f"{fw_config['url']}/api/v1/rules",
                         headers=headers, json=payload, verify=False)
    return {"status_code": resp.status_code, "rule_id": resp.json().get("rule_id")}


def request_manual_approval(incident_id, action, target, reason, timeout):
    """请求人工审核"""
    # 发送审批请求到IM/工单系统
    approval_request = {
        "incident_id": incident_id,
        "action": action,
        "target": target,
        "reason": reason,
        "timeout": timeout,
        "callback_url": f"{SOAR_URL}/api/approval/callback"
    }
    send_im_approval(approval_request)
    
    # 等待审批结果（轮询或回调）
    deadline = time.time() + timeout
    while time.time() < deadline:
        result = check_approval_status(incident_id)
        if result["status"] in ["approved", "rejected"]:
            return result
        time.sleep(30)
    
    return {"approved": False, "reason": "timeout"}

10.5 人工审核节点设计

对于高风险操作（如大范围封禁、禁用关键账号），必须设计人工审核节点，避免自动化造成的误操作。

python 复制代码

# 人工审核节点配置
APPROVAL_POLICIES = {
    "block_ip_global": {
        "description": "全网IP封禁",
        "auto_approve_threshold": 70,  # 风险评分<70可自动
        "require_approvers": ["soc_manager", "ciso"],  # 需要双重审批
        "timeout_seconds": 900,  # 15分钟超时
        "escalation": ["soc_lead"]  # 超时后升级
    },
    "disable_account_critical": {
        "description": "禁用关键账号",
        "auto_approve_threshold": 999,  # 永不自动审批
        "require_approvers": ["it_manager"],
        "timeout_seconds": 1800,  # 30分钟超时
        "fallback_action": "force_logout",  # 超时后备选动作
    },
    "isolate_host": {
        "description": "隔离主机",
        "auto_approve_threshold": 80,
        "require_approvers": ["soc_lead"],
        "timeout_seconds": 600,
        "escalation": ["soc_manager"]
    },
    "collect_forensics": {
        "description": "采集取证数据",
        "auto_approve_threshold": 50,  # 低风险可自动
        "require_approvers": [],
        "timeout_seconds": 300,
    }
}

10.6 完整SOAR Playbook集

yaml 复制代码

# Playbook: 恶意软件检测自动响应
name: malware_detection_response
trigger:
  type: siem_alert
  conditions:
    alert_type: "malware_detected"
    severity: ["critical", "high"]

workflow:
  - step: context_collection
    actions:
      - action: query_edr
        params:
          hostname: "{{ alert.hostname }}"
          time_range: "-24h"
      - action: query_asset_db
        params:
          hostname: "{{ alert.hostname }}"
      - action: query_threat_intel
        params:
          file_hash: "{{ alert.file_hash }}"
  
  - step: risk_assessment
    actions:
      - action: calculate_risk
        inputs:
          file_hash_intel: "{{ steps.context_collection.results.query_threat_intel }}"
          asset_criticality: "{{ steps.context_collection.results.query_asset_db.criticality }}"
          user_history: "{{ steps.context_collection.results.query_edr }}"
  
  - step: decision_branch
    condition: "{{ steps.risk_assessment.results.risk_score }}"
    branches:
      - condition: ">= 80"
        actions:
          - action: isolate_host
            params:
              hostname: "{{ alert.hostname }}"
          - action: kill_process
            params:
              hostname: "{{ alert.hostname }}"
              pid: "{{ alert.process.pid }}"
          - action: collect_forensics
            params:
              hostname: "{{ alert.hostname }}"
              artifacts: ["memory", "disk", "registry"]
          - action: block_c2_ip
            params:
              ip: "{{ alert.c2_ip }}"
              duration: "7d"
      - condition: ">= 50"
        actions:
          - action: kill_process
            params:
              hostname: "{{ alert.hostname }}"
              pid: "{{ alert.process.pid }}"
          - action: quarantine_file
            params:
              hostname: "{{ alert.hostname }}"
              file_path: "{{ alert.file_path }}"
      - condition: "< 50"
        actions:
          - action: log_only
            message: "Low risk malware, monitoring"
  
  - step: notification
    actions:
      - action: send_notification
        params:
          channel: "soc_team_im"
          message: "Malware detected on {{ alert.hostname }}, risk={{ steps.risk_assessment.results.risk_score }}"
      - action: create_ticket
        params:
          type: "security_incident"
          priority: "{{ alert.severity }}"
          assignee: "soc_l2_team"
  
  - step: audit
    actions:
      - action: record_audit_trail
        params:
          incident_id: "{{ incident.id }}"
          actions_taken: "{{ workflow.actions }}"

11. 安全告警与事件管理

11.1 告警分类与优先级

优先级	级别	响应时间	处理层级	典型场景	通知方式
P0	Critical	15分钟	Tier 3 + 管理层	APT活动、勒索软件、数据外泄	电话+短信+IM
P1	High	30分钟	Tier 2	恶意软件、权限提升、横向移动	短信+IM
P2	Medium	2小时	Tier 1/2	异常登录、策略违规	IM
P3	Low	8小时	Tier 1	低风险扫描、信息收集	工单
P4	Info	24小时	自动化	合规审计、状态变更	日志

11.2 告警去重与聚合策略

python 复制代码

# 告警聚合引擎
from collections import defaultdict
from datetime import datetime, timedelta

class AlertAggregator:
    """告警去重与聚合引擎"""
    
    AGGREGATION_WINDOW = 300  # 5分钟窗口
    MAX_ALERTS_PER_GROUP = 100  # 每组最多100条
    
    def __init__(self):
        self.alert_groups = defaultdict(list)
    
    def aggregate_alert(self, alert):
        """聚合新告警"""
        # 生成聚合键
        agg_key = self._generate_agg_key(alert)
        
        # 清理过期分组
        self._cleanup_expired_groups()
        
        # 添加到分组
        self.alert_groups[agg_key].append(alert)
        
        # 如果分组达到阈值，生成聚合告警
        if len(self.alert_groups[agg_key]) >= self.MAX_ALERTS_PER_GROUP:
            return self._create_aggregated_alert(agg_key)
        
        return None
    
    def _generate_agg_key(self, alert):
        """生成聚合键"""
        # 基于规则ID + 源/目标IP + 用户
        key_fields = [
            alert.get("rule_id", ""),
            alert.get("source.ip", ""),
            alert.get("destination.ip", ""),
            alert.get("user.name", "")
        ]
        return "|".join(str(f) for f in key_fields)
    
    def _create_aggregated_alert(self, agg_key):
        """创建聚合告警"""
        alerts = self.alert_groups[agg_key]
        return {
            "type": "aggregated",
            "rule_id": alerts[0].get("rule_id"),
            "count": len(alerts),
            "first_seen": min(a["@timestamp"] for a in alerts),
            "last_seen": max(a["@timestamp"] for a in alerts),
            "unique_src_ips": list(set(a.get("source.ip") for a in alerts)),
            "unique_dst_ips": list(set(a.get("destination.ip") for a in alerts)),
            "unique_users": list(set(a.get("user.name") for a in alerts)),
            "original_alerts": [a["id"] for a in alerts]
        }

11.3 告警升级与转派流程

复制代码

告警生成 → Tier 1初筛（15分钟）
    ├── 误报 → 关闭并标记原因
    ├── 确认威胁 → 分派处理
    │   ├── 低/中风险 → Tier 1/2处理
    │   └── 高/严重风险 → Tier 2/3处理
    └── 无法判断 → 升级到Tier 2
         ├── Tier 2分析（30分钟）
         │   ├── 需要专家支持 → 升级到Tier 3
         │   └── 可以处理 → 处置
         └── Tier 3调查
              ├── 需要管理层决策 → 通知SOC经理
              └── 可以处理 → 深度调查+处置

11.4 事件管理生命周期

阶段	名称	工作	产出	SLA
1	创建（Create）	告警确认为事件，创建工单	事件工单	即时
2	调查（Investigate）	收集证据、分析攻击链	调查报告	4小时
3	遏制（Contain）	隔离受影响系统、阻断攻击	遏制记录	1小时
4	根除（Eradicate）	清除恶意软件、修复漏洞	根除验证	24小时
5	恢复（Recover）	恢复服务、验证业务	恢复确认	48小时
6	关闭（Close）	事件复盘、文档归档	复盘报告	72小时

11.5 SLA定义表

事件优先级	响应SLA	调查SLA	遏制SLA	解决SLA	升级阈值
P0 Critical	15分钟	1小时	2小时	8小时	30分钟未响应
P1 High	30分钟	4小时	8小时	24小时	1小时未响应
P2 Medium	2小时	8小时	24小时	72小时	4小时未响应
P3 Low	8小时	24小时	48小时	7天	24小时未响应

11.6 告警疲劳缓解策略

策略	方法	效果	实施难度
规则调优	持续优化检测规则，降低误报率	高	中
告警聚合	相同/相似告警合并展示	高	低
白名单	已知良性活动加入白名单	中	低
优先级排序	基于风险评分排序告警	高	中
自动化处置	低风险告警自动关闭	中	中
UEBA补充	行为异常补充规则告警	中	高
疲劳检测	监控分析师处理速率，异常时预警	中	高

12. 安全度量与报表

12.1 SOC KPI指标

指标	全称	计算方法	目标值	意义
MTTD	平均检测时间	事件发生→首次检测	<10分钟	检测能力
MTTR	平均响应时间	首次检测→事件关闭	<4小时	响应能力
MTTC	平均遏制时间	首次检测→遏制完成	<1小时	遏制能力
告警量	日/周/月告警数	直接统计	持续优化	工作量
告警准确率	真阳性/(真阳性+假阳性)	直接计算	>85%	规则质量
检测覆盖率	ATT&CK技术覆盖比例	已覆盖/总数	>70%	检测广度
漏报率	漏报事件/总事件	直接统计	<5%	检测有效性
误报率	假阳性/总告警	直接计算	<15%	规则质量
自动化率	自动处置/总告警	直接统计	>40%	SOAR效果
首次响应率	Tier 1正确分派率	正确/总数	>80%	分析能力

12.2 安全态势看板设计

json 复制代码

// Kibana Dashboard - SOC态势看板配置
{
  "title": "SOC Security Operations Dashboard",
  "panels": [
    {
      "type": "metric",
      "title": "今日告警总数",
      "query": "event.category:security AND @timestamp:[now/d TO now]",
      "aggregation": "count"
    },
    {
      "type": "metric",
      "title": "待处理告警",
      "query": "alert.status:open",
      "aggregation": "count",
      "color": "red"
    },
    {
      "type": "gauge",
      "title": "MTTD（分钟）",
      "query": "stats avg(alert.detect_time)",
      "target": 10,
      "max": 60
    },
    {
      "type": "gauge",
      "title": "MTTR（小时）",
      "query": "stats avg(alert.resolve_time)",
      "target": 4,
      "max": 24
    },
    {
      "type": "pie",
      "title": "告警分布（按严重程度）",
      "query": "groupby alert.severity"
    },
    {
      "type": "bar",
      "title": "告警趋势（7天）",
      "query": "timeseries count() by day",
      "interval": "1d"
    },
    {
      "type": "table",
      "title": "Top 10 告警规则",
      "query": "groupby rule.name | sort -count | limit 10"
    },
    {
      "type": "map",
      "title": "攻击源地理分布",
      "query": "source.geo.location",
      "groupby": "source.geo.country_name"
    },
    {
      "type": "timelion",
      "title": "ATT&CK覆盖趋势",
      "query": ".es(index=attck_coverage, timefield=@timestamp)"
    }
  ]
}

12.3 月度安全报告模板

markdown 复制代码

# 月度安全运营报告 - 2026年8月

## 1. 执行摘要

本月SOC团队共处理安全告警12,450条，确认安全事件23起，其中严重事件2起、
高风险事件7起。平均检测时间（MTTD）为8.5分钟，平均响应时间（MTTR）为
3.2小时，均在SLA范围内。本月检测到1起APT活动（APT29关联），已成功遏制。

## 2. 关键指标

| 指标 | 本月 | 上月 | 趋势 | 目标 |
|------|------|------|------|------|
| 总告警数 | 12,450 | 11,820 | +5% | - |
| 确认事件数 | 23 | 28 | -18% | - |
| MTTD | 8.5min | 9.2min | 改善 | <10min |
| MTTR | 3.2h | 4.1h | 改善 | <4h |
| 误报率 | 12.3% | 14.5% | 改善 | <15% |
| 检测覆盖率 | 72% | 68% | 改善 | >70% |
| 自动化率 | 45% | 38% | 改善 | >40% |

## 3. 事件统计

### 3.1 事件分级

| 级别 | 数量 | 占比 |
|------|------|------|
| Critical | 2 | 8.7% |
| High | 7 | 30.4% |
| Medium | 10 | 43.5% |
| Low | 4 | 17.4% |

### 3.2 事件类型

| 类型 | 数量 |
|------|------|
| 恶意软件 | 8 |
| 账户接管 | 5 |
| 数据外泄 | 2 |
| 横向移动 | 4 |
| 策略违规 | 4 |

## 4. 重大事件回顾

### 事件 #2026-08-001: APT29钓鱼攻击

| 项目 | 详情 |
|------|------|
| 发现时间 | 2026-08-15 09:32 |
| 检测方式 | UEBA + 威胁情报 |
| MTTD | 6分钟 |
| MTTR | 2.5小时 |
| 影响 | 3台主机被感染，0数据泄露 |
| 根因 | 钓鱼邮件附件执行 |
| 整改 | 邮件网关规则更新、EDR检测增强 |

## 5. 改进计划

| 改进项 | 责任人 | 截止日期 | 状态 |
|--------|--------|---------|------|
| Sigma规则库扩充 | Tier3 | 2026-09-15 | 进行中 |
| UEBA基线优化 | Tier3 | 2026-09-30 | 计划中 |
| SOAR Playbook新增 | Tier2 | 2026-09-10 | 进行中 |
| 威胁狩猎计划 | Tier3 | 2026-09-20 | 计划中 |

13. 安全运营最佳实践

13.1 安全运营SOP

标准操作流程（SOP）是确保SOC运营一致性和质量的基础。

SOP编号	流程名称	触发条件	责任人	核心步骤
SOP-001	告警处理流程	告警生成	Tier1/2	分派→初筛→分析→处置→关闭
SOP-002	事件响应流程	事件确认	Tier2/3	创建→调查→遏制→根除→恢复→关闭
SOP-003	事件升级流程	超时/高风险	所有	评估→通知→升级→记录
SOP-004	威胁狩猎流程	定期/触发式	Tier3	假设→查询→验证→文档→规则
SOP-005	规则开发流程	新威胁发现	Tier3	需求→开发→测试→部署→调优
SOP-006	知识库更新流程	事件关闭后	Tier1/2	复盘→文档→审核→发布
SOP-007	轮班交接流程	每班次	所有	待办→事件→风险→签字

13.2 轮班与交接管理

复制代码

交接清单模板：
┌─────────────────────────────────────────────┐
│ 班次：白班 08:00-20:00 → 夜班 20:00-08:00  │
│ 交接时间：2026-08-24 20:00                  │
│ 交出人：张三    接收人：李四                │
├─────────────────────────────────────────────┤
│ 1. 进行中事件                                │
│    - INC-001 (High): 暴力破解，已封禁IP    │
│      待办：持续监控4小时                    │
│    - INC-002 (Medium): 异常DNS，调查中     │
│      待办：等待威胁情报返回                  │
│ 2. 待处理告警                               │
│    - 共15条Medium告警，已按优先级排序       │
│ 3. SOAR自动处置中                           │
│    - Playbook: malware_response (3个执行中) │
│ 4. 已知风险/注意事项                         │
│    - VPN网关今晨异常，已上报网络组          │
│    - 威胁情报同步任务凌晨2点执行            │
│ 5. 设备状态                                 │
│    - 所有SIEM节点正常                      │
│    - Kafka积压<1000（正常）                │
├─────────────────────────────────────────────┤
│ 交接人签字：__________ 接收人签字：________  │
└─────────────────────────────────────────────┘

13.3 知识库建设

知识库是SOC积累和传承经验的核心载体，建议使用Confluence或Wiki搭建。

知识库模块	内容	维护人	更新频率
事件案例库	历史事件分析、攻击链、处置记录	Tier2/3	每次事件后
检测规则库	Sigma规则文档、误报/漏报记录	Tier3	规则变更时
工具手册	SIEM/SOAR/EDR操作指南	所有	季度
威胁情报库	APT组织档案、TTPs总结	Tier3	月度
SOP文档	标准操作流程	SOC经理	半年
培训资料	新人培训、技能提升	Tier3	季度
复盘报告	事件复盘、改进追踪	Tier2/3	每次事件后

13.4 红蓝对抗演练（Purple Team）

紫队（Purple Team）是红蓝对抗的融合体，通过有计划的对抗演练验证和提升蓝队检测能力。

复制代码

紫队演练流程：

1. 计划阶段
   - 确定演练目标（如ATT&CK T1003 LSASS转储检测）
   - 红队设计攻击路径（按ATT&CK技术编排）
   - 蓝队准备检测规则和监控
   
2. 执行阶段
   - 红队按计划执行攻击（可控环境）
   - 蓝队实时监控和检测
   - 记录红队每步操作和蓝队检测响应
   
3. 评估阶段
   - 生成覆盖率矩阵（ATT&CK技术 vs 检测规则）
   - 计算检测率、MTTD、MTTR
   - 识别检测盲区
   
4. 改进阶段
   - 针对盲区编写新检测规则
   - 优化现有规则
   - 更新Playbook
   - 下次演练验证改进效果

13.5 威胁狩猎实践

sql 复制代码

# 威胁狩猎示例 - 基于假设的主动狩猎

# 狩猎假设1: 攻击者可能使用Living off the Land（LotL）技术
# 狩猎目标: 查找系统自带工具的可疑使用模式

index=windows EventCode=4688
| search (Image IN ("*\certutil.exe", "*\bitsadmin.exe", "*\mshta.exe", 
                     "*\rundll32.exe", "*\regsvr32.exe", "*\msiexec.exe",
                     "*\wmic.exe", "*\scriptrunner.exe", "*\forfiles.exe"))
| eval is_suspicious = case(
    match(CommandLine, "(http|https|ftp|download)"), 1,
    match(CommandLine, "(base64|encoded|decode|encode)"), 1,
    match(CommandLine, "(temp|appdata|public|programdata)"), 1,
    match(CommandLine, "(powershell|cmd|wscript|cscript)"), 1,
    1=1, 0
)
| search is_suspicious=1
| stats count, values(Image) as tools, values(CommandLine) as commands by user, ComputerName
| table _time, user, ComputerName, tools, commands, count

13.6 安全运营持续改进（PDCA）

阶段	名称	核心活动	输出	频率
Plan	计划	制定安全目标、识别风险、规划改进	改进计划	季度
Do	执行	实施改进措施、开发新规则、部署新工具	实施记录	持续
Check	检查	度量KPI、评估效果、识别差距	评估报告	月度
Act	处理	标准化有效措施、调整无效措施	更新文档	季度

13.7 安全运营checklist

编号	检查项	责任人	频率
1	SIEM日志源连通性检查	Tier1	每班次
2	关键日志源EPS监控	Tier1	每小时
3	Elasticsearch集群健康状态	Tier1	每班次
4	Kafka积压队列检查	Tier1	每小时
5	告警队列积压检查	Tier1	每小时
6	SOAR Playbook执行状态	Tier1	每班次
7	威胁情报同步状态	Tier2	每日
8	检测规则覆盖率评估	Tier3	每周
9	误报率监控与规则调优	Tier3	每周
10	UEBA模型健康检查	Tier3	每周
11	安全设备证书有效期	Tier2	每月
12	备份与灾备验证	Tier2	每月
13	KPI指标度量与汇报	SOC经理	每月
14	知识库内容更新	Tier2/3	每次事件
15	ATT&CK覆盖矩阵更新	Tier3	每月
16	红蓝对抗演练	Tier3	每季度
17	威胁狩猎计划执行	Tier3	每周
18	安全补丁与规则更新	Tier2	每周
19	员工培训与技能提升	SOC经理	每季度
20	运营流程评审与优化	SOC经理	每季度
21	供应商/托管服务评估	SOC经理	每半年
22	合规性审计检查	SOC经理	每季度

14. 自动化与AI赋能

14.1 SOAR自动化场景

场景	触发	自动化动作	人工介入	预期效果
暴力破解	20+次失败/5分钟	封禁IP+通知	高风险需审核	MTTR从30min→2min
恶意软件	EDR检测	隔离主机+杀进程+取证	确认后根除	MTTR从1h→10min
钓鱼邮件	用户上报	隔离邮件+移除附件	调查钓鱼链接	响应从2h→15min
异常DNS	DNS隧道检测	阻断域名+告警	分析通信内容	MTTD从30min→5min
凭据泄露	暗网监控命中	强制密码重置+通知用户	确认账号	响应从4h→30min
资产发现	新设备上线	资产登记+基线扫描	验证授权	自动化资产盘点
合规审计	定时触发	生成报告+分发	审核后发布	报告生成自动化

14.2 AI辅助告警分类

利用大语言模型（LLM）辅助告警分析和分类，减少分析师工作量。

python 复制代码

# AI辅助告警分类 - LLM集成示例
import openai
import json

class AIAlertClassifier:
    """AI辅助告警分类器"""
    
    def __init__(self, api_key, model="gpt-4"):
        self.client = openai.OpenAI(api_key=api_key)
        self.model = model
    
    def classify_alert(self, alert):
        """使用LLM对告警进行分类和建议"""
        prompt = self._build_classification_prompt(alert)
        
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[
                {"role": "system", "content": "你是一名网络安全分析师，"
                 "请根据告警信息进行分类、风险评估和处置建议。"
                 "请严格基于提供的信息分析，不要编造细节。"
                 "输出JSON格式。"},
                {"role": "user", "content": prompt}
            ],
            temperature=0.3,
            response_format={"type": "json_object"}
        )
        
        result = json.loads(response.choices[0].message.content)
        return result
    
    def _build_classification_prompt(self, alert):
        """构建分类提示"""
        return f"""
请分析以下安全告警并输出分类结果：

告警信息：
- 类型: {alert.get('alert_type')}
- 严重程度: {alert.get('severity')}
- 规则名称: {alert.get('rule_name')}
- 源IP: {alert.get('source_ip')}
- 目标IP: {alert.get('destination_ip')}
- 用户: {alert.get('user')}
- 时间: {alert.get('timestamp')}
- 描述: {alert.get('description')}
- 日志片段: {alert.get('log_snippet')}

请输出以下JSON格式：
{{
    "classification": "true_positive/false_positive/needs_investigation",
    "confidence": 0.0-1.0,
    "attack_technique": "ATT&CK技术ID（如适用）",
    "risk_assessment": "low/medium/high/critical",
    "recommended_actions": ["动作1", "动作2"],
    "explanation": "分析说明",
    "false_positive_indicators": ["可能的误报原因"]
}}
"""
    
    def enrich_with_context(self, alert):
        """使用AI为告警添加上下文分析"""
        # 查询历史相似告警
        similar = self._find_similar_alerts(alert)
        
        prompt = f"""
基于以下告警和历史数据，提供上下文分析：

当前告警: {json.dumps(alert, indent=2)}

历史相似告警 (近30天):
{json.dumps(similar[:5], indent=2)}

请分析：
1. 该告警是否为已知模式的重复？
2. 是否存在攻击升级趋势？
3. 建议的优先级调整？
"""
        response = self.client.chat.completions.create(
            model=self.model,
            messages=[{"role": "user", "content": prompt}],
            temperature=0.3
        )
        return response.choices[0].message.content

14.3 自动化威胁狩猎

python 复制代码

# AI驱动的自动化威胁狩猎
class AIThreatHunter:
    """AI辅助威胁狩猎引擎"""
    
    def __init__(self, es_client, ml_model):
        self.es = es_client
        self.ml = ml_model
    
    def hunt_anomalous_patterns(self, timeframe="7d"):
        """使用ML检测异常模式进行威胁狩猎"""
        # 获取基线数据
        baseline = self._get_baseline_data(timeframe)
        
        # 使用Isolation Forest检测异常
        anomalies = self.ml.predict_anomalies(baseline)
        
        # 对每个异常进行深入调查
        hunting_results = []
        for anomaly in anomalies:
            result = self._investigate_anomaly(anomaly)
            hunting_results.append(result)
        
        return sorted(hunting_results, key=lambda x: x["confidence"], reverse=True)
    
    def _investigate_anomaly(self, anomaly):
        """深入调查异常"""
        # 查询相关上下文
        context = {
            "user_history": self._query_user_history(anomaly["user"]),
            "asset_info": self._query_asset_info(anomaly["host"]),
            "threat_intel": self._query_threat_intel(anomaly["ip"]),
            "similar_events": self._query_similar_events(anomaly)
        }
        
        # 使用LLM生成狩猎假设
        hypothesis = self._generate_hypothesis(anomaly, context)
        
        return {
            "anomaly": anomaly,
            "context": context,
            "hypothesis": hypothesis,
            "confidence": self._calculate_confidence(anomaly, context),
            "recommendation": self._generate_recommendation(anomaly, context)
        }

14.4 自动化报告生成

python 复制代码

# 自动化安全报告生成
class SecurityReportGenerator:
    """安全报告自动生成器"""
    
    def generate_monthly_report(self, month):
        """生成月度安全报告"""
        # 收集数据
        metrics = self._collect_metrics(month)
        incidents = self._collect_incidents(month)
        trends = self._analyze_trends(month)
        
        # 使用LLM生成报告文本
        report = self._llm_generate_report(metrics, incidents, trends)
        
        # 生成图表
        charts = self._generate_charts(metrics)
        
        # 组装最终报告
        final_report = self._assemble_report(report, charts)
        
        return final_report
    
    def _llm_generate_report(self, metrics, incidents, trends):
        """使用LLM生成报告文本"""
        prompt = f"""
请基于以下安全运营数据生成月度报告：

关键指标:
{json.dumps(metrics, indent=2)}

事件列表:
{json.dumps(incidents[:10], indent=2)}

趋势分析:
{json.dumps(trends, indent=2)}

请生成包含以下部分的报告：
1. 执行摘要（面向管理层，200字以内）
2. 关键指标分析
3. 事件统计与分析
4. 趋势与展望
5. 改进建议
"""
        # 调用LLM生成...
        pass

14.5 ChatGPT/Copilot在安全运营中的应用

应用场景	使用方式	价值	注意事项
告警分析	输入告警日志，AI辅助分析	加速分析、减少误判	敏感数据不出境
规则编写	AI辅助编写Sigma/SPL规则	降低开发门槛	人工审核规则
调查辅助	AI建议调查方向和查询语句	拓展分析思路	验证AI建议
报告生成	AI生成事件报告初稿	节省文档时间	人工修正
知识查询	查询ATT&CK技术、漏洞信息	快速获取信息	验证准确性
代码审计	AI辅助分析可疑脚本	加速分析	不可完全依赖

【提示】 在安全运营中使用AI/LLM时，务必注意数据安全：不要将敏感日志、内部IP、用户凭证等数据发送到外部AI服务。建议使用私有化部署的LLM（如本地Llama/Ollama）或确保API供应商签署数据处理协议（DPA），符合数据安全合规要求。

15. 靶场实战：完整SOC搭建

15.1 环境规划

本节将演示如何从零搭建一个功能完整的SOC靶场环境，涵盖日志收集、解析建模、检测规则、告警管理、SOAR响应、威胁狩猎和度量报表的完整流程。

组件	技术选型	资源需求	部署方式
日志存储	ELK Stack 8.x	8核/16GB/200GB	Docker
日志采集	Filebeat/Winlogbeat	2核/4GB	Agent安装
消息队列	Kafka 3.x	4核/8GB/100GB	Docker
日志解析	Logstash 8.x	4核/8GB	Docker
检测规则	Sigma + ElastAlert	2核/4GB	Docker
威胁情报	OpenCTI 5.x	4核/8GB/50GB	Docker
SOAR平台	Shuffle	4核/8GB/50GB	Docker
可视化	Kibana / Grafana	2核/4GB	Docker
攻击模拟	Caldera / Atomic Red Team	2核/4GB	脚本执行
总计	-	30核/60GB/500GB+	Docker Compose

15.2 Docker Compose部署

yaml 复制代码

# docker-compose.yml - 完整SOC靶场编排
version: '3.8'

services:
  # Elasticsearch - 日志存储
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.12.0
    container_name: soc-es
    environment:
      - node.name=soc-es
      - cluster.name=soc-elk
      - discovery.type=single-node
      - xpack.security.enabled=true
      - ELASTIC_PASSWORD=Soctest123!
      - "ES_JAVA_OPTS=-Xms4g -Xmx4g"
      - bootstrap.memory_lock=true
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - es_data:/usr/share/elasticsearch/data
      - ./config/es/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml
      - ./config/es/certs:/usr/share/elasticsearch/config/certs
    ports:
      - "9200:9200"
    networks:
      - soc-net

  # Kibana - 可视化
  kibana:
    image: docker.elastic.co/kibana/kibana:8.12.0
    container_name: soc-kibana
    environment:
      - ELASTICSEARCH_HOSTS=https://elasticsearch:9200
      - ELASTICSEARCH_USERNAME=elastic
      - ELASTICSEARCH_PASSWORD=Soctest123!
      - ELASTICSEARCH_SSL_CERTIFICATEAUTHORITIES=/usr/share/kibana/config/certs/ca.crt
    volumes:
      - ./config/kibana/kibana.yml:/usr/share/kibana/config/kibana.yml
      - ./config/es/certs/ca.crt:/usr/share/kibana/config/certs/ca.crt
    ports:
      - "5601:5601"
    depends_on:
      - elasticsearch
    networks:
      - soc-net

  # Logstash - 日志解析与富化
  logstash:
    image: docker.elastic.co/logstash/logstash:8.12.0
    container_name: soc-logstash
    volumes:
      - ./config/logstash/pipelines:/usr/share/logstash/pipeline
      - ./config/logstash/patterns:/etc/logstash/patterns
      - ./config/logstash/geoip:/etc/logstash/geoip
      - ./config/es/certs/ca.crt:/etc/logstash/certs/ca.crt
    environment:
      - ES_PASSWORD=Soctest123!
    ports:
      - "5044:5044"
    depends_on:
      - elasticsearch
    networks:
      - soc-net

  # Kafka - 消息缓冲
  kafka:
    image: confluentinc/cp-kafka:7.5.0
    container_name: soc-kafka
    environment:
      KAFKA_BROKER_ID: 1
      KAFKA_ZOOKEEPER_CONNECT: zookeeper:2181
      KAFKA_ADVERTISED_LISTENERS: PLAINTEXT://kafka:9092
      KAFKA_OFFSETS_TOPIC_REPLICATION_FACTOR: 1
      KAFKA_AUTO_CREATE_TOPICS_ENABLE: "true"
    ports:
      - "9092:9092"
    depends_on:
      - zookeeper
    networks:
      - soc-net

  zookeeper:
    image: confluentinc/cp-zookeeper:7.5.0
    container_name: soc-zookeeper
    environment:
      ZOOKEEPER_CLIENT_PORT: 2181
    networks:
      - soc-net

  # ElastAlert - 检测告警引擎
  elastalert:
    image: jertel/elastalert2:2.14.0
    container_name: soc-elastalert
    volumes:
      - ./config/elastalert/rules:/opt/elastalert/rules
      - ./config/elastalert/config.yaml:/opt/elastalert/config.yaml
    depends_on:
      - elasticsearch
    networks:
      - soc-net

  # OpenCTI - 威胁情报平台
  opencti:
    image: opencti/platform:5.12.15
    container_name: soc-opencti
    environment:
      - NODE_OPTIONS=--max-old-space-size=2048
      - APP__BASE_PATH=/
      - APP__ADMIN__EMAIL=admin@soc.local
      - APP__ADMIN__PASSWORD=Soctest123!
      - APP__ADMIN__TOKEN=your-opencti-token
      - ELASTICSEARCH__URL=http://elasticsearch:9200
      - ELASTICSEARCH__USERNAME=elastic
      - ELASTICSEARCH__PASSWORD=Soctest123!
      - REDIS__HOSTNAME=redis
      - GRAKN__HOSTNAME=grakn
      - MINIO__ENDPOINT=minio
      - RABBITMQ__HOSTNAME=rabbitmq
    depends_on:
      - elasticsearch
      - redis
      - grakn
      - minio
      - rabbitmq
    ports:
      - "8080:8080"
    networks:
      - soc-net

  redis:
    image: redis:7.2
    container_name: soc-redis
    networks:
      - soc-net

  grakn:
    image: graknlabs/grakn:2.1.2
    container_name: soc-grakn
    networks:
      - soc-net

  minio:
    image: minio/minio:latest
    container_name: soc-minio
    environment:
      MINIO_ROOT_USER: minioadmin
      MINIO_ROOT_PASSWORD: minioadmin
    command: server /data
    networks:
      - soc-net

  rabbitmq:
    image: rabbitmq:3.12-management
    container_name: soc-rabbitmq
    networks:
      - soc-net

  # Shuffle - SOAR平台
  shuffle:
    image: ghcr.io/shuffle/shuffle-backend:latest
    container_name: soc-shuffle
    environment:
      - SHUFFLE_APP_HOTLOAD=true
      - DATA_REDIS_HOST=shuffle-redis
    volumes:
      - shuffle_data:/shuffle
    ports:
      - "3001:3333"
    depends_on:
      - shuffle-redis
    networks:
      - soc-net

  shuffle-redis:
    image: redis:7.2
    container_name: shuffle-redis
    networks:
      - soc-net

  # Grafana - 度量看板
  grafana:
    image: grafana/grafana:latest
    container_name: soc-grafana
    environment:
      - GF_SECURITY_ADMIN_PASSWORD=Soctest123!
    ports:
      - "3000:3000"
    networks:
      - soc-net

volumes:
  es_data:
  shuffle_data:

networks:
  soc-net:
    driver: bridge

15.3 逐步演示流程

步骤1: 日志收集

bash 复制代码

# 启动SOC靶场
docker compose up -d

# 验证所有服务正常
docker compose ps

# 安装Winlogbeat到测试Windows主机
# 配置输出到Logstash
# filebeat.yml配置输出到Kafka

# 验证日志流入
curl -u elastic:Soctest123! -k "https://localhost:9200/_cat/indices?v"

步骤2: 解析建模

bash 复制代码

# 部署Index Template
curl -u elastic:Soctest123! -k -X PUT "https://localhost:9200/_index_template/security-logs" \
  -H "Content-Type: application/json" -d @config/es/index-template.json

# 创建ILM策略
curl -u elastic:Soctest123! -k -X PUT "https://localhost:9200/_ilm/policy/security-logs-policy" \
  -H "Content-Type: application/json" -d @config/es/ilm-policy.json

# 验证数据流入和解析
curl -u elastic:Soctest123! -k "https://localhost:9200/nginx-access-*/_search?pretty" -d '{
  "query": {"match_all": {}}, "size": 5
}'

步骤3: 检测规则部署

bash 复制代码

# 安装Sigma CLI
pip install sigmatools

# 将Sigma规则转换为ElastAlert规则
sigma convert -t elastalert -c es-ecs rules/*.yml -o config/elastalert/rules/

# 重启ElastAlert加载新规则
docker restart soc-elastalert

# 验证规则加载
docker logs soc-elastalert 2>&1 | grep "Loaded"

步骤4: 告警管理

kql 复制代码

// 在Kibana中查看告警
// 创建告警索引模式
// 设置告警看板

// KQL查询待处理告警
alert.status: "open" AND alert.severity: ["high", "critical"]
| sort @timestamp desc

步骤5: SOAR响应

bash 复制代码

# 访问Shuffle Web界面
# http://localhost:3001

# 导入Playbook
# 创建Workflow: brute_force_response
# 配置触发器: Elasticsearch Alert Webhook
# 添加动作: HTTP Request (Firewall API)
# 添加条件: Risk Score分支
# 添加通知: IM Webhook
# 启用Workflow

步骤6: 威胁狩猎

kql 复制代码

// 在Kibana Discover或ESQL中执行狩猎查询

// 狩猎1: 查找LotL可疑工具使用
event.category: "process" AND process.name: ("certutil.exe" OR "bitsadmin.exe" OR "mshta.exe") 
  AND process.command_line: (*http* OR *download* OR *base64*)

// 狩猎2: 查找异常网络连接
event.category: "network" AND NOT destination.ip: (10.0.0.0/8 OR 172.16.0.0/12 OR 192.168.0.0/16)
  AND destination.port: (4444 OR 8443 OR 8888)

步骤7: 度量报表

json 复制代码

// 在Kibana Dashboard中创建SOC度量看板
// 核心指标面板：
// 1. 今日告警总数（Metric）
// 2. MTTD趋势（Time Series）
// 3. MTTR趋势（Time Series）
// 4. 告警按严重程度分布（Pie）
// 5. Top 10检测规则触发（Bar）
// 6. ATT&CK覆盖矩阵（Heatmap）
// 7. 自动化处置率（Gauge）
// 8. 攻击源地理分布（Map）

15.4 验证与测试

bash 复制代码

# 使用Atomic Red Team模拟攻击验证检测能力
# 安装Atomic Red Team
Invoke-WebRequest -Uri "https://github.com/redcanaryco/atomic-red-team/raw/master/atomics/T1003.001/T1003.001.yaml" -OutFile T1003.001.yaml

# 执行T1003.001 LSASS转储模拟
Invoke-AtomicTest T1003.001

# 验证SIEM是否检测到
curl -u elastic:Soctest123! -k "https://localhost:9200/_search" -d '{
  "query": {"match": {"event.code": "10"}},
  "filter": [{"range": {"@timestamp": {"gte": "now-5m"}}}]
}'

# 使用Caldera进行自动化对抗测试
# 配置Caldera Agent
# 执行攻击链模拟
# 查看SOC检测结果和响应时间

16. 总结与参考资源

16.1 SOC建设检查清单

编号	检查项	类别	重要性	验证方法
1	日志源覆盖率>90%	日志收集	高	资产清单对照
2	日志标准化符合ECS/CIM	数据建模	高	字段抽样检查
3	SIEM集群高可用	基础设施	高	故障切换测试
4	检测规则覆盖ATT&CK>70%	检测能力	高	覆盖矩阵评估
5	告警误报率<15%	告警质量	高	月度统计
6	MTTD<10分钟	响应能力	高	指标度量
7	MTTR<4小时	响应能力	高	指标度量
8	SOAR自动化率>40%	自动化	中	Playbook统计
9	威胁情报同步<1小时	情报集成	中	同步日志
10	UEBA模型覆盖核心用户	行为分析	中	模型列表
11	7x24监控覆盖	运营	高	排班表
12	事件响应SOP完整	流程	高	SOP文档
13	知识库持续更新	知识管理	中	更新记录
14	定期红蓝对抗	持续改进	中	演练记录
15	合规报表自动生成	合规	中	报表模板
16	数据保留符合合规要求	合规	高	ILM策略
17	安全事件复盘率100%	持续改进	高	复盘记录
18	分析师培训计划	人才	中	培训计划
19	供应商/服务评估	运营	低	评估报告
20	灾备与恢复验证	基础设施	高	恢复测试

16.2 检测规则速查表

攻击场景	ATT&CK ID	日志源	关键事件/字段	Sigma规则名
LSASS转储	T1003.001	Sysmon ProcessAccess	TargetImage=lsass.exe	lsass_memory_access
PowerShell编码执行	T1059.001	Windows 4104	-EncodedCommand	ps_encoded_command
计划任务持久化	T1053.005	Windows 4698	TaskName/TaskContent	schtask_creation
服务安装持久化	T1543.003	Windows 7045	ServiceFileName	service_install
注册表自启	T1060	Sysmon 12/13	Run/RunOnce	registry_persistence
横向移动SMB	T1021.002	Windows 5140	ShareName=C$	smb_share_access
PsExec远程执行	T1569.002	Windows 4688	Image=psexec.exe	psexec_execution
DNS隧道	T1071.004	DNS日志	query长度>50	dns_tunneling
Webshell访问	T1505.003	Web日志	cmd.php/shell.php	webshell_access
SQL注入	T1190	Web日志	union select等	sqli_attempt
勒索软件加密	T1486	文件日志	批量文件修改	ransomware_encryption
钓鱼附件执行	T1566	Windows 4688	ParentImage=Office	macro_execution

16.3 Splunk SPL速查表

sql 复制代码

# 基础搜索
index=<index> sourcetype=<type> <keyword>

# 时间范围
index=* earliest=-1h@h latest=now

# 统计
| stats count, avg(field), sum(field), dc(field) by group_field

# 过滤
| search field=value
| where field > 100
| regex field="pattern"

| eval new_field = case(condition1, value1, condition2, value2, 1=1, default)
| eval concat = field1 . "-" . field2

# 排序与限制
| sort -count    # 降序
| sort field     # 升序
| head 10
| tail 10

# 时间分桶
| bucket _time span=1h
| stats count by _time, field

# 关联
| join field [search subsearch]
| append [search subsearch]
| lookup lookup_table field OUTPUT result_field

# 格式化输出
| table field1, field2, field3
| fields field1, field2
| rename field as "Display Name"

# 条件
| where count > 10
| search NOT (field=value)
| dedup field

# 聚合时间序列
| timechart span=1h count by field
| tstats count from datamodel by field

16.4 Elasticsearch KQL/ESQL速查表

kql 复制代码

// KQL - Lucene语法
field: value                    // 精确匹配
field: "phrase value"           // 短语匹配
field: val*                     // 通配符
field: [1 TO 100]               // 范围
field: (val1 OR val2)           // 逻辑或
field: (val1 AND val2)          // 逻辑与
NOT field: value                // 逻辑非
field.keyword: exact            // 精确匹配（不分词）
@timestamp: [now-1h TO now]     // 时间范围

// ESQL - 管道式查询
FROM index-*
| WHERE field == "value"
| STATS count = COUNT(*) BY group_field
| SORT count DESC
| LIMIT 10
| KEEP field1, field2

// 多索引关联
FROM index1 AS a, index2 AS b
| WHERE a.id == b.ref_id
| STATS count BY a.name, b.value

16.5 工具速查表

工具	类别	功能	官网/仓库
ELK Stack	SIEM	日志收集、存储、分析	elastic.co
Splunk	SIEM	日志分析、告警	splunk.com
Microsoft Sentinel	SIEM	云原生SIEM	azure.microsoft.com/sentinel
Sigma	检测规则	通用检测规则格式	github.com/SigmaHQ/sigma
ElastAlert	告警引擎	ES告警引擎	github.com/jertel/elastalert2
OpenCTI	威胁情报	情报管理平台	opencti.io
MISP	威胁情报	情报共享平台	misp-project.org
Shuffle	SOAR	开源SOAR平台	shuffle.dev
Splunk SOAR	SOAR	商业SOAR	splunk.com/soar
Cortex XSOAR	SOAR	商业SOAR	cortex.paloaltonetworks.com
Atomic Red Team	攻击模拟	ATT&CK技术测试	github.com/redcanaryco/atomic-red-team
MITRE Caldera	攻击模拟	自动化对抗平台	github.com/mitre/caldera
Zeek	网络分析	网络流量分析	zeek.org
Suricata	IDS/IPS	入侵检测	suricata.io
Sysmon	端点监控	Windows系统监控	microsoft.com/sysinternals
Velociraptor	DFIR	端点取证	velociraptor.app
Grafana	可视化	度量看板	grafana.com
TheHive	事件管理	协同事件响应	thehive-project.org
CyberChef	数据处理	日志解析/解码	gchq.github.io/CyberChef
YARA	规则匹配	恶意软件识别	virustotal.github.io/yara

16.6 参考资源列表

资源	类型	链接	说明
MITRE ATT&CK	框架	attack.mitre.org	攻击技术知识库
NIST CSF	框架	nist.gov/cyberframework	网络安全框架
NIST SP 800-61	标准	nist.gov	事件响应指南
ISO 27035	标准	iso.org	事件管理标准
Sigma规则库	规则库	github.com/SigmaHQ/sigma	社区检测规则
ELK安全文档	文档	elastic.co/guide	ELK官方文档
Splunk文档	文档	docs.splunk.com	Splunk官方文档
MITRE D3FEND	框架	d3fend.mitre.org	防御技术知识库
FIRST CSIRT	社区	first.org	事件响应团队
CIS Controls	标准	cisecurity.org	安全控制基准

16.7 合规声明

【合规声明】 本文所有技术内容、检测规则、配置示例和脚本代码仅用于授权安全测试、防御能力建设、安全学习和学术研究目的。所有演示均在隔离靶场环境中完成，未涉及任何真实生产系统或第三方系统。未经书面授权对任何信息系统进行安全测试、渗透测试或攻击行为均属违法行为，可能触犯《中华人民共和国网络安全法》《中华人民共和国数据安全法》《中华人民共和国个人信息保护法》及相关法律法规。读者应确保在合法授权范围内使用本文所述技术和工具，并对自身行为的合法性承担全部责任。本文作者和发布平台不对任何因不当使用本文内容而产生的法律后果承担责任。

16.8 结语

SOC建设是一个持续演进的过程，没有终点。从日志收集到威胁狩猎，从规则检测到AI赋能，每一步都需要团队的持续投入和迭代优化。关键不在于工具多先进，而在于人员能力、流程成熟度和工具适配度的平衡发展。

蓝队防御的核心心法：看得见（全面日志收集）、看得懂（检测规则与数据建模）、防得住（SOAR自动响应）、追得到（威胁狩猎与情报）、学得快（持续改进与知识积累）。希望本文能为你的SOC建设之路提供有价值的参考和实战指导。

安全是一场永无止境的攻防博弈，蓝队永远是最后一道防线。保持学习，保持警惕，保持敬畏。