fox-srt/cobaltstrike-beacon-corpus

Fox-IT Cobalt Strike Beacon Corpus

The Fox-IT Cobalt Strike Beacon Corpus contains Cobalt Strike beacons downloaded from internet-facing Team Servers between July 2018 and 29 September 2026, together with their parsed configurations.

Metric	Value
Unique beacons (raw payloads)	56,843
Sightings	190,182
Unique ip:port	36,652
First sighting	2018-07-04
Last sighting	2026-09-29

• Blog: https://blog.fox-it.com/2026/10/13/releasing-the-cobalt-strike-beacon-corpus/
• Beacon Parser: https://github.com/fox-it/dissect.cobaltstrike

Files

File	Rows	Contents
beacons.parquet	190,182	One row per sighting: when and where a beacon was collected, plus its parsed configuration.
payloads.parquet	56,843	One row per unique beacon: the raw payload, wrapped in CaRT.

Most research only needs beacons.parquet. You can download payloads.parquet to re-parse beacons or to look into the ones that failed to parse.

Collection

All beacons were downloaded directly from internet-facing Team Servers, mostly on TCP ports 80 and 443 (HTTP and HTTPS) and UDP port 53 (DNS), with a small number on other ports. Candidate servers came from Fox-IT's own internet-wide scanning. From each one we requested a stager using a URI that passes Cobalt Strike's checksum8 check, or, for DNS listeners, a series of TXT record lookups sent directly to the server. No samples from other sources (such as VirusTotal) are included.

Every beacon was parsed with dissect.cobaltstrike.

Schema

beacons.parquet

A sighting is unique per beacon (sha256), IP, port and collection date.

Column	Type	Description
id	int	Row ID, can be used to reference a sighting
sha256	string	SHA-256 of the raw beacon payload; joins to payloads.parquet
status	string	Parse status reported by dissect.cobaltstrike
collected_on	string	Date of the beacon download (sighting)
collected_from_ip	string	IP address of the Team Server
collected_from_port	int	Port the beacon was downloaded from (53 = DNS)
protocol	string	Listener protocol (dumped from config) from the beacon configuration (http, https, dns, …)
watermark	string	Beacon watermark as hex string (dumped from config)
version	string	Cobalt Strike version detected by dissect.cobaltstrike (dumped from config)
config_json	string	Full parsed configuration as JSON (see below)
tls_subject	string	TLS certificate subject from the Team Server
tls_issuer	string	TLS certificate issues from the Team Server
tls_fingerprint_sha256	string	TLS SHA256 fingerprint of the certificate from the Team Server
pe_export_stamp	uint32	PE export timestamp of the beacon payload
pe_compile_stamp	uint32	PE compile timestamp of the beacon payload
geo_asn	integer	ASN of the Team Server IP address
geo_as_org	string	Organization name of the Team Server IP address
geo_country	string	Country code of the Team Server IP address
geo_country_code	string	Country code of the Team Server IP address
geo_db	string	GeoIP database used to resolve the Team Server IP address

config_json

config_json holds the full beacon configuration plus some metadata from the parser as a JSON string. Every SETTING_* value sits under settings, and byte values are stored as hex strings. Example:

{
  "domains": ["malware.domain", …],
  "protocol": "dns",
  "watermark": "0x4de0a4af",
  "version": "Cobalt Strike 4.13 (Jun 10, 2026)",
  "pubkey_sha256": "20440a20f900560374621fab5bc40b19e1043b81a184aeac15ea1498da7cd257",
  "settings": {
    "SETTING_PROTOCOL": 1,
    "SETTING_PORT": 53,
    "SETTING_DNS_IDLE": "1.1.1.1",
    "SETTING_DNS_BEACON_PUT_OUTPUT": "api.",
    "SETTING_WATERMARKHASH": "4f4c417769516a49756c4a645579562b7546547630513d3d",
    "SETTING_CFG_CAUTION": 0,
    "SETTING_DNS_DOH_USERAGENT": "Mozilla/5.0 (Windows NT 6.1; WOW64; rv:40.0) Gecko/20100101 Firefork/48.1",
    "SETTING_WATERMARK": 1306567855,
    "SETTING_DNS_DOH_SERVERS": "cloudflare-dns.com",
    …
  },
  "stages": [
    "ObfuscatedBeacon(OBFUSCATION_LZNT1)",
    "ObfuscatedBeacon(OBFUSCATION_BASE64)",
    "ObfuscatedBeacon(OBFUSCATION_XOR)",
    "ObfuscatedBeacon(OBFUSCATION_RC4)",
    "ObfuscatedBeacon(OBFUSCATION_LZNT1)",
    "ObfuscatedBeacon(OBFUSCATION_NONE)"
  ],
  "xorkey": "2e",
  "layout": {…},
  "guardrails": {…},
}

The layout key contains the settings layout, example:

"layout": {
  "indexes": [1, 2, 3, …],
  "types": [1, 1, 2, …],
  "sizes": [2, 2, 4, …],
},

Example values for the first setting in the layout:

type	integer	enum / size
index	1	SETTING_PROTOCOL
type	1	TYPE_SHORT
size	2	2 bytes

This can be useful to find modified beacons, such as shuffled configuration settings or remapped types. For the full types and enum mappings, see https://dissect-cobaltstrike.readthedocs.io/en/latest/structures/cs_def.html

The guardrails key can be present if the beacon was protected using Guardrails:

"guardrails": {
  "beacon_xor_key": "2e",
  "guardrail_xor_key": "8a",
  "payload_xor_key": "npc",
  "settings": ["GUARD_COMPUTER", "GUARD_PAYLOAD_CHECKSUM"]
}

The modifications key can be present if the beacon configuration block was modified to break parsers:

