README.md

---
license: apache-2.0
task_categories:
  - text-classification
  - graph-ml
language:
  - en
tags:
  - cybersecurity
  - intrusion-detection
  - provenance-graphs
  - MITRE-ATT&CK
  - SOAR
  - security-operations
  - IDS
  - network-security
  - threat-detection
  - labeled-dataset
size_categories:
  - 1M<n<10M
configs:
  - config_name: signals
    data_files:
      - split: train
        path: signals/signals.parquet
  - config_name: graph_nodes
    data_files:
      - split: train
        path: graph/nodes.jsonl
  - config_name: graph_edges
    data_files:
      - split: train
        path: graph/edges.jsonl
  - config_name: incidents
    data_files:
      - split: train
        path: graph/incidents.jsonl
---

# WitFoo Precinct6 Cybersecurity Dataset

## Overview

A large-scale, labeled cybersecurity dataset derived from production Security Operations Center (SOC) data processed by [WitFoo Precinct](https://www.witfoo.com/) version 6.x. The dataset contains **1.96 million sanitized security events** (signal logs) and **provenance graphs** (10,442 incident graphs with 18,083 nodes and 469,894 edges) from real enterprise network monitoring across multiple organizations.

This dataset is designed to support research in:
- **Provenance graph-based intrusion detection** (KnowHow, NodLink, and similar systems)
- **AI-driven cyber defense simulation** (CybORG and MARL-based defense policy training)
- **Security alert classification** (malicious vs. benign event labeling)
- **Attack lifecycle analysis** using MITRE ATT&CK framework mappings

## Quick Start

```python
from datasets import load_dataset

# Load flat signal logs (1.95M rows, Parquet)
signals = load_dataset("witfoo/precinct6-cybersecurity", "signals", split="train")

# Load provenance graph nodes (18K nodes)
nodes = load_dataset("witfoo/precinct6-cybersecurity", "graph_nodes", split="train")

# Load provenance graph edges (470K edges)
edges = load_dataset("witfoo/precinct6-cybersecurity", "graph_edges", split="train")

# Load full incident graphs (10K incidents with embedded artifacts, leads, and MITRE mappings)
incidents = load_dataset("witfoo/precinct6-cybersecurity", "incidents", split="train")
```

## Dataset Configurations

### `signals` — Flat Security Signal Logs

Tabular format ideal for ML classification, anomaly detection, and feature engineering. Each row is a sanitized security event from production network monitoring.

| Column | Type | Description |
|--------|------|-------------|
| `timestamp` | float | Unix epoch timestamp of the event |
| `message_type` | string | Event classification (e.g., `firewall_action`, `account_logon`, `security_audit_event`, `dns_event`, AWS API names) |
| `stream_name` | string | Source product/data stream identifier (see [Source Products](#source-products-stream-names)) |
| `pipeline` | string | Ingestion pipeline (`syslog`, `aws_cloudtrail`, etc.) |
| `src_ip` | string | Source IP address (sanitized) |
| `dst_ip` | string | Destination IP address (sanitized) |
| `src_port` | string | Source port |
| `dst_port` | string | Destination port |
| `protocol` | string | Network protocol (6=TCP, 17=UDP, 1=ICMP, etc.) |
| `src_host` | string | Source hostname (sanitized) |
| `dst_host` | string | Destination hostname (sanitized) |
| `username` | string | Associated username (sanitized) |
| `action` | string | Event action (`block`, `Logon`, `Logoff`, `File System`, etc.) |
| `severity` | string | Severity level (`warning`, `informational`, `Info`, etc.) |
| `vendor_code` | string | Vendor-specific event code (e.g., `ASA-4-106023` for Cisco) |
| `message_sanitized` | string | Full sanitized raw log message (syslog, XML, JSON, CSV depending on source) |
| `label_binary` | string | `malicious` or `benign` (derived from incident correlation) |
| `label_confidence` | float | Confidence score for the binary label (0.0–1.0) |
| `attack_techniques` | string | JSON array of MITRE ATT&CK technique IDs |
| `attack_tactics` | string | JSON array of MITRE ATT&CK tactic names |
| `mo_name` | string | Modus operandi / attack campaign type (e.g., `Data Theft`) |
| `suspicion_score` | float | WitFoo-computed suspicion score (0.0–1.0) |
| `lifecycle_stage` | string | Kill chain stage mapping for KnowHow compatibility |

### `graph_nodes` — Provenance Graph Nodes

Nodes in the provenance graph representing network entities observed in security monitoring.

| Field | Type | Description |
|-------|------|-------------|
| `node_id` | string | Unique node identifier (sanitized IP, hostname, or UUID) |
| `type` | string | Entity type: `HOST`, `CREDENTIAL`, `SERVICE`, `FILE`, `CRED`, `ACTOR` |
| `attrs` | object | Node attributes: `ip` (sanitized), `hostname` (sanitized), `credential` (sanitized) |

### `graph_edges` — Provenance Graph Edges

Directed edges representing security events and relationships between entities. Each edge is a connection observed in production network traffic or security monitoring.

| Field | Type | Description |
|-------|------|-------------|
| `edge_id` | string | Unique edge identifier |
| `src` | string | Source node ID |
| `dst` | string | Destination node ID |
| `type` | string | Edge type: `NETWORK_FLOW`, `AUDIT_EVENT`, `DNS_RESOLVE`, `INCIDENT_LINK`, `EVENT` |
| `timestamp` | float | Unix epoch timestamp |
| `attrs` | object | Edge attributes: `message_type`, `action`, `protocol`, `src_port`, `dst_port`, `stream` |
| `labels` | object | Labels: `label_binary`, `label_confidence`, `suspicion_score`, `attack_techniques`, `attack_tactics`, `mo_name`, `lifecycle_stage` |

### `incidents` — Full Incident Graphs

Complete incident records as produced by WitFoo Precinct's threat detection engine. Each incident is a self-contained provenance graph capturing a correlated chain of suspicious or malicious activity. This is the richest configuration — each record contains embedded nodes, edges, leads (the triggering artifacts with full raw messages), and framework mappings.

**Top-level fields:**

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique incident identifier |
| `name` | string | Auto-generated incident name (e.g., "Convoluted Bandicoot 241304") |
| `mo_id` | int | Modus operandi ID |
| `mo_name` | string | Attack campaign type: `Data Theft`, `Ransomware`, `Credential Theft`, etc. |
| `suspicion_score` | float | WitFoo-computed suspicion score (0.0–1.0) |
| `status_id` | int | Incident status code |
| `status_name` | string | Status: `Unprocessed`, `Investigating`, `Disrupted`, `False Positive`, etc. |
| `first_observed_at` | int | Unix timestamp of earliest event in the incident |
| `last_observed_at` | int | Unix timestamp of latest event in the incident |
| `created_at` | int | Unix timestamp when the incident was created |
| `lead_count` | int | Number of triggering signals (leads) |
| `nodes` | object | Dict of entity nodes in the incident graph (see below) |
| `edges` | object | Dict of connections between nodes (see below) |
| `leads` | object | Dict of triggering artifacts with full event data (see below) |
| `products` | object | Security products involved in detection |
| `tools` | object | Security tools that generated the signals |
| `sets` | list | WitFoo classification sets (Exploiting Host, Exploiting Target, etc.) |
| `actors` | list | Threat actor attributions (if any) |
| `top_set` | int | Primary classification set ID |

**Incident nodes** (`nodes.{uuid}`):

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Node UUID |
| `type` | string | Entity type: `host`, `cred`, `service`, `file`, `actor` |
| `ip_address` | string | Sanitized IP address |
| `hostname` | string | Sanitized hostname |
| `credential` | string | Sanitized credential identifier |
| `suspicion_score` | float | Per-node suspicion score |
| `internal` | bool | Whether the entity is internal to the network |
| `managed` | bool | Whether the entity is a managed asset |
| `sets` | object | Classification sets assigned to this node |
| `products` | object | Products that observed this entity, with full framework mappings (MITRE ATT&CK, D3FEND, NIST 800-53, CIS, PCI, ISO 27001, SOC 2, CMMC) |

**Incident edges** (`edges.{id}`):

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Edge identifier |
| `source` | string | Source node UUID |
| `target` | string | Target node UUID |
| `type` | string | Connection type (e.g., `connection`) |
| `subtype` | int | Connection subtype code |
| `started` | int | Unix timestamp of connection start |
| `ended` | int | Unix timestamp of connection end |
| `count` | int | Number of events in this connection |
| `bytes` | int | Total bytes transferred |
| `artifacts` | object | Dict of raw artifacts (security events) associated with this edge |
| `products` | object | Products that observed this connection |

**Incident leads** (`leads.{uuid}`):

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Lead UUID |
| `artifact` | object | Full artifact record (85+ fields) — the triggering security event with sanitized raw message, extracted fields, vendor codes, and all metadata |
| `details` | string | Sanitized raw log message that triggered the lead |
| `description` | string | Human-readable lead description |
| `set_id` | int | Classification set (1=Exploiting Host, 5=Exploiting Target, etc.) |
| `node_id` | string | Associated node UUID |
| `product` | object | Product that generated this lead |
| `observed_at` | int | Unix timestamp of observation |
| `status_id` | int | Lead status code |
| `statuses` | object | Available status transitions |

### Additional Formats (in repository)

- **`graph/graph.graphml`** — Full provenance graph in GraphML format for direct import into NetworkX, Gephi, or graph databases
- **`graph/graph.json`** — NetworkX node-link JSON format
- **`signals/signals.csv`** — CSV version of signal logs (larger than Parquet, identical content)

## Data Provenance

### Production Origin

This dataset was generated from **production security operations data** collected by WitFoo Precinct 6.x, a Security Orchestration, Automation, and Response (SOAR) platform. The data originates from real enterprise networks monitored by WitFoo's SOC platform, covering multiple organizations across diverse industry sectors.

**Data collection period:** July–August 2024

**Processing pipeline:**
1. Security events were ingested by WitFoo Precinct 6.x from production network monitoring tools via syslog, API connectors, and agent-based collection
2. Events were parsed by WitFoo's signal processing pipeline using field extractors specific to each product/vendor
3. Events were correlated into incidents by WitFoo's automated threat detection and incident analysis engine, which assigns suspicion scores, modus operandi labels, and maps to security frameworks (MITRE ATT&CK, D3FEND, NIST, CIS, PCI, etc.)
4. Raw signal data and incident graphs were extracted from WitFoo's Cassandra database
5. All data was sanitized through a comprehensive 4-layer PII removal pipeline (see [Sanitization](#sanitization-methodology))
6. Labels were derived from WitFoo's incident analysis (see [Labeling](#labeling-methodology))

### Source Products (Stream Names)

The dataset contains security events from the following monitoring products and data sources, reflecting a typical enterprise SOC deployment:

| Stream Name | Product/Source | Event Types |
|-------------|----------------|-------------|
| `microsoft-windows-security-auditing` | Microsoft Windows Security | Logon/logoff, file access, privilege use, account management (Event IDs: 4624, 4656, 4658, 4662, 4688, 4690, 4776, 4799, 4985, 5156, 5158) |
| `cisco_asa` | Cisco ASA Firewall | Firewall allow/deny, connection teardown, VPN events |
| `cisco_os` | Cisco IOS/NX-OS | Network device management and routing events |
| `cisco_stealthwatch` | Cisco Stealthwatch | Network flow analytics and anomaly detection |
| `aws_cloudtrail_events` | AWS CloudTrail | API calls: AssumeRole, DescribeInstances, GetLogEvents, ListClusters, S3 operations, IAM operations, Lambda, SNS, SQS, and 50+ other AWS API event types |
| `aws_vpc_flow_log` | AWS VPC Flow Logs | Network flow data within AWS VPCs |
| `network_communication` | Network Flow Data | TCP/UDP/ICMP communication events |
| `pan_firewall` | Palo Alto Networks Firewall | Traffic allow/drop, threat events, URL filtering |
| `symantec_sep` | Symantec Endpoint Protection | Endpoint security events |
| `ad fs auditing` | Active Directory Federation Services | Authentication and federation events |
| `generic_log` | Various (unclassified) | Events from sources without dedicated parsers |
| `precinct_audit` | WitFoo Precinct | Internal SOAR platform audit events |
| `sshd` | OpenSSH | SSH authentication and session events |
| `pam` | Linux PAM | Pluggable Authentication Module events |
| `systemd` | Linux systemd | System service management events |
| `crond` | Linux cron | Scheduled task execution events |
| `filebeat_diagnostic` | Elastic Filebeat | Log shipper diagnostic events |
| `security` | Linux Security | SELinux and security subsystem events |

### WitFoo Precinct 6.x

WitFoo Precinct is a SOAR (Security Orchestration, Automation, and Response) platform that ingests security telemetry from diverse sources, parses events using vendor-specific field extractors, correlates events into incidents using automated threat detection rules, and maps findings to security frameworks. Key capabilities relevant to this dataset:

- **Signal Processing:** Multi-stage pipeline with field extraction, normalization, and enrichment
- **Incident Correlation:** Automated grouping of related signals into incident graphs with nodes (hosts, credentials, actors) and edges (connections, communications)
- **Framework Mapping:** Events and incidents are mapped to MITRE ATT&CK, MITRE D3FEND, NIST 800-53, NIST CSF, CIS Controls, PCI DSS, ISO 27001, SOC 2, and CMMC frameworks
- **Suspicion Scoring:** Proprietary scoring algorithm that assigns suspicion levels to nodes and incidents based on observed behavior patterns

## Labeling Methodology

### Binary Labels (`malicious` / `benign`)

Labels are derived from WitFoo Precinct's automated incident analysis:

- **`malicious`**: The event appears as a lead (triggering artifact) in one or more confirmed incidents with suspicion_score > 0. These events were identified by WitFoo's detection rules as part of attack patterns or suspicious activity chains.
- **`benign`**: The event does not appear in any incident, or appears only in incidents classified as false positives.

### Label Distribution

| Label | Count | Percentage |
|-------|-------|------------|
| `malicious` | 34,362 | ~1.8% |
| `benign` | ~1.91M | ~98.2% |

This imbalanced distribution reflects the reality of production SOC environments where the vast majority of events are benign, and is consistent with published IDS datasets (DARPA TC, LANL).

### MITRE ATT&CK Mappings

Attack technique and tactic labels are derived from WitFoo's framework mapping of incident patterns. The `lifecycle_stage` field maps events to the 7-stage APT kill chain used by KnowHow and similar provenance graph detection systems:

1. `initial-compromise` — Initial access to the network
2. `establish-foothold` — Execution and establishing persistence
3. `escalate-privilege` — Privilege escalation attempts
4. `internal-reconnaissance` — Discovery and internal scanning
5. `move-laterally` — Lateral movement between hosts
6. `maintain-persistence` — Command & control and persistence
7. `complete-mission` — Data theft, exfiltration, or impact

## Sanitization Methodology

All customer-identifying information has been removed through a comprehensive, iterative multi-layer sanitization pipeline. **Quality was prioritized over processing speed** — the dataset underwent multiple full re-sanitization cycles until convergence (near-zero new PII discoveries per cycle).

### Pipeline Architecture

The sanitization pipeline operates in 4 layers, applied iteratively. Each cycle processes all ~2 million records, and the pipeline repeats until Layers 3 and 4 find no (or near-zero) additional PII. A persistent **PII Registry** (SQLite-backed) maintains a global mapping of every original value to its sanitized replacement. The same original value always maps to the same token, preserving graph topology, network relationships, and host behavior patterns across all records.

A self-referencing token guard prevents the pipeline from registering its own replacement tokens (e.g., `HOST-0001`, `ORG-1234`) as new PII entries, which would otherwise cause runaway registry inflation during iterative cycles.

### Layer 1: Structured Field Sanitization + Aho-Corasick Sweep

**Structured field matching:** Known JSON fields are sanitized based on their semantic meaning using deterministic regex and format-aware type inference:

- **IP addresses** → Private IPs remapped deterministically within RFC 1918 ranges using HMAC-based subnet-preserving mapping; public IPs replaced with RFC 5737 TEST-NET addresses (192.0.2.0/24, 198.51.100.0/24, 203.0.113.0/24)
- **Organization names** → `ORG-NNNN`
- **Hostnames** → `HOST-NNNN` or `host-NNNN.example.internal`
- **FQDNs** → `host-NNNN.example.internal` (public domains like google.com, microsoft.com are preserved via allowlist)
- **Usernames** → `USER-NNNN` (system accounts like `SYSTEM`, `LOCAL SERVICE`, `NETWORK SERVICE`, `root`, `sshd` are preserved)
- **Emails** → `user-NNNN@example.net`
- **Domains** → `domain-NNNN.example.net`
- **Windows SIDs** → `S-1-5-21-1000000000-2000000000-3000000000-NNNN` (well-known SIDs like `S-1-5-18` are preserved)
- **AWS Account IDs** → Sequential 12-digit replacements
- **ARNs** → `arn:aws:iam::NNNN:sanitized/NNNN`
- **Credentials / API keys** → `CRED-NNNN`
- **Machine accounts** → `MACHINE-NNNN$`

**Field-agnostic deep scanning:** All unknown or unrecognized JSON fields are inspected value-by-value using type heuristics (IP regex, FQDN patterns, email patterns, SID patterns, hostname conventions) to catch PII in fields not covered by structured parsers. Nested JSON objects and arrays are scanned recursively to arbitrary depth.

**Aho-Corasick multi-pattern sweep:** After field-level sanitization, the full serialized record is swept using an [Aho-Corasick automaton](https://en.wikipedia.org/wiki/Aho%E2%80%93Corasick_algorithm) built from all registry entries ≥4 characters. This catches PII values that appear in unexpected contexts — concatenated strings, log message bodies, cross-field references, and embedded JSON. The automaton is rebuilt each cycle as the registry grows.

### Layer 2: Format-Specific Message Parsing

Raw log messages (`message_sanitized`) are parsed using 8 format-specific parsers that understand the exact structure of each vendor's log format:

- **Cisco ASA syslog** — Regex extraction of `src IFACE:IP/PORT dst IFACE:IP/PORT` patterns from ASA deny/permit messages
- **Windows Security Event XML** — DOM parsing of XML elements including `TargetUserName`, `IpAddress`, `WorkstationName`, `Computer`, `SubjectDomainName`, `SubjectUserName`, `TargetDomainName`, `MemberSid`
- **WinLogBeat JSON** — Full recursive parsing of nested WinLogBeat JSON structures, including `agent.name`, `host.hostname`, `winlog.event_data.*`, `organization`, `senderHost`, and all `SubjectDomainName`/`SubjectUserName`/`TargetUserName` fields within the embedded event data
- **AWS CloudTrail** — Sanitization of `userIdentity.accountId`, `userIdentity.arn`, `sourceIPAddress`, `userName`, `accessKeyId`, and recursive scanning of `requestParameters` and `responseElements`
- **Palo Alto Networks CSV** — BSD syslog header hostname extraction plus CSV body field parsing for source/destination IPs, hostnames, and user fields
- **VMware ESXi** — BSD syslog header hostname and IP extraction from vCenter/ESXi log formats
- **DNS events** — Sanitization of resolved IPs while preserving public domain names (google.com, microsoft.com, etc.) via a curated allowlist of ~1,000 public domains and TLDs
- **Generic fallback** — Comprehensive regex battery applied to all unrecognized formats: IP addresses, FQDNs, email addresses, Windows SIDs, machine accounts (`*$` pattern), ARNs, `user=`/`host=`/`domain=` key-value pairs, `\\DOMAIN\user` UNC paths, and BSD syslog header hostnames

### Layer 3: ML/NER Residual Detection

After Layers 1–2, machine learning models scan a stratified random sample of 2,000 sanitized records for residual PII that regex and format parsers missed:

- **Microsoft Presidio** with spaCy `en_core_web_lg` model — Entity recognition for PERSON, ORGANIZATION, IP_ADDRESS, EMAIL_ADDRESS, with custom `PatternRecognizer` instances for AWS account IDs (12-digit patterns) and machine accounts (`*$` suffix)
- **HuggingFace BERT NER** (`dslim/bert-base-NER`) — Transformer-based token classification for PER (person), ORG (organization), and LOC (location) entities, providing a second-opinion cross-check against Presidio's spaCy-based detection

All ML findings are filtered against an allowlist of safe values (system accounts, well-known services, public domains) and existing registry entries. New PII discoveries are added to the registry and trigger a **full re-sanitization pass** across all ~2 million records.

### Layer 4: Claude AI Contextual Review

A stratified random sample of 500 sanitized records (sampled proportionally across message types and stream names) is submitted to Anthropic's Claude API for contextual PII review. Claude is prompted to identify PII that pattern-based and NER approaches commonly miss:

- Organization names, abbreviations, or acronyms embedded in log messages
- Internal hostnames that reveal organizational structure or naming conventions
- Employee names embedded in file paths, process names, or service descriptions
- Custom Active Directory group names, policy names, or OU names that identify the organization
- Geographic identifiers tied to specific offices or data centers (e.g., `ATL-DC1`, `NYC-PROD`)
- Database instance names containing organization identifiers (e.g., `mssql$acmesql01`)

Claude's response is parsed for structured findings, each with a span, category, confidence score, and reasoning. New discoveries are added to the registry and trigger another full re-sanitization pass.

### Iterative Convergence

The 4-layer pipeline runs in iterative cycles:

1. **Cycle N**: Layers 1–2 sanitize all records using the current registry → Layer 3 (ML) scans a sample → Layer 4 (Claude) scans a sample → New findings are added to registry → Full re-sanitize if new PII found
2. **Cycle N+1**: Repeat with the enriched registry — Layers 1–2 now catch everything previously found by ML/Claude
3. **Convergence**: Cycles repeat until Layer 3 and Layer 4 find near-zero new entries

This iterative approach ensures that PII discovered by expensive ML/AI methods in one cycle is caught cheaply by regex/Aho-Corasick in all subsequent cycles across the full dataset (not just the sampled records).

### Sanitization Registry Statistics

The final PII registry contains **~157,000 unique mappings** across 14 categories:

| PII Category | Entries Found | Replacement Pattern |
|--------------|--------------|---------------------|
| Public IPs | ~80,500 | RFC 5737 TEST-NET (deterministic) |
| Hostnames | ~21,900 | `HOST-NNNN` |
| Private IPs | ~18,000 | HMAC-remapped RFC 1918 (subnet-preserving) |
| Credentials | ~13,100 | `CRED-NNNN` |
| FQDNs | ~11,100 | `host-NNNN.example.internal` |
| Organizations | ~7,500 | `ORG-NNNN` |
| Usernames | ~2,400 | `USER-NNNN` |
| Windows SIDs | ~1,400 | Standardized replacement SIDs |
| Emails | ~575 | `user-NNNN@example.net` |
| Machine Accounts | ~350 | `MACHINE-NNNN$` |
| Domains | ~23 | `domain-NNNN.example.net` |
| AWS Accounts | ~16 | Sequential 12-digit IDs |
| Org IDs | 6 | Numeric replacement IDs |
| ARNs | 2 | `arn:aws:iam::NNNN:sanitized/NNNN` |

### What Is Preserved

The following security-relevant information is intentionally preserved:
- **Timestamps** — Event timing, dwell time, and lateral movement sequences
- **Port numbers** — Protocol behavior signals
- **Protocol types** — TCP/UDP/ICMP classification
- **Severity levels** — Event priority and criticality
- **Vendor event codes** — Cisco ASA codes, Windows Event IDs, AWS API names
- **Action types** — Block, permit, logon, logoff, file access
- **MITRE ATT&CK / D3FEND mappings** — Framework technique and tactic IDs
- **Graph topology** — Node relationships and connection patterns (via consistent IP/hostname replacement)
- **Product/stream identifiers** — Which security tool generated the event

## Intended Uses

### Primary Use Cases

1. **Provenance graph-based intrusion detection research** — Evaluate and benchmark graph-based IDS approaches (KnowHow, NodLink) on production-derived data
2. **AI cyber defense simulation** — Train and evaluate reinforcement learning defense policies in CybORG and similar simulators
3. **Security alert classification** — Build and evaluate ML models for malicious/benign event classification
4. **Attack lifecycle analysis** — Study attack progression patterns mapped to MITRE ATT&CK

### Research Context

This dataset was produced in collaboration with the University of Canterbury (New Zealand) Computer Science and Software Engineering department for two research projects:
- **AI Cyber-Security Battle Simulator** — Improving CybORG with realistic IDS observations, graph-based defense policies, and AI-driven attacker modeling
- **Intrusion Detection based on Provenance Graphs** — Evaluating reproducibility and generalizability of KnowHow and NodLink detection methods

## Limitations

- **Label imbalance**: ~98% benign, ~2% malicious — reflects production SOC reality but may require sampling strategies for balanced training
- **Temporal scope**: Data covers July–August 2024, a limited time window
- **Organization diversity**: Data from 5 organizations, each with different security tool deployments
- **Sanitization trade-offs**: Some log message detail is reduced by PII replacement, particularly in free-text fields
- **Label derivation**: Binary labels depend on WitFoo's automated detection; some attacks may be unlabeled (false negatives) and some benign events may be incorrectly linked to incidents

## Ethical Considerations

- All customer-identifying information has been removed through the 4-layer sanitization process described above
- The dataset does not contain personally identifiable information (PII) of any individual
- IP addresses, hostnames, usernames, and organization names have been replaced with consistent synthetic tokens
- The dataset should be used for defensive security research only

## Citation

```bibtex
@dataset{witfoo_precinct6_2025,
  title={WitFoo Precinct6 Cybersecurity Dataset: Labeled Provenance Graphs and Signal Logs from Production SOC Operations},
  author={WitFoo, Inc.},
  year={2025},
  url={https://huggingface.co/datasets/witfoo/precinct6-cybersecurity},
  license={Apache-2.0}
}
```

## License

This dataset is released under the [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0).