| """ |
| Structure-aware chunkers for CVE, MITRE ATT&CK, CAPEC, and CWE documents. |
| |
| Each chunker produces a list of dicts: |
| { |
| "id": str — deterministic, stable chunk ID |
| "kind": str — chunk section name |
| "text": str — text to embed / index |
| "payload": dict — Qdrant payload (filterable metadata) |
| } |
| """ |
|
|
| from __future__ import annotations |
| from typing import Any, Dict, List, Optional, Set |
|
|
|
|
| |
| |
| |
|
|
| def _join(*parts: Optional[str], sep: str = " | ") -> str: |
| return sep.join(p for p in parts if p) |
|
|
|
|
| def _list_str(val: Any) -> List[str]: |
| if isinstance(val, list): |
| return [str(v) for v in val if v] |
| if isinstance(val, str) and val: |
| return [val] |
| return [] |
|
|
|
|
| def _base_payload(cve_doc: Dict[str, Any]) -> Dict[str, Any]: |
| """Shared metadata carried by every CVE chunk for Qdrant payload filtering.""" |
| cve_id_val = cve_doc.get("id") or cve_doc.get("cve_id", "") |
| cvss3 = cve_doc.get("cvss_v3") or {} |
| year = "" |
| pub = cve_doc.get("published_date", "") |
| if pub: |
| year = pub[:4] |
| return { |
| "cve_id": cve_id_val, |
| "severity": cvss3.get("base_severity", ""), |
| "cvss_score": cvss3.get("base_score"), |
| "is_in_kev": bool(cve_doc.get("is_in_kev", False)), |
| "year": year, |
| "products": _list_str(cve_doc.get("affected_products", [])), |
| "cwe_refs": _list_str(cve_doc.get("cwe_refs", [])), |
| "capec_entries": _list_str(cve_doc.get("capec_entries", [])), |
| "mitre_techniques": _list_str(cve_doc.get("mitre_techniques", [])), |
| "mitre_tactics": _list_str(cve_doc.get("mitre_tactics", [])), |
| } |
|
|
|
|
| |
| |
| |
|
|
| class CVEChunker: |
| """ |
| Produces 1-2 self-contained chunks per CVE. |
| |
| Chunk 1 — ``core``: vulnerability prose + CVSS metrics. |
| Best for semantic queries about *what* the vuln is |
| and exact CVE-ID lexical lookup. |
| |
| Chunk 2 — ``context`` (omitted when empty): |
| Affected products/vendors + CWE/CAPEC + MITRE ATT&CK |
| + KEV status + tags. Best for *who is affected* and |
| threat-hunting queries. |
| |
| Both chunks carry the full payload so Qdrant payload filters work uniformly. |
| """ |
|
|
| def chunk(self, doc: Dict[str, Any]) -> List[Dict[str, Any]]: |
| cve_id = doc.get("id") or doc.get("cve_id", "unknown") |
| payload = _base_payload(doc) |
| chunks: List[Dict[str, Any]] = [] |
|
|
| core_text = self._core(doc) |
| if core_text: |
| chunks.append({ |
| "id": f"{cve_id}::core", |
| "kind": "core", |
| "text": core_text, |
| "payload": {**payload, "chunk_kind": "core"}, |
| }) |
|
|
| ctx_text = self._context(doc) |
| if ctx_text: |
| chunks.append({ |
| "id": f"{cve_id}::context", |
| "kind": "context", |
| "text": ctx_text, |
| "payload": {**payload, "chunk_kind": "context"}, |
| }) |
|
|
| return chunks |
|
|
| |
|
|
| def _core(self, doc: Dict[str, Any]) -> str: |
| """CVE ID + vulnerability prose + full CVSS metrics.""" |
| cve_id = doc.get("id") or doc.get("cve_id", "") |
|
|
| |
| content = (doc.get("content") or "").strip() |
| prose = content.split("\n")[0].strip() if content else (doc.get("description") or "").strip() |
|
|
| parts = [f"CVE ID: {cve_id}"] |
| if prose: |
| parts.append(prose) |
|
|
| pub = doc.get("published_date", "") |
| if pub: |
| parts.append(f"Published: {pub[:10]}") |
|
|
| cvss3 = doc.get("cvss_v3") or {} |
| if cvss3.get("base_score"): |
| parts.append( |
| f"CVSS v3: {cvss3['base_score']} {cvss3.get('base_severity', '')} " |
| f"| Vector: {cvss3.get('vector_string', '')}" |
| ) |
| metric_parts = [] |
| for label, key in [ |
| ("AV", "attack_vector"), |
| ("AC", "attack_complexity"), |
| ("PR", "privileges_required"), |
| ("UI", "user_interaction"), |
| ("S", "scope"), |
| ]: |
| v = cvss3.get(key, "") |
| if v: |
| metric_parts.append(f"{label}:{v}") |
| if metric_parts: |
| parts.append(" ".join(metric_parts)) |
| impact_parts = [] |
| for label, key in [("C", "confidentiality_impact"), ("I", "integrity_impact"), ("A", "availability_impact")]: |
| v = cvss3.get(key, "") |
| if v: |
| impact_parts.append(f"{label}:{v}") |
| if impact_parts: |
| parts.append("Impact: " + " ".join(impact_parts)) |
|
|
| cvss2 = doc.get("cvss_v2") or {} |
| if cvss2.get("base_score"): |
| parts.append(f"CVSS v2: {cvss2['base_score']} | {cvss2.get('vector_string', '')}") |
|
|
| return " | ".join(parts) |
|
|
| def _context(self, doc: Dict[str, Any]) -> str: |
| """Affected products/vendors + CWE/CAPEC + MITRE + KEV — self-contained threat context.""" |
| cve_id = doc.get("id") or doc.get("cve_id", "") |
| cvss3 = doc.get("cvss_v3") or {} |
|
|
| parts = [f"CVE ID: {cve_id}"] |
| sev = cvss3.get("base_severity", "") |
| if sev: |
| parts.append(f"Severity: {sev}") |
|
|
| products = _list_str(doc.get("affected_products", [])) |
| if products: |
| parts.append(f"Affected Products: {', '.join(products[:20])}") |
|
|
| vendors = self._extract_vendors(doc) |
| if vendors: |
| parts.append(f"Vendors: {', '.join(sorted(vendors)[:15])}") |
|
|
| cwes = _list_str(doc.get("cwe_refs", [])) |
| if cwes: |
| parts.append(f"CWE Weaknesses: {', '.join(cwes)}") |
|
|
| capecs = _list_str(doc.get("capec_entries", [])) |
| if capecs: |
| parts.append(f"CAPEC Attack Patterns: {', '.join(capecs[:10])}") |
|
|
| techs = _list_str(doc.get("mitre_techniques", [])) |
| if techs: |
| parts.append(f"MITRE ATT&CK Techniques: {', '.join(techs[:15])}") |
|
|
| tactics = _list_str(doc.get("mitre_tactics", [])) |
| if tactics: |
| parts.append(f"MITRE ATT&CK Tactics: {', '.join(tactics[:10])}") |
|
|
| if doc.get("is_in_kev"): |
| parts.append("KEV: Known Exploited Vulnerability") |
|
|
| edb = doc.get("exploitdb_correlations_count", 0) or 0 |
| if edb: |
| parts.append(f"ExploitDB References: {edb}") |
|
|
| tags = _list_str(doc.get("tags", [])) |
| if tags: |
| parts.append(f"Tags: {', '.join(tags)}") |
|
|
| |
| if len(parts) <= 2: |
| return "" |
| return " | ".join(parts) |
|
|
| def _extract_vendors(self, doc: Dict[str, Any]) -> Set[str]: |
| vendors: Set[str] = set() |
| for cfg in doc.get("cpe_configurations") or []: |
| for match in cfg.get("cpe_match") or []: |
| uri = match.get("cpe23Uri", "") |
| segs = uri.split(":") |
| if len(segs) > 4 and segs[3] not in ("*", "-", ""): |
| vendors.add(segs[3]) |
| return vendors |
|
|
|
|
| |
| |
| |
|
|
| class MITREChunker: |
| """One chunk per MITRE ATT&CK technique (already compact ~300-500 words).""" |
|
|
| def chunk(self, doc: Dict[str, Any]) -> List[Dict[str, Any]]: |
| tid = doc.get("id", "") |
| title = doc.get("title", "") |
| content= doc.get("content", "") |
| tactics= doc.get("tactics", []) |
| tac_ids= doc.get("tactic_ids", []) |
|
|
| text = _join( |
| f"MITRE ATT&CK Technique: {tid}", |
| f"Name: {title}", |
| f"Tactics: {', '.join(tactics)}" if tactics else None, |
| f"Description: {content}" if content else None, |
| ) |
|
|
| return [{ |
| "id": f"mitre::{tid}", |
| "kind": "technique", |
| "text": text, |
| "payload": { |
| "technique_id": tid, |
| "title": title, |
| "tactics": tactics, |
| "tactic_ids": tac_ids, |
| "data_type": "mitre", |
| }, |
| }] |
|
|
|
|
| |
| |
| |
|
|
| class CAPECChunker: |
| """One chunk per CAPEC attack pattern.""" |
|
|
| def chunk(self, doc: Dict[str, Any]) -> List[Dict[str, Any]]: |
| cid = doc.get("id", "") |
| title = doc.get("title", "") |
| content= doc.get("content", "") |
|
|
| capec_id = f"CAPEC-{cid}" if not str(cid).startswith("CAPEC") else cid |
| text = _join( |
| f"CAPEC Attack Pattern: {capec_id}", |
| f"Name: {title}", |
| f"Description: {content}" if content else None, |
| ) |
|
|
| return [{ |
| "id": f"capec::{capec_id}", |
| "kind": "pattern", |
| "text": text, |
| "payload": { |
| "capec_id": capec_id, |
| "title": title, |
| "data_type": "capec", |
| }, |
| }] |
|
|
|
|
| |
| |
| |
|
|
| class CWEChunker: |
| """One chunk per CWE weakness entry (parsed from cwe_latest.xml).""" |
|
|
| def chunk(self, doc: Dict[str, Any]) -> List[Dict[str, Any]]: |
| cwe_id = doc.get("id", "") |
| name = doc.get("name", "") |
| desc = doc.get("description", "") |
| ext = doc.get("extended_description", "") |
| conseqs = doc.get("consequences", []) |
| capecs = doc.get("capec_refs", []) |
|
|
| text_parts = [ |
| f"CWE Weakness: {cwe_id}", |
| f"Name: {name}", |
| ] |
| if desc: |
| text_parts.append(f"Description: {desc}") |
| if ext: |
| text_parts.append(f"Extended Description: {ext}") |
| if conseqs: |
| text_parts.append(f"Impacts: {', '.join(conseqs)}") |
| if capecs: |
| text_parts.append(f"Related CAPEC Patterns: {', '.join(capecs)}") |
|
|
| return [{ |
| "id": f"cwe::{cwe_id}", |
| "kind": "weakness", |
| "text": " | ".join(text_parts), |
| "payload": { |
| "cwe_id": cwe_id, |
| "name": name, |
| "abstraction": doc.get("abstraction", ""), |
| "capec_refs": capecs, |
| "data_type": "cwe", |
| }, |
| }] |
|
|
