witfoo/precinct6-cybersecurity

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 2.07 million sanitized security events (signal logs) and provenance graphs (10,442 incident graphs with 30,092 nodes and 595,618 edges) from real enterprise network monitoring across multiple organizations.

Available in two sizes:

• witfoo/precinct6-cybersecurity — 2M signals (this dataset)
• witfoo/precinct6-cybersecurity-100m — 114M signals (same methodology, larger extraction)

Generate your own: WitFoo Precinct 6.x customers can create datasets from their own data using the open-source pipeline: witfoo/dataset-from-precinct6

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. suspicious vs. benign event labeling)
• Attack lifecycle analysis using MITRE ATT&CK framework mappings
• Detection rule evaluation using WitFoo's 261 lead detection rules

Quick Start

from datasets import load_dataset

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

# Find malicious events
malicious = signals.filter(lambda x: x["label_binary"] == "malicious")

# Find suspicious events (matched detection rules but not in confirmed incidents)
suspicious = signals.filter(lambda x: x["label_binary"] == "suspicious")

# Query by product/vendor
cisco_events = signals.filter(lambda x: x["vendor_name"] == "Cisco")

# Load provenance graph
nodes = load_dataset("witfoo/precinct6-cybersecurity", "graph_nodes", split="train")
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")

SQL queries (HuggingFace dataset viewer):

-- Malicious events from confirmed incidents
SELECT * FROM signals WHERE label_binary='malicious' LIMIT 100;

-- Suspicious events that triggered detection rules
SELECT * FROM signals WHERE label_binary='suspicious' LIMIT 100;

-- Events with matched detection rules
SELECT matched_rules, set_roles, product_name FROM signals
WHERE matched_rules != '[]' LIMIT 100;

-- Count by label tier
SELECT label_binary, COUNT(*) FROM signals GROUP BY label_binary;

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, suspicious, or benign (see Labeling)
label_confidence	float	Confidence score for the 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, Phishing)
suspicion_score	float	WitFoo-computed suspicion score (0.0–1.0)
lifecycle_stage	string	Kill chain stage (e.g., initial-compromise, complete-mission)
matched_rules	string	JSON array of WitFoo lead rule descriptions that matched this event
set_roles	string	JSON array of WitFoo classification set roles (e.g., Exploiting Host, C2 Server)
product_name	string	Security product that generated this event (e.g., ASA Firewall, Falcon)
vendor_name	string	Vendor of the security product (e.g., Cisco, Crowdstrike)

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.

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, Phishing
suspicion_score	float	WitFoo-computed suspicion score (0.0–1.0)
status_id	int	Incident status code
status_name	string	Status: Unprocessed, Investigating, Disrupted, Dismissed, False Positive
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
edges	object	Dict of connections between nodes
leads	object	Dict of triggering artifacts with full event data
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)

Incident leads (leads.{uuid}):

Field	Type	Description
id	string	Lead UUID
artifact	object	Full artifact record (85+ fields) — the triggering security event
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, with framework mappings
observed_at	int	Unix timestamp of observation

Additional Files

• graph/graph.graphml — Full provenance graph in GraphML format for NetworkX, Gephi, or graph databases
• graph/graph.json — NetworkX node-link JSON format
• reference/lead_rules_catalog.json — Complete catalog of 261 WitFoo lead detection rules, 158 security products, 106 classification sets, and 216 stream-to-product mappings

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 5 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 using 261 lead detection rules
4. Incidents were scored with WitFoo's suspicion scoring algorithm and mapped to security frameworks (MITRE ATT&CK, D3FEND, NIST, CIS, PCI, etc.)
5. Raw signal data and incident graphs were extracted from WitFoo's Cassandra database
6. All data was sanitized through a comprehensive 4-layer PII removal pipeline (see Sanitization)
7. Labels were derived from WitFoo's incident analysis and lead rule matching (see Labeling)

Source Products (Stream Names)

The dataset contains security events from 158 security products across 70+ vendors, reflecting real enterprise SOC deployments. The complete product catalog is included in reference/lead_rules_catalog.json.