"modifications": {
  "tags": ["remapped_types"],
  "remapped_types": {
    "65535": 1,
    "65534": 2,
    "65533": 3
  }
}

In this case the beacon config had remapped types where:

type name	original type value	modified to value
TYPE_SHORT	1	65535
TYPE_INT	2	65534
TYPE_PTR	3	65533

It was automatically corrected by dissect.cobaltstrike so the beacon could be parsed.

payloads.parquet

Column	Type	Description
sha256	string	SHA-256 of the beacon
md5	string	MD5 of the beacon
beacon_size	int	Size of the beacon in bytes
payload_cart	binary	Beacon payload stored in CaRT format

Usage

Query with DuckDB

DuckDB can query the files on Hugging Face directly:

SELECT watermark,
       count(*)                          AS sightings,
       count(DISTINCT collected_from_ip) AS servers,
       min(collected_on)                 AS first_seen,
       max(collected_on)                 AS last_seen
FROM 'hf://datasets/fox-srt/cobaltstrike-beacon-corpus/data/beacons.parquet'
GROUP BY watermark
ORDER BY sightings DESC
LIMIT 20;

┌────────────┬───────────┬─────────┐
│ watermark  │ sightings │ servers │
│  varchar   │   int64   │  int64  │
├────────────┼───────────┼─────────┤
│ 0x0        │     31776 │    4922 │
│ 0x12345678 │     28892 │    4361 │
│ 0x3ade68b1 │     11365 │    2403 │
│ 0x5109bf6d │      9035 │    1552 │
│ 0x499602d2 │      8574 │    1542 │
│ 0x1969a08d │      7192 │    1330 │
│ 0x5e2e7890 │      5940 │     701 │
│ NULL       │      5647 │     716 │
│ 0x6faa51c3 │      5313 │     929 │
│ 0x175065ea │      4632 │     912 │
│ 0x5e2e7886 │      4529 │     799 │
│ 0x186a0    │      4449 │     837 │
│ 0x27bc86aa │      2889 │     638 │
│ 0x1        │      2719 │     389 │
│ 0xc4fa452  │      1048 │     256 │
│ 0x1000000  │      1042 │     155 │
│ 0x282d4156 │      1010 │     145 │
│ 0x3        │       989 │     227 │
│ 0x3039     │       936 │      97 │
│ 0x5f5e100  │       925 │     112 │
└────────────┴───────────┴─────────┘
  20 rows                3 columns

Unpack and parse a raw beacon

Only unpack beacons in an isolated analysis environment.

Example snippet to get a specific beacon payload by SHA256 and parse it with dissect.cobaltstrike:

# uv --with cart,duckdb,dissect.cobaltstrike python
import io
import cart
import duckdb
from dissect.cobaltstrike.beacon import BeaconConfig

# We can query the payloads.parquet file directly from Hugging Face using DuckDB
DB_PATH = "hf://datasets/fox-srt/cobaltstrike-beacon-corpus/data/payloads.parquet"

con = duckdb.connect()
sha256 = '<SHA256_OF_BEACON>'
data = con.execute(f"SELECT payload_cart FROM '{DB_PATH}' WHERE sha256 = ?", [sha256]).fetchone()[0]
out = io.BytesIO()
cart.unpack_stream(io.BytesIO(data), out)
config = BeaconConfig.from_bytes(out.getvalue())
print(config.settings)

Limitations

• Coverage: only Team Servers that matched our fingerprints and had beacon staging enabled are included. Servers with staging disabled, or hidden behind redirectors or domain fronting, are under-represented. The coverage is mainly focussed on port 80, 443 for HTTP(s) beacons and port 53 for DNS beacons. Other ports might be included, but are not guaranteed to be representative of the overall Cobalt Strike population.
• Collection gaps: there might be some collection gaps due to outages. Treat low or missing months in those periods as collection gaps, not changes in Cobalt Strike use.
• Not all malicious: legitimate red teams use Cobalt Strike too. Don't treat an IP, domain or watermark as malicious based on this corpus alone.
• Stale data: IP addresses and domains get reassigned. A sighting tells you what a host served on the collection date, not what it serves today.
• Raw beacons: Each beacon is wrapped in CaRT, which encodes the file so antivirus doesn't flag or quarantine it. This lets us release the full set, which is too large to upload to VirusTotal or MalwareBazaar, while keeping the samples inert until someone unpacks them on purpose. Beacons are still live malware stagers and may contain working C2 addresses, so handle them the way you would any malware sample.
• What's excluded: The corpus does not contain anything that would help someone run or crack Cobalt Strike.

Safety

The raw beacons are live malware stagers and may contain working C2 addresses. Each one is wrapped in CaRT, which encodes the file so antivirus doesn't flag or quarantine it while you download and store it. Handle unpacked beacons the way you would any malware sample.

Citation

@misc{hu2026cobaltstrike,
  title        = {{Fox-IT Cobalt Strike Beacon Corpus}},
  author       = {Hu, Yun Zheng},
  year         = 2026,
  publisher    = {Hugging Face},
  organization = {Fox-IT},
  doi          = {10.57967/hf/10887},
  url          = {https://huggingface.co/datasets/fox-srt/cobaltstrike-beacon-corpus},
  note         = {Beacons collected from internet-facing Team Servers, July 2018 to September 2026}
}

License

The collection metadata and parsed beacon configurations are released under the Creative Commons Attribution 4.0 International (CC BY 4.0) license. The raw beacon payloads are not covered by this license. They are provided as-is, for research purposes only.

Links

• Blog post (2026): Releasing the Cobalt Strike Beacon Corpus
• Previous post (2022): Mining Data from Cobalt Strike Beacons
• Previous dataset (2022): fox-it/cobaltstrike-beacon-data