CTI 보고서 기반 공격 패턴 라이브러리 구축은(는) 무엇을 하나요?
개요
Mandiant, CrowdStrike, Talos, Microsoft 등과 같은 벤더의 사이버 위협 인텔리전스(CTI) 보고서는 구조화된 공격 패턴 라이브러리로 추출, 정규화 및 분류할 수 있는 공격자 행동에 대한 상세한 설명을 포함합니다. 이 기술은 CTI 보고서를 파싱하여 공격자 기술을 추출하고, 행동을 MITRE ATT&CK 기술 ID에 매핑하고, STIX 2.1 Attack Pattern 객체를 생성하고, 전술, 기술 및 위협 행위자별로 색인된 검색 가능한 라이브러리를 구축하며, 문서화된 패턴에서 탐지 규칙 템플릿을 생성하는 방법을 다룹니다.
사용 시기
- 환경에서 CTI 보고서 기반 공격 패턴 라이브러리 구축 기능을 배포하거나 구성할 때
- 규정 준수 요구 사항에 맞춰 보안 제어를 수립할 때
- 이 도메인에 대한 보안 아키텍처를 구축하거나 개선할 때
- 이 구현이 필요한 보안 평가를 수행할 때
사전 준비 사항
- Python 3.9+ (
stix2,mitreattack-python,spacy,requests라이브러리 필요) - CTI 보고서 모음 (PDF, HTML 또는 텍스트 형식)
- MITRE ATT&CK STIX 데이터 (로컬 또는 TAXII 통해)
- ATT&CK 기술 구조 및 명명 규칙에 대한 이해
- 탐지 엔지니어링 개념(Sigma, YARA)에 대한 숙련도
주요 개념
공격 패턴 추출
CTI 보고서는 자연어로 공격자 행동을 설명합니다. 추출에는 ATT&CK 기술에 매핑되는 동사 및 기술 용어 식별, 도구 이름 및 악성코드 패밀리 인식, 인프라 지표 식별, 그리고 행동 시퀀스를 공격 체인(킬 체인 단계)에 매핑하는 작업이 포함됩니다.
STIX 2.1 Attack Pattern 객체
STIX는 Attack Pattern을 위협 행위자가 대상을 손상시키기 위해 시도하는 방식을 설명하는 구조화된 도메인 객체(SDO)로 정의합니다. 각 패턴은 외부 참조를 통해 ATT&CK에 연결되고, 킬 체인 단계(전술)를 포함하며, 침입 세트, 멀웨어 및 도구 객체와 관련될 수 있습니다.
탐지 규칙 생성
추출된 공격 패턴은 다음을 제공하여 탐지 엔지니어링을 지원합니다: Sigma 규칙 생성을 위한 구체적인 절차 예제, 상관 관계 규칙을 위한 행동 시퀀스, YARA 및 Snort 규칙을 위한 IOC 패턴, 그리고 텔레메트리 격차에 대한 데이터 소스 요구 사항.
워크플로우
1단계: CTI 보고서 파싱 및 행동 추출
import re
import json
from collections import defaultdict
class CTIReportParser:
"""Parse CTI reports to extract adversary behaviors."""
BEHAVIOR_INDICATORS = [
"used", "executed", "deployed", "leveraged", "exploited",
"established", "created", "modified", "downloaded", "uploaded",
"exfiltrated", "injected", "enumerated", "spawned", "dropped",
"persisted", "escalated", "moved laterally", "collected",
"encrypted", "compressed", "encoded", "obfuscated",
]
TOOL_PATTERNS = [
r'\b(Cobalt Strike|Mimikatz|PsExec|BloodHound|Rubeus|Impacket)\b',
r'\b(PowerShell|cmd\.exe|WMI|WMIC|certutil|bitsadmin)\b',
r'\b(Metasploit|Empire|Covenant|Sliver|Brute Ratel)\b',
r'\b(Lazagne|SharpHound|ADFind|Sharphound|Invoke-Obfuscation)\b',
]
TECHNIQUE_KEYWORDS = {
"spearphishing": "T1566",
"phishing attachment": "T1566.001",
"phishing link": "T1566.002",
"powershell": "T1059.001",
"command line": "T1059.003",
"scheduled task": "T1053.005",
"registry run key": "T1547.001",
"process injection": "T1055",
"dll side-loading": "T1574.002",
"credential dumping": "T1003",
"lsass": "T1003.001",
"kerberoasting": "T1558.003",
"pass the hash": "T1550.002",
"remote desktop": "T1021.001",
"smb": "T1021.002",
"winrm": "T1021.006",
"data staging": "T1074",
"exfiltration over c2": "T1041",
"dns tunneling": "T1071.004",
"web shell": "T1505.003",
}
def parse_report(self, text, report_metadata=None):
"""Parse a CTI report and extract behaviors."""
sentences = re.split(r'[.!?]\s+', text)
behaviors = []
for sentence in sentences:
sentence_lower = sentence.lower()
# Check for behavior indicators
for indicator in self.BEHAVIOR_INDICATORS:
if indicator in sentence_lower:
behavior = {
"sentence": sentence.strip(),
"action": indicator,
"tools": self._extract_tools(sentence),
"technique_hints": self._match_techniques(sentence_lower),
}
if behavior["technique_hints"]:
behaviors.append(behavior)
break
print(f"[+] Extracted {len(behaviors)} behavioral indicators from report")
return behaviors
def _extract_tools(self, text):
"""Extract tool/malware names from text."""
tools = set()
for pattern in self.TOOL_PATTERNS:
matches = re.findall(pattern, text, re.IGNORECASE)
tools.update(matches)
return list(tools)
def _match_techniques(self, text):
"""Match text to ATT&CK technique hints."""
matches = []
for keyword, tech_id in self.TECHNIQUE_KEYWORDS.items():
if keyword in text:
matches.append({"keyword": keyword, "technique_id": tech_id})
return matches
parser = CTIReportParser()
sample_report = """
The threat actor used spearphishing attachments with macro-enabled documents to
gain initial access. Once inside, they executed PowerShell scripts to download
additional tooling. The actor leveraged Mimikatz to dump credentials from LSASS
memory. They then used pass the hash techniques for lateral movement via SMB
to multiple systems. Data was staged in a compressed archive and exfiltrated
over the existing C2 channel. The actor established persistence through
scheduled tasks and registry run keys.
"""
behaviors = parser.parse_report(sample_report)
2단계: 행동을 ATT&CK 기술에 매핑
from attackcti import attack_client
class ATTACKMapper:
def __init__(self):
self.lift = attack_client()
self.techniques = {}
self._load_techniques()
def _load_techniques(self):
"""Load all ATT&CK techniques for mapping."""
all_techs = self.lift.get_enterprise_techniques()
for tech in all_techs:
tech_id = ""
for ref in tech.get("external_references", []):
if ref.get("source_name") == "mitre-attack":
tech_id = ref.get("external_id", "")
break
if tech_id:
self.techniques[tech_id] = {
"name": tech.get("name", ""),
"description": tech.get("description", "")[:500],
"tactics": [p.get("phase_name") for p in tech.get("kill_chain_phases", [])],
"platforms": tech.get("x_mitre_platforms", []),
"data_sources": tech.get("x_mitre_data_sources", []),
}
print(f"[+] Loaded {len(self.techniques)} ATT&CK techniques")
def map_behaviors(self, behaviors):
"""Map extracted behaviors to ATT&CK techniques."""
mapped = []
for behavior in behaviors:
for hint in behavior.get("technique_hints", []):
tech_id = hint["technique_id"]
if tech_id in self.techniques:
tech_info = self.techniques[tech_id]
mapped.append({
"technique_id": tech_id,
"technique_name": tech_info["name"],
"tactics": tech_info["tactics"],
"source_sentence": behavior["sentence"],
"tools_observed": behavior["tools"],
"keyword_matched": hint["keyword"],
"data_sources": tech_info["data_sources"],
})
print(f"[+] Mapped {len(mapped)} behaviors to ATT&CK techniques")
return mapped
mapper = ATTACKMapper()
mapped_behaviors = mapper.map_behaviors(behaviors)
3단계: STIX 2.1 Attack Pattern 라이브러리 생성
from stix2 import AttackPattern, Relationship, Bundle, TLP_GREEN
from datetime import datetime
class AttackPatternLibrary:
def __init__(self):
self.patterns = []
self.relationships = []
def add_pattern_from_mapping(self, mapping, report_source="CTI Report"):
"""Create STIX Attack Pattern from mapped behavior."""
pattern = AttackPattern(
name=mapping["technique_name"],
description=f"Observed: {mapping['source_sentence']}\n\n"
f"Tools: {', '.join(mapping['tools_observed']) or 'None identified'}\n"
f"Source: {report_source}",
external_references=[{
"source_name": "mitre-attack",
"external_id": mapping["technique_id"],
"url": f"https://attack.mitre.org/techniques/{mapping['technique_id'].replace('.', '/')}/",
}],
kill_chain_phases=[{
"kill_chain_name": "mitre-attack",
"phase_name": tactic,
} for tactic in mapping["tactics"]],
object_marking_refs=[TLP_GREEN],
)
self.patterns.append(pattern)
return pattern
def build_library(self, mapped_behaviors, report_source="CTI Report"):
"""Build complete attack pattern library from mappings."""
seen_techniques = set()
for mapping in mapped_behaviors:
tech_id = mapping["technique_id"]
if tech_id not in seen_techniques:
self.add_pattern_from_mapping(mapping, report_source)
seen_techniques.add(tech_id)
bundle = Bundle(objects=self.patterns + self.relationships)
print(f"[+] Library: {len(self.patterns)} attack patterns")
return bundle
def export_library(self, output_file="attack_pattern_library.json"):
bundle = Bundle(objects=self.patterns + self.relationships)
with open(output_file, "w") as f:
f.write(bundle.serialize(pretty=True))
print(f"[+] Library exported to {output_file}")
def generate_detection_templates(self, mapped_behaviors):
"""Generate Sigma rule templates from attack patterns."""
templates = []
for mapping in mapped_behaviors:
template = {
"title": f"Detection: {mapping['technique_name']} ({mapping['technique_id']})",
"status": "experimental",
"description": f"Detects {mapping['technique_name']} based on CTI report observation",
"references": [
f"https://attack.mitre.org/techniques/{mapping['technique_id'].replace('.', '/')}/",
],
"tags": [
f"attack.{mapping['tactics'][0]}" if mapping['tactics'] else "attack.unknown",
f"attack.{mapping['technique_id'].lower()}",
],
"data_sources": mapping.get("data_sources", []),
"observed_tools": mapping.get("tools_observed", []),
"source_context": mapping["source_sentence"],
}
templates.append(template)
with open("detection_templates.json", "w") as f:
json.dump(templates, f, indent=2)
print(f"[+] Generated {len(templates)} detection templates")
return templates
library = AttackPatternLibrary()
bundle = library.build_library(mapped_behaviors, "Sample CTI Report")
library.export_library()
templates = library.generate_detection_templates(mapped_behaviors)
검증 기준
- CTI 보고서가 파싱되고 행동 지표가 추출됨
- 행동이 신뢰도를 가지고 ATT&CK 기술에 매핑됨
- 적절한 참조와 함께 STIX 2.1 Attack Pattern 객체가 생성됨
- 라이브러리가 전술, 기술 및 위협 행위자별로 검색 가능함
- 문서화된 패턴에서 탐지 템플릿이 생성됨
- 공유를 위해 라이브러리가 STIX 번들로 내보내기 가능함