Key products by category:

Category	Products
Firewalls	Cisco ASA, Palo Alto PAN NGFW, Fortinet FortiGate, Checkpoint, Meraki, SonicWall, pfSense, Barracuda CloudGen, Juniper SRX, OPNsense, VyOS
Endpoint Protection	CrowdStrike Falcon, Symantec SEP, Carbon Black, Cylance Protect, SentinelOne, Deep Instinct, Malwarebytes, ESET, Sophos Central, McAfee Endpoint
Network Detection	Cisco Stealthwatch, Cisco Firepower, Suricata IDS, TippingPoint IPS, Vectra Cognito, Cisco WSA
Identity & Access	Microsoft Windows AD, Cisco ISE, Centrify, CyberArk, Duo (Cisco), Okta, Shibboleth, Beyond Trust, Thycotic Secret Server
Cloud Security	AWS CloudTrail, AWS VPC Flow Logs, AWS GuardDuty, Azure Security, Zscaler NSS, Netskope, Cisco Umbrella
Email Security	ProofPoint Protect, Mimecast, FireEye EX, Barracuda ESS, Cisco IronPort, SpamTitan, Checkpoint Harmony Email
Threat Intelligence	FireEye NX/HX/AX/CMS, Trend Micro Deep Security, QRadar, Microsoft ATA, Cortex XDR
Data Protection	Symantec DLP, Varonis DatAdvantage, Imperva SecureSphere
SOAR/SIEM	WitFoo Precinct, Splunk, QRadar, Security Onion
Infrastructure	VMware vCenter/NSX, Elastic Filebeat, Linux (sshd, PAM, systemd, auditd, fail2ban), Apache, HAProxy

Stream names in the dataset (top streams by volume):

Stream Name	Product	Vendor	Description
microsoft-windows-security-auditing	Windows Active Directory	Microsoft	Logon/logoff, file access, privilege use, account management
aws_cloudtrail_events	AWS CloudTrail	Amazon Web Services	API calls: AssumeRole, Describe*, List*, Get*, 50+ event types
aws_cloud_trail	AWS CloudTrail	Amazon Web Services	CloudTrail via CloudWatch Logs
vcenter	VMware vCenter	VMware	Virtual infrastructure management events
cisco_asa	ASA Firewall	Cisco	Firewall allow/deny, connection teardown, VPN events
cisco_os	Cisco NOS	Cisco	Network device management and routing events
cisco_stealthwatch	Stealthwatch	Cisco	Network flow analytics and anomaly detection
aws_vpc_flow_log	AWS VPC Security	Amazon Web Services	Network flow data within AWS VPCs
pan_firewall	PAN NGFW	Palo Alto	Traffic allow/drop, threat events, URL filtering
symantec_sep	Symantec EP	Symantec	Endpoint security events
meraki	Meraki	Cisco	Cloud-managed network security events
ad_audit_plus	ADManager	ManageEngine	Active Directory audit and change tracking
ad fs auditing	Windows AD FS	Microsoft	Authentication and federation events
network_communication	Network Flow Data	Various	TCP/UDP/ICMP communication events
sshd	SSHD	Linux	SSH authentication and session events
pam	Linux PAM	Linux	Pluggable Authentication Module events
crond	cron	Linux	Scheduled task execution events
linux_audit	auditd	Linux	Linux kernel audit events
dnsmasq	dnsmasq	Linux	DNS resolver events
barracuda_waf	Barracuda WAF	Barracuda	Web application firewall events
filebeat_diagnostic	Filebeat	Elastic	Log shipper diagnostic events
Crowdstrike Detection	Falcon	CrowdStrike	Endpoint detection events
DUO	Duo	Cisco	Multi-factor authentication events
proofpoint_protect	Protect	ProofPoint	Email security 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.

