| |
| """Persistent benchmark.py adapter for Cisco's released SecureBERT detection head. |
| |
| The original benchmark run did not record the exact Hub snapshot revision. |
| Set SECUREBERT_MODEL to that snapshot when reproducing a specific run. |
| """ |
|
|
| import json |
| import math |
| import os |
| import sys |
|
|
| from huggingface_hub import snapshot_download |
| import torch |
| from transformers import AutoModelForSequenceClassification, AutoTokenizer |
|
|
|
|
| CAPS = (("method", 2800), ("edges", 120), ("callers", 520), |
| ("callees", 520), ("module", 240), ("imports", 120)) |
| path = os.getenv("SECUREBERT_MODEL") or snapshot_download( |
| "cisco-ai/SecureBERT2.0-code-vuln-detection") |
| tokenizer = AutoTokenizer.from_pretrained(path) |
| model = AutoModelForSequenceClassification.from_pretrained(path, attn_implementation="sdpa") |
| device = "cuda" if torch.cuda.is_available() else "mps" if torch.backends.mps.is_available() else "cpu" |
| model.to(device).eval() |
|
|
|
|
| def sections(row): |
| state = row["state"] |
| method = state["method"] |
|
|
| def neighbors(key): |
| return "\n".join(f"{item.get('name', '')} ({item.get('path', '')})\n{item.get('source', '')}" |
| for item in state.get(key, [])) |
|
|
| return { |
| "method": f"LANGUAGE: {row['language']}\nPATH: {method.get('path', '')}" |
| f"\nMETHOD: {method.get('name', '')}\n{method.get('source', '')}", |
| "edges": "CALL GRAPH EDGES:\n" + "\n".join(state.get("call_graph", [])), |
| "callers": "CALLERS:\n" + neighbors("called_by"), |
| "callees": "CALLEES:\n" + neighbors("calls"), |
| "module": "MODULE SCOPE:\n" + str(state.get("module_scope", "")), |
| "imports": "IMPORTS:\n" + "\n".join(map(str, state.get("imports", []))), |
| } |
|
|
|
|
| with torch.inference_mode(): |
| for line in sys.stdin: |
| row = json.loads(line) |
| if row["domain"] != "security": |
| raise ValueError("SecureBERT adapter supports security only") |
| if "question_name" in row: |
| raise ValueError("SecureBERT does not accept CWE questions; use its native protocol ID") |
| parts = sections(row) |
| ids = [tokenizer.cls_token_id] |
| for name, cap in CAPS: |
| ids.extend(tokenizer.encode(parts[name], add_special_tokens=False)[:cap]) |
| ids.append(tokenizer.sep_token_id) |
| if len(ids) > 4096: |
| ids = ids[:4095] + [tokenizer.sep_token_id] |
| length = math.ceil(len(ids) / 64) * 64 |
| tokens = torch.full((1, length), tokenizer.pad_token_id, dtype=torch.long, device=device) |
| mask = torch.zeros_like(tokens) |
| tokens[0, :len(ids)] = torch.tensor(ids, dtype=torch.long, device=device) |
| mask[0, :len(ids)] = 1 |
| hidden = model.model(input_ids=tokens, attention_mask=mask)[0] |
| if model.config.classifier_pooling == "mean": |
| m = mask.unsqueeze(-1) |
| pooled = (hidden * m).sum(1) / m.sum(1).clamp(min=1) |
| else: |
| pooled = hidden[:, 0] |
| logits = model.classifier(model.drop(model.head(pooled)))[0].float() |
| score = torch.sigmoid(logits[1] - logits[0]).item() |
| print(json.dumps({"score": score}), flush=True) |
|
|
