Datasets:

TocharianOU
/

secops-es-benchmark

#!/usr/bin/env python3
"""
Deterministic pseudonymization for the SecOps benchmark corpus.
Goal: make exported evidence / answer keys shareable WITHOUT leaking real IPs,
usernames, hostnames or secrets, while PRESERVING correlatability — the same real
value always maps to the same fake value, so cross-index / cross-host links survive.
Usage:
    export BENCH_PSEUDO_SALT="some-long-secret"      # keep this stable & private
    python3 pseudonymize.py < raw.json > clean.json  # stream JSON/text
    python3 pseudonymize.py file1.md file2.json      # in-place-ish -> .pseudo
Method: HMAC-SHA256(salt, value) -> stable short token. IP structure preserved
(public vs RFC1918 vs CGNAT/Tailscale 100.64/10); secrets (shadow hashes) redacted.
"""
import hashlib, hmac, ipaddress, os, re, sys

SALT = os.environ.get("BENCH_PSEUDO_SALT", "CHANGE-ME-benchmark-salt").encode()

def _h(value: str, n: int = 8) -> str:
    return hmac.new(SALT, value.encode(), hashlib.sha256).hexdigest()[:n]

# ---------------------------------------------------------------------------
# POLICY (v0.2, "keep-real-infra"):
#   KEEP REAL: IP addresses, hostnames, domains (tocharian.eu, ubuntu-2404-…,
#              attacktrace), the MISP platform, stripe.com DNS, the name "luke".
#   SCRUB    : real emails, ALL "newmind*" business identifiers, the MySQL DB
#              password, OS password hashes, private keys, API tokens/JWT/AWS.
# Rationale: the authors do not consider their own infrastructure IPs/hostnames
# sensitive, and keeping real IPs avoids the TEST-NET "this is synthetic" tell —
# improving benchmark validity. Only secrets and third-party business/PII are removed.
# ---------------------------------------------------------------------------

# business identifier to remove entirely (any newmind* -> appA; no "newmind" remains)
NEWMIND_RE = re.compile(r"newmind", re.IGNORECASE)

# --- secrets / PII to redact ---------------------------------------------------
SHADOW_HASH_RE = re.compile(r"\$(?:y|gy|6|5|1|2[aby])\$[^\s:\"]+")   # crypt() hashes
AWS_RE = re.compile(r"AKIA[0-9A-Z]{8,}")
EMAIL_RE = re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b")
JWT_RE = re.compile(r"\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{6,}\b")
PRIVKEY_RE = re.compile(r"-----BEGIN [A-Z ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z ]*PRIVATE KEY-----")
# db password: mysql/cli `-p<pw>` where the value looks like a password (has pass/pwd).
# Anchoring on pass/pwd avoids eating benign flags like -parts / -path / -policy.
DBPW_RE = re.compile(r"(-p)([A-Za-z0-9_.@!#%^*+-]*(?:pass|pwd)[A-Za-z0-9_.@!#%^*+-]*)", re.IGNORECASE)
# require a real =/: assignment so we don't eat "/etc/passwd" or "GET /x passwd HTTP"
BEARER_RE = re.compile(r"(?i)\b(bearer|api[_-]?key|password|passwd|secret|token)(\s*[=:]\s*[\"']?)([^\s\"',}]+)")

def scrub(text: str) -> str:
    # secrets / PII only — IPs and hostnames are intentionally left REAL
    text = SHADOW_HASH_RE.sub("<REDACTED_PWHASH>", text)
    text = PRIVKEY_RE.sub("<REDACTED_PRIVATE_KEY>", text)
    text = JWT_RE.sub("<REDACTED_JWT>", text)
    text = AWS_RE.sub("<REDACTED_AWS_KEY>", text)
    text = DBPW_RE.sub(lambda m: f"{m.group(1)}<REDACTED>", text)         # mysql -p<pw>
    text = BEARER_RE.sub(lambda m: f"{m.group(1)}{m.group(2)}<REDACTED>", text)
    text = EMAIL_RE.sub("<REDACTED_EMAIL>", text)                          # scrub emails
    text = NEWMIND_RE.sub("appA", text)                                    # remove newmind*
    return text

def _walk(o):
    if isinstance(o, str):
        return scrub(o)
    if isinstance(o, list):
        return [_walk(x) for x in o]
    if isinstance(o, dict):
        return {k: _walk(v) for k, v in o.items()}
    return o

def scrub_json(line):
    """Structure-safe scrub for an NDJSON line: only string VALUES are scrubbed, so a
    field name or path like /etc/passwd can never corrupt the JSON. Falls back to raw
    text scrub if the line is not valid JSON."""
    import json as _json
    try:
        return _json.dumps(_walk(_json.loads(line)), ensure_ascii=False)
    except Exception:
        return scrub(line)

def main(argv):
    if len(argv) <= 1:
        # stream NDJSON structure-safely
        for line in sys.stdin:
            line = line.rstrip("\n")
            if line.strip():
                sys.stdout.write(scrub_json(line) + "\n")
        return
    for path in argv[1:]:
        with open(path) as f:
            out = scrub(f.read())
        with open(path + ".pseudo", "w") as f:
            f.write(out)
        print(f"wrote {path}.pseudo", file=sys.stderr)