• Signal Processing: Multi-stage pipeline with field extraction, normalization, and enrichment
• Lead Detection Rules: 261 rules that define what makes a security event suspicious enough to create an incident lead. Rules match on stream name, message type, action, severity, and vendor-specific event codes. Each rule assigns classification sets that define the role of source and target entities (e.g., Exploiting Host → Exploiting Target)
• 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

WitFoo Classification Sets

WitFoo classifies entities in incidents using 106 classification sets that define the role each entity plays in an attack. These are exposed in the set_roles column and in incident node data:

Set ID	Name	Description
1	Exploiting Host	Source of attack traffic
2	Staging Host	Host used for staging payloads or tools
3	Exfiltration Host	Source of data exfiltration
4	Suspicious User	User account involved in suspicious activity
5	Exploiting Target	Target of attack traffic
6	Staging Target	Target receiving staged payloads
7	Exfiltration Target	Destination of exfiltrated data
8	C2 Server	Command & Control infrastructure
9	Bot	Compromised host acting as bot
10	Malicious File	File identified as malicious
11	Reconnaissance Host	Source of scanning/recon activity
12	Reconnaissance Target	Target of scanning/recon
13	Disruption Host	Source of disruptive activity
15	Phishing Site	Phishing infrastructure
16	Phished User	User targeted by phishing
18	Ransomware Malware	Ransomware payload
19	Ransomware Target	Target of ransomware
21	Policy Violation User	User violating security policy

Labeling Methodology

Three-Tier Labels (malicious / suspicious / benign)

Labels are derived from two sources: WitFoo Precinct's incident analysis and lead detection rule matching.

• malicious: The event was embedded as a lead (triggering artifact) inside one or more confirmed incidents. These events were identified by WitFoo's detection engine as part of attack patterns, correlated with other suspicious signals, and assigned to an incident with a suspicion score and modus operandi. The full artifact data, including raw messages, is extracted directly from the incident lead objects.

• suspicious: The event matched one or more of WitFoo's 261 lead detection rules (e.g., "ASA Deny", "Windows Failed Login Attempt", "Blocked Action", "CrowdStrike Detection") but did not appear in a confirmed incident. These events represent security-relevant activity flagged by detection logic.

• benign: The event did not match any lead detection rules and does not appear in any incident.

Label Distribution

2M Dataset (witfoo/precinct6-cybersecurity):

Label	Count	Percentage
benign	1,899,723	91.7%
malicious	125,780	6.1%
suspicious	45,420	2.2%

114M Dataset (witfoo/precinct6-cybersecurity-100m):

Label	Count	Percentage
benign	113,326,050	99.34%
malicious	125,780	0.11%
suspicious	622,700	0.55%

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

Lead Detection Rules

The matched_rules column contains JSON arrays of rule descriptions matched for each event. The complete rule catalog is in reference/lead_rules_catalog.json. Example rules:

Rule	Criteria	Source Role	Target Role
Blocked Action	Any firewall block event	Exploiting Host	Exploiting Target
ASA Deny	cisco_asa + action="deny"	Exploiting Host	Exploiting Target
Windows Failed Login Attempt	Windows Event ID 4625	Exploiting Target	Exploiting Host
CrowdStrike Detection	Crowdstrike Detection stream	Exploiting Target	Exploiting Host
AWS VPC Reject	aws_vpc_flow_log + action="REJECT"	Exploiting Host	Exploiting Target
Palo Alto FW Alarm	pan_firewall + severity < 5	Exploiting Host	Exploiting Target
Authentication Failure	messageType="auth_failure"	Exploiting Host	Exploiting Target
The audit log was cleared	Windows Event ID 1102	Exploiting Target	Exploiting Host
User Account Created	Windows Event ID 4720	Exploiting Target	Exploiting Host
Special privileges assigned	Windows Event ID 4672	Exploiting Target	Exploiting Host

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 APT kill chain:

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
8. policy-violation — Policy violations (non-attack)

Incident Modus Operandi

MO Name	Incidents	Description
Data Theft	10,441	Coordinated data exfiltration campaigns
Phishing	1	Phishing-based initial access

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

