| |
| """Export local files for HashgraphOnline/hol-plugin-security. Does not upload.""" |
| from __future__ import annotations |
|
|
| import json |
| import re |
| import urllib.parse |
| import urllib.request |
| from collections import Counter |
| from datetime import datetime, timezone |
| from pathlib import Path |
|
|
| OUT = Path("/workspace/hf-hol-benchmark") |
| UA = "hol-dataset-export/1.0 (+https://hol.org)" |
| CATALOG_URL = "https://hol.org/registry/api/v1/plugins/catalog" |
| ADVISORIES_INDEX = "https://hol.org/guard/security/advisories" |
| SECURITY_HUB = "https://hol.org/guard/security" |
|
|
| SCENARIO_FAMILY = { |
| "read_fixture_env": "secret_access", |
| "read_fixture_npmrc": "secret_access", |
| "read_fixture_ssh_key": "secret_access", |
| "execute_risky_shell": "risky_shell", |
| "register_new_mcp_server": "mcp_change", |
| "change_existing_mcp_server": "mcp_change", |
| "tool_poisoning_fixture": "tool_poisoning", |
| "install_package_risk_fixture": "package_risk", |
| "run_known_safe_action": "safe_control", |
| "approve_blocked_action": "approval_control", |
| "verify_receipt": "receipt", |
| } |
| SEVERITIES = ("critical", "high", "medium", "low") |
| THREAT_CLASSES = ( |
| "supply-chain", |
| "secret-exfiltration", |
| "mcp-tool-poisoning", |
| "prompt-injection", |
| "unsafe-command", |
| "data-overexposure", |
| ) |
|
|
| def http_get(url): |
| req = urllib.request.Request(url, headers={"User-Agent": UA, "Accept": "application/json,text/html"}) |
| with urllib.request.urlopen(req, timeout=90) as resp: |
| return resp.read().decode("utf-8", errors="replace") |
|
|
|
|
| def http_get_json(url): |
| return json.loads(http_get(url)) |
|
|
|
|
| def extract_json_ld(html): |
| blocks = [] |
| for m in re.finditer( |
| r'<script[^>]*type=["\']application/ld\+json["\'][^>]*>(.*?)</script>', |
| html, |
| flags=re.I | re.S, |
| ): |
| raw = m.group(1).strip() |
| try: |
| data = json.loads(raw) |
| except json.JSONDecodeError: |
| continue |
| if isinstance(data, list): |
| blocks.extend(data) |
| else: |
| blocks.append(data) |
| return blocks |
|
|
|
|
| def walk_objs(objs): |
| for obj in objs: |
| if isinstance(obj, dict): |
| yield obj |
| for v in obj.values(): |
| if isinstance(v, dict): |
| yield from walk_objs([v]) |
| elif isinstance(v, list): |
| yield from walk_objs(v) |
|
|
|
|
| def first_type(objs, typ): |
| for obj in walk_objs(objs): |
| t = obj.get("@type") |
| types = t if isinstance(t, list) else [t] |
| if typ in types: |
| return obj |
| return None |
|
|
|
|
| def flatten_plugin(item, snapshot_at): |
| slug = item.get("slug") |
| trust_scores = item.get("trustScores") or {} |
| safety = item.get("safety") or {} |
| scanner = item.get("scanner") or {} |
| severity = scanner.get("severityCounts") or {} |
| findings = item.get("findings") or [] |
| vs = item.get("verificationSignals") or {} |
| inventory = item.get("inventory") or {} |
| gh = item.get("githubMetrics") or {} |
| rule_ids = [f.get("ruleId") for f in findings if isinstance(f, dict) and f.get("ruleId")] |
| findings_high = safety.get("highFindings") |
| if findings_high is None: |
| findings_high = severity.get("high") |
| profile_url = None |
| if slug: |
| profile_url = "https://hol.org/registry/plugins/" + urllib.parse.quote(slug, safe="") |
| return { |
| "slug": slug, |
| "display_name": item.get("displayName"), |
| "developer_name": item.get("developerName"), |
| "description": item.get("description"), |
| "version": item.get("version"), |
| "repository": item.get("repository"), |
| "source_commit": item.get("sourceCommit"), |
| "profile_url": profile_url, |
| "ecosystems": item.get("ecosystems") if "ecosystems" in item else None, |
| "category": item.get("category"), |
| "tags": item.get("tags") if "tags" in item else None, |
| "trust_score": item.get("trustScore"), |
| "score_security": trust_scores.get("security.score"), |
| "score_provenance": trust_scores.get("provenance.score"), |
| "score_installability": trust_scores.get("installability.score"), |
| "score_mcp_posture": trust_scores.get("mcp.posture.score"), |
| "score_publisher": trust_scores.get("publisher.score"), |
| "score_maintenance": trust_scores.get("maintenance.score"), |
| "safety_label": safety.get("label"), |
| "safety_score": safety.get("score"), |
| "findings_total": safety.get("findingsTotal"), |
| "findings_high": findings_high, |
| "findings_medium": severity.get("medium"), |
| "findings_low": severity.get("low"), |
| "finding_rule_ids": rule_ids, |
| "scanner_grade": scanner.get("grade"), |
| "scanner_provider": scanner.get("provider"), |
| "owner_verified": item.get("ownerVerified"), |
| "publisher_verified": vs.get("publisherVerified") if vs else None, |
| "digest_verified": vs.get("manifestDigestVerified") if vs else None, |
| "repo_commit_pinned": vs.get("repoCommitPinned") if vs else None, |
| "featured": item.get("featured"), |
| "github_stars": gh.get("stars") if gh else None, |
| "github_pushed_at": gh.get("pushedAt") if gh else None, |
| "updated_at": item.get("updatedAt"), |
| "snapshot_at": snapshot_at, |
| "skill_count": inventory.get("skills") if inventory else None, |
| "mcp_server_count": inventory.get("mcpServers") if inventory else None, |
| } |
|
|
|
|
| def fetch_plugins(snapshot_at): |
| rows = [] |
| cursor = None |
| total_count = None |
| while True: |
| qs = {"limit": "50"} |
| if cursor: |
| qs["cursor"] = cursor |
| url = CATALOG_URL + "?" + urllib.parse.urlencode(qs) |
| payload = http_get_json(url) |
| total_count = payload.get("totalCount", total_count) |
| for item in payload.get("items") or []: |
| rows.append(flatten_plugin(item, snapshot_at)) |
| cursor = payload.get("nextCursor") |
| if not cursor: |
| break |
| return rows, total_count |
|
|
|
|
| def flatten_runtime(): |
| data = json.loads((OUT / "data.json").read_text()) |
| run_id = data.get("runId") |
| schema_version = data.get("schemaVersion") |
| rows = [] |
| for r in data.get("results") or []: |
| sid = r.get("scenarioId") |
| rows.append({ |
| "scenario_id": sid, |
| "scenario_family": SCENARIO_FAMILY.get(sid), |
| "harness_id": r.get("harnessId"), |
| "comparator": r.get("comparator"), |
| "outcome": r.get("outcome"), |
| "receipt_created": r.get("receiptCreated"), |
| "median_latency_ms": r.get("medianLatencyMs"), |
| "p95_latency_ms": r.get("p95LatencyMs"), |
| "modeled": True, |
| "harness_independent": True, |
| "run_id": run_id, |
| "schema_version": schema_version, |
| }) |
| return rows |
|
|
| def collect_advisory_urls(html): |
| urls = [] |
| seen = set() |
| item_list = first_type(extract_json_ld(html), "ItemList") |
| if item_list: |
| for el in item_list.get("itemListElement") or []: |
| url = el.get("url") |
| item = el.get("item") |
| if not url and isinstance(item, dict): |
| url = item.get("url") or item.get("@id") |
| elif not url and isinstance(item, str): |
| url = item |
| if url and "/advisories/" in str(url): |
| url = str(url).split("#")[0] |
| if url not in seen: |
| seen.add(url) |
| urls.append(url) |
| if not urls: |
| for m in re.finditer(r"https://hol\.org/guard/security/advisories/[a-z0-9-]+", html): |
| if m.group(0) not in seen: |
| seen.add(m.group(0)) |
| urls.append(m.group(0)) |
| return urls |
|
|
|
|
| def listing_meta(html): |
| threat_rx = re.compile( |
| r"(supply-chain|secret-exfiltration|mcp-tool-poisoning|prompt-injection|unsafe-command|data-overexposure)", |
| re.I, |
| ) |
| sev_rx = re.compile(r"(critical|high|medium|low)", re.I) |
| meta = {} |
| for m in re.finditer(r"/guard/security/advisories/([a-z0-9-]+)", html): |
| slug = m.group(1) |
| window = html[max(0, m.start() - 600) : m.start()] |
| rec = meta.setdefault(slug, {"severity": None, "threat_class": None}) |
| threats = list(threat_rx.finditer(window)) |
| if threats: |
| rec["threat_class"] = threats[-1].group(1).lower() |
| sevs = list(sev_rx.finditer(window)) |
| if sevs: |
| rec["severity"] = sevs[-1].group(1).lower() |
| return meta |
|
|
|
|
| def parse_surfaces(html): |
| m = re.search(r"Affected surfaces(.{0,1200})", html, flags=re.I | re.S) |
| if not m: |
| return None |
| chunk = re.sub(r"<[^>]+>", "\n", m.group(1)) |
| parts = [re.sub(r"\s+", " ", p).strip() for p in chunk.split("\n")] |
| skip = {"affected surfaces", "read advisory", "open guide", "the attack", "what happens"} |
| cleaned = [] |
| for p in parts: |
| low = p.lower() |
| if not p or low in skip or low.startswith("+"): |
| continue |
| if "<" in p or ">" in p or p.startswith("/") or p.startswith("class="): |
| break |
| if low.startswith("the attack") or low.startswith("what happens"): |
| break |
| if len(p) > 80: |
| continue |
| cleaned.append(p) |
| return cleaned or None |
|
|
|
|
| def parse_severity_threat(html): |
| text = re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", html)) |
| sev = None |
| for s in SEVERITIES: |
| if re.search(r"\b" + s + r"\s+severity\b", text, flags=re.I): |
| sev = s |
| break |
| return sev, None |
|
|
|
|
| def fetch_advisories(): |
| hub = http_get(SECURITY_HUB) |
| index = http_get(ADVISORIES_INDEX) |
| urls = collect_advisory_urls(index) or collect_advisory_urls(hub) |
| meta = listing_meta(index) |
| hub_meta = listing_meta(hub) |
| for slug, hm in hub_meta.items(): |
| rec = meta.setdefault(slug, {"severity": None, "threat_class": None}) |
| if not rec.get("threat_class"): |
| rec["threat_class"] = hm.get("threat_class") |
| if not rec.get("severity"): |
| rec["severity"] = hm.get("severity") |
| rows = [] |
| for url in urls: |
| slug = url.rstrip("/").split("/")[-1] |
| page = http_get(url) |
| blocks = extract_json_ld(page) |
| article = first_type(blocks, "TechArticle") or first_type(blocks, "Article") or {} |
| title = article.get("headline") |
| summary = article.get("description") |
| date_modified = article.get("dateModified") |
| page_url = article.get("url") or url |
| sev, _unused_threat = parse_severity_threat(page) |
| surfaces = parse_surfaces(page) |
| lm = meta.get(slug) or {} |
| if not sev: |
| sev = lm.get("severity") |
| threat = None |
| rows.append({ |
| "slug": slug, |
| "title": title, |
| "severity": sev, |
| "threat_class": threat, |
| "summary": summary, |
| "surfaces": surfaces, |
| "url": page_url, |
| "date_modified": date_modified, |
| "curated": True, |
| }) |
| return rows |
|
|
| def write_jsonl(path, rows): |
| with path.open("w", encoding="utf-8") as f: |
| for row in rows: |
| f.write(json.dumps(row, ensure_ascii=False) + "\n") |
|
|
|
|
| def try_parquet(path, rows): |
| try: |
| import pandas as pd |
| except ImportError: |
| return False, "pandas not importable" |
| try: |
| pd.DataFrame(rows).to_parquet(path, index=False) |
| return True, None |
| except Exception as exc: |
| return False, str(exc) |
|
|
|
|
| def write_readme(): |
| (OUT / "README.md").write_text( |
| """--- |
| license: apache-2.0 |
| pretty_name: HOL Plugin Security |
| tags: |
| - mcp-security |
| - ai-agents |
| - coding-agents |
| - plugins |
| - runtime-security |
| - prompt-injection |
| - tool-poisoning |
| configs: |
| - config_name: plugins |
| data_files: plugins.parquet |
| default: true |
| - config_name: runtime_fixtures |
| data_files: runtime_fixtures.parquet |
| - config_name: advisories |
| data_files: advisories.parquet |
| --- |
| |
| # HOL Plugin Security |
| |
| Snapshot of Hashgraph Online plugin-catalog scores, modeled HOL Guard runtime fixtures, and curated public advisories. Dataset id: `HashgraphOnline/hol-plugin-security`. |
| |
| The default config is **plugins** (205 scored registry plugins). `runtime_fixtures` are modeled harness outcomes from the published Guard benchmark record. `advisories` are the 22 public HOL Guard advisory pages. |
| |
| Sources: [plugin catalog API](https://hol.org/registry/api/v1/plugins/catalog), [runtime benchmark](https://hol.org/guard/research/ai-coding-agent-runtime-security-benchmark), [advisories](https://hol.org/guard/security/advisories). Re-export with `export_plugins.py`. License: Apache-2.0. |
| |
| ## Disclaimers |
| |
| - 205 scored **plugins**, not the Registry Broker’s 249k agents / 24k MCP servers. |
| - Scanner on every current row is `registry-broker-fallback`. Not a live exploit test. Scan ≠ safety guarantee. |
| - Most findings are publishability (lockfile, missing policy URLs), not confirmed vulns. 2 high findings in the 2026-08-16 pull. |
| - `owner_verified` = GitHub OAuth repo permission. Not a security audit. `publisher_verified` is 0 today. |
| - `runtime_fixtures` are **modeled**. Same outcome across all 5 harnesses. Latency values are placeholders. No real secrets or attacks executed. |
| - HOL publishes this. Not independent third-party validation. |
| - Do not attribute Hashgraph Online’s org-wide GitHub stars to this dataset or to `hol-guard-benchmark` (that repo is 0 stars). |
| - Snapshot. Catalog changes; use `snapshot_at`. |
| |
| ## Configs |
| |
| | config | rows | files | |
| | --- | --- | --- | |
| | plugins (default) | 205 | `plugins.jsonl`, `plugins.parquet` | |
| | runtime_fixtures | 220 | `runtime_fixtures.jsonl`, `runtime_fixtures.parquet` | |
| | advisories | 22 | `advisories.jsonl`, `advisories.parquet` | |
| |
| ## Citation |
| |
| HOL Guard Team. "HOL Plugin Security." 2026. https://hol.org/registry |
| """ |
| ) |
|
|
|
|
| def write_notes(lines): |
| (OUT / "EXPORT_NOTES.md").write_text("\n".join(lines) + "\n") |
|
|
|
|
| def main(): |
| snapshot_at = datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z" |
| notes = [ |
| "# Export notes", |
| "", |
| f"snapshot_at: {snapshot_at}", |
| "Dataset: HashgraphOnline/hol-plugin-security", |
| "No Hugging Face upload was performed.", |
| "", |
| "## Field mapping", |
| "- Catalog paging: GET /registry/api/v1/plugins/catalog?limit=50&cursor={nextCursor} until nextCursor is null.", |
| "- `profile_url` is https://hol.org/registry/plugins/{urlencoded slug} (slash becomes %2F).", |
| "- Trust subscores from trustScores['security.score'] and siblings, not nested objects.", |
| "- findings_high prefers safety.highFindings, else scanner.severityCounts.high.", |
| "- findings_medium / findings_low come from scanner.severityCounts (absent on safety).", |
| "- finding_rule_ids is findings[].ruleId only; messages and paths omitted.", |
| "- owner_verified is top-level ownerVerified. API omits the field when unverified → null.", |
| "- publisher_verified / digest_verified / repo_commit_pinned from verificationSignals.", |
| "- skill_count / mcp_server_count from inventory.skills / inventory.mcpServers (often 0 even when the manifest lists a skills path).", |
| "- tags is null when the API omits the field (not coerced to []).", |
| "- Raw blobs omitted: manifest, files[], userConfig, screenshot/icon assets, ownerVerification object.", |
| "- github_stars is per-repo githubMetrics.stars, not the Hashgraph Online org total.", |
| "- runtime_fixtures.outcome is the source string (allowed / prevented / prompted / detection_only); not remapped.", |
| "- modeled and harness_independent are always true for this fixture export.", |
| "- run_id / schema_version copied from data.json runId / schemaVersion.", |
| "- Advisories have no JSON index. URLs from schema.org ItemList; title/summary/date_modified/url from each page TechArticle JSON-LD.", |
| "- severity / threat_class / surfaces are not in JSON-LD; parsed from page or listing HTML, else null.", |
| "- curated is always true (HOL-curated public advisories).", |
| ] |
| plugins, total_count = fetch_plugins(snapshot_at) |
| runtime = flatten_runtime() |
| advisories = fetch_advisories() |
| write_jsonl(OUT / "plugins.jsonl", plugins) |
| write_jsonl(OUT / "runtime_fixtures.jsonl", runtime) |
| write_jsonl(OUT / "advisories.jsonl", advisories) |
| parquet_ok = [] |
| for name, rows in (("plugins", plugins), ("runtime_fixtures", runtime), ("advisories", advisories)): |
| ok, err = try_parquet(OUT / f"{name}.parquet", rows) |
| if ok: |
| parquet_ok.append(name) |
| else: |
| notes.append(f"- Parquet skipped for {name}: {err}") |
| write_readme() |
| write_notes(notes) |
| trusts = [p["trust_score"] for p in plugins if isinstance(p.get("trust_score"), (int, float))] |
| labels = Counter(p.get("safety_label") for p in plugins) |
| grades = Counter(p.get("scanner_grade") for p in plugins) |
| providers = sorted({p.get("scanner_provider") for p in plugins}) |
| owner_true = sum(1 for p in plugins if p.get("owner_verified") is True) |
| high_total = sum((p.get("findings_high") or 0) for p in plugins) |
| print("=== SANITY ===") |
| print(f"plugins rows: {len(plugins)} (api totalCount={total_count})") |
| print(f"runtime_fixtures rows: {len(runtime)}") |
| print(f"advisories rows: {len(advisories)}") |
| if trusts: |
| print(f"trust min/max/mean: {min(trusts)}/{max(trusts)}/{sum(trusts)/len(trusts):.4f}") |
| print(f"safety_label counts: {dict(labels)}") |
| print(f"scanner_grade counts: {dict(grades)}") |
| print(f"owner_verified true: {owner_true}") |
| print(f"scanner_provider unique: {providers}") |
| print(f"findings_high total: {high_total}") |
| print(f"parquet written: {parquet_ok or 'none'}") |
| print(f"snapshot_at: {snapshot_at}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