if __name__ == "__main__":
    main(sys.argv)

	#!/usr/bin/env python3
	"""
	Deterministic pseudonymization for the SecOps benchmark corpus.

	Goal: make exported evidence / answer keys shareable WITHOUT leaking real IPs,
	usernames, hostnames or secrets, while PRESERVING correlatability — the same real
	value always maps to the same fake value, so cross-index / cross-host links survive.

	Usage:
	export BENCH_PSEUDO_SALT="some-long-secret" # keep this stable & private
	python3 pseudonymize.py < raw.json > clean.json # stream JSON/text
	python3 pseudonymize.py file1.md file2.json # in-place-ish -> .pseudo

	Method: HMAC-SHA256(salt, value) -> stable short token. IP structure preserved
	(public vs RFC1918 vs CGNAT/Tailscale 100.64/10); secrets (shadow hashes) redacted.
	"""
	import hashlib, hmac, ipaddress, os, re, sys

	SALT = os.environ.get("BENCH_PSEUDO_SALT", "CHANGE-ME-benchmark-salt").encode()

	def _h(value: str, n: int = 8) -> str:
	return hmac.new(SALT, value.encode(), hashlib.sha256).hexdigest()[:n]

	# ---------------------------------------------------------------------------
	# POLICY (v0.2, "keep-real-infra"):
	# KEEP REAL: IP addresses, hostnames, domains (tocharian.eu, ubuntu-2404-…,
	# attacktrace), the MISP platform, stripe.com DNS, the name "luke".
	# SCRUB : real emails, ALL "newmind*" business identifiers, the MySQL DB
	# password, OS password hashes, private keys, API tokens/JWT/AWS.
	# Rationale: the authors do not consider their own infrastructure IPs/hostnames
	# sensitive, and keeping real IPs avoids the TEST-NET "this is synthetic" tell —
	# improving benchmark validity. Only secrets and third-party business/PII are removed.
	# ---------------------------------------------------------------------------

	# business identifier to remove entirely (any newmind* -> appA; no "newmind" remains)
	NEWMIND_RE = re.compile(r"newmind", re.IGNORECASE)

	# --- secrets / PII to redact ---------------------------------------------------
	SHADOW_HASH_RE = re.compile(r"\$(?:y\|gy\|6\|5\|1\|2[aby])\$[^\s:\"]+") # crypt() hashes
	AWS_RE = re.compile(r"AKIA[0-9A-Z]{8,}")
	EMAIL_RE = re.compile(r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b")
	JWT_RE = re.compile(r"\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{6,}\b")
	PRIVKEY_RE = re.compile(r"-----BEGIN [A-Z ]PRIVATE KEY-----[\s\S]?-----END [A-Z ]*PRIVATE KEY-----")
	# db password: mysql/cli `-p<pw>` where the value looks like a password (has pass/pwd).
	# Anchoring on pass/pwd avoids eating benign flags like -parts / -path / -policy.
	DBPW_RE = re.compile(r"(-p)([A-Za-z0-9_.@!#%^+-](?:pass\|pwd)[A-Za-z0-9_.@!#%^+-])", re.IGNORECASE)
	# require a real =/: assignment so we don't eat "/etc/passwd" or "GET /x passwd HTTP"
	BEARER_RE = re.compile(r"(?i)\b(bearer\|api[_-]?key\|password\|passwd\|secret\|token)(\s[=:]\s[\"']?)([^\s\"',}]+)")

	def scrub(text: str) -> str:
	# secrets / PII only — IPs and hostnames are intentionally left REAL
	text = SHADOW_HASH_RE.sub("<REDACTED_PWHASH>", text)
	text = PRIVKEY_RE.sub("<REDACTED_PRIVATE_KEY>", text)
	text = JWT_RE.sub("<REDACTED_JWT>", text)
	text = AWS_RE.sub("<REDACTED_AWS_KEY>", text)
	text = DBPW_RE.sub(lambda m: f"{m.group(1)}<REDACTED>", text) # mysql -p<pw>
	text = BEARER_RE.sub(lambda m: f"{m.group(1)}{m.group(2)}<REDACTED>", text)
	text = EMAIL_RE.sub("<REDACTED_EMAIL>", text) # scrub emails
	text = NEWMIND_RE.sub("appA", text) # remove newmind*
	return text

	def _walk(o):
	if isinstance(o, str):
	return scrub(o)
	if isinstance(o, list):
	return [_walk(x) for x in o]
	if isinstance(o, dict):
	return {k: _walk(v) for k, v in o.items()}
	return o

	def scrub_json(line):
	"""Structure-safe scrub for an NDJSON line: only string VALUES are scrubbed, so a
	field name or path like /etc/passwd can never corrupt the JSON. Falls back to raw
	text scrub if the line is not valid JSON."""
	import json as _json
	try:
	return _json.dumps(_walk(_json.loads(line)), ensure_ascii=False)
	except Exception:
	return scrub(line)

	def main(argv):
	if len(argv) <= 1:
	# stream NDJSON structure-safely
	for line in sys.stdin:
	line = line.rstrip("\n")
	if line.strip():
	sys.stdout.write(scrub_json(line) + "\n")
	return
	for path in argv[1:]:
	with open(path) as f:
	out = scrub(f.read())
	with open(path + ".pseudo", "w") as f:
	f.write(out)
	print(f"wrote {path}.pseudo", file=sys.stderr)

	if __name__ == "__main__":
	main(sys.argv)