Product identifier protection: Stream names, message types, pipeline names, and other product metadata fields are explicitly protected from the Aho-Corasick sweep to prevent over-sanitization of security-relevant identifiers.

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 → [email protected]
• Domains → domain-NNNN.example.net
• Windows SIDs → S-1-5-21-1000000000-2000000000-3000000000-NNNN (well-known SIDs 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 JSON fields are inspected recursively using type heuristics to catch PII in fields not covered by structured parsers.

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 (~166,000 patterns). Product identifiers (stream names, message types, pipeline names, severity codes, etc.) are protected from the sweep.

Layer 2: Format-Specific Message Parsing

Raw log messages are parsed using 8 format-specific parsers:

• Cisco ASA syslog — src IFACE:IP/PORT dst IFACE:IP/PORT patterns
• Windows Security Event XML — DOM parsing of TargetUserName, IpAddress, WorkstationName, SubjectDomainName, MemberSid, etc.
• WinLogBeat JSON — Recursive parsing of nested structures including agent.name, host.hostname, winlog.event_data.*, organization
• AWS CloudTrail — userIdentity, sourceIPAddress, userName, accessKeyId, recursive requestParameters/responseElements
• Palo Alto Networks CSV — BSD syslog header + CSV field parsing
• VMware ESXi — BSD syslog header hostname and IP extraction
• DNS events — IP sanitization with public domain allowlist (~1,000 domains)
• Generic fallback — Comprehensive regex battery for all unrecognized formats

Layer 3: ML/NER Residual Detection

Machine learning models scan a stratified random sample of sanitized records:

• Microsoft Presidio with spaCy en_core_web_lg — Entity recognition for PERSON, ORGANIZATION, IP_ADDRESS, EMAIL_ADDRESS
• HuggingFace BERT NER (dslim/bert-base-NER) — Transformer-based PER, ORG, LOC detection

Layer 4: Claude AI Contextual Review

A stratified sample is submitted to Anthropic's Claude API for contextual PII review, catching organization names, internal hostnames, employee names in file paths, AD group names, geographic identifiers, and database instance names.

Iterative Convergence

The 4-layer pipeline runs in iterative cycles until Layer 3 and Layer 4 find near-zero new entries. PII discovered by ML/AI in one cycle is caught by regex/Aho-Corasick in all subsequent cycles across the full dataset.

Sanitization Registry Statistics

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

PII Category	Entries	Replacement Pattern
Public IPs	88,917	RFC 5737 TEST-NET (deterministic)
ARNs	43,838	arn:aws:iam::NNNN:sanitized/NNNN
AWS Account IDs	31,460	Sequential 12-digit IDs
Hostnames	30,374	HOST-NNNN
Private IPs	24,509	HMAC-remapped RFC 1918 (subnet-preserving)
Credentials	23,859	CRED-NNNN
Usernames	23,188	USER-NNNN
FQDNs	17,234	host-NNNN.example.internal
Organizations	11,013	ORG-NNNN
Emails	3,723	[email protected]
Windows SIDs	2,019	Standardized replacement SIDs
Machine Accounts	1,406	MACHINE-NNNN$
Domains	23	domain-NNNN.example.net
Org IDs	6	Numeric replacement IDs

What Is 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 (explicitly protected from sanitization)
• Lead rule match results — Which detection rules matched each 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 three-tier (malicious/suspicious/benign) event classification
4. Attack lifecycle analysis — Study attack progression patterns mapped to MITRE ATT&CK
5. Detection rule evaluation — Analyze effectiveness of 261 lead detection rules across diverse security products

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: Production SOC data is inherently imbalanced (~92–99% benign). Sampling strategies may be needed 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: Labels depend on WitFoo's automated detection and 261 rules; some attacks may be unlabeled (false negatives) and some benign events may be incorrectly flagged
• Incident coverage: The same 10,442 incidents appear in both the 2M and 114M datasets since incidents are stored separately from signal data

Ethical Considerations

• All customer-identifying information has been removed through the 4-layer sanitization process with ~302,000 PII mappings
• 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.