README.md

metadata

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 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

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)
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)
6. Labels were derived from WitFoo's incident analysis (see Labeling)

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 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

@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.