Enterprise security certification with deterministic scanners, cost tracking, and compliance mapping
Enterprise-grade security certification for codebases and AI agent systems with deterministic scanners, LLM-powered analysis, and signed attestations.
We pass our own strictest certification on every commit. The Self-Certification badge above is the live result of running this product against its own codebase as a blocking CI gate — the one claim a scanner-wrapper can't fake. How it works »
Don't trust us — verify. Any agent certificate can be checked independently (
npm run verify:cert -- cert.json, orPOST /verify) with no token and no trust in Vaspera: it recomputes the content digest and checks the signature from the certificate itself. Verifying a certificate »
Covers the 11-item pre-launch security checklist every AI-built app needs — statically in the free tier, with behavioral runtime proof on Pro. See docs/pre-launch-checklist.md.
pre_launch_checklist — renders all 11 items (RLS, OWASP, headers, rate limits, CAPTCHA/CORS,
client-exposed secrets, data leaks, error disclosure, …) as PASS / FAIL / NEEDS-RUNTIME for any repo.certification_scan
(no auto_detect needed) catches the classes that actually breach AI-built apps: RLS-disabled
Supabase/Postgres tables, client-exposed NEXT_PUBLIC_* secrets, cross-tenant IDOR / RLS-bypass,
missing auth on endpoints, CSRF / CORS / security-headers / missing rate-limits, missing
webhook-signature verification, plus injection, scalability/DB antipatterns, container/IaC lint, and
monorepo dependency SCA. See the full Coverage Matrix (class × tier × static/proof).forceDisable).runtime_verify exercises your running app to prove the behavioral items:
a two-account cross-tenant isolation probe ("A can't read B") and auth failure-path testing
(lockout, reset-enumeration, idempotency). A failed proof emits a critical finding that BLOCKS the cert.feedback_report_miss → rules_propose_from_miss → rules_promote
turns a missed vulnerability into a regression fixture + a human-approved detection rule.Tiering: Free = all 11 covered statically ($0). Pro = LLM adversarial reasoning + runtime proof of #2 (cross-tenant) and #3 (auth failure-paths).
Note: the features above ship in PRs #73–#76 — merge those before this doc set lands.
Robust scanner testing with fast-check property-based tests:
| Function | Properties Tested |
|---|---|
extractPathParams() | All 4 framework styles (Express :id, Next.js [id], Flask <id>, Spring {id}) |
inferResourceType() | Singularization invariants (-ies → -y, -ses → -s) |
analyzeFilePath() | Test/vendor/generated file classification |
22 test fixtures across 11 vulnerability categories (up from 13):
| Category | CWE | Fixtures |
|---|---|---|
command-injection | CWE-78 | 2 |
ssrf | CWE-918 | 2 |
xxe | CWE-611 | 1 |
insecure-deserialization | CWE-502 | 2 |
rls-bypass | CWE-639 | 2 |
Policy-based governance for autonomous autofix operations:
# .vaspera/constitution.yaml
version: "1.0"
riskTolerance: "conservative" # conservative | moderate | aggressive
patterns:
- patternId: "qual-console-log"
autoApprove: true
- patternId: "sec-sql-injection"
autoApprove: false
requiredReviewer: "security-team"
directories:
neverAutofix: ["node_modules", "vendor"]
requireReview: ["src/auth/", "src/crypto/"]
safety:
dryRunDefault: true
maxFilesPerRun: 20
runTestsAfterFix: true
revertOnTestFailure: true
Constitution Features:
All 13 compliance frameworks now support audit-defensible report generation:
| Feature | Description |
|---|---|
| Evidence Bundle | Cryptographically signed artifacts with Sigstore |
| Audit Trail Verification | Hash-chained integrity verification |
| Attestation Section | Framework-specific methodology and scope limitations |
Supported Frameworks:
New Tool Parameters:
{
"collect_evidence": true,
"verify_audit_trail": true,
"store_evidence": true,
"include_attestation": true
}
Unified HIPAA + 42 CFR Part 2 assessment for healthcare organizations:
New compliance framework for Substance Use Disorder (SUD) patient record confidentiality:
New tool for submitting findings from subagent JSON output:
agent_batch_submit - Submit all findings in one call when agents run as subagents| Limit | Free | Pro | Enterprise |
|---|---|---|---|
| Certifications/month | 3 | 50 | Unlimited |
| Projects | 2 | 20 | Unlimited |
| Agents | 3 | 7 | All |
| Frameworks | SOC2 | SOC2, HIPAA, NIST | All |
Three new deep-analysis scanners for low-level security vulnerabilities:
| Scanner | Focus | Detection |
|---|---|---|
| binary-analysis | Native modules, FFI | Missing RELRO/NX/PIE/CANARY, dangerous imports |
| memory-safety | C/C++/Rust memory bugs | Buffer overflow, use-after-free, double-free |
| race-condition | Concurrency bugs | TOCTOU, data races, lock issues |
Binary Analysis detects:
Memory Safety detects:
strcpy, sprintf, gets, strcatunsafe blocks with transmuteRace Conditions detects:
Three new AI-powered agents for deep code analysis:
| Agent | Focus | Capability |
|---|---|---|
| zero-day-hunter | Novel vulnerabilities | Logic flaws, auth bypasses, crypto weaknesses |
| logic-flaw-detector | Business logic bugs | State inconsistencies, trust boundary issues |
| exploit-chain | Attack paths | Chains multiple findings into attack scenarios |
Exploit Chain Analyzer automatically:
certification_scan_binary # Scan native modules and binaries
certification_semantic_analysis # AI-powered code analysis
certification_analyze_chains # Analyze finding chains
First-mover capability for certifying AI agent systems and MCP servers:
Five new AI-specific compliance frameworks:
| Framework | Controls | Use Case |
|---|---|---|
| OWASP LLM Top 10 | 10 | AI application security |
| NIST AI RMF | 33 | Federal AI governance |
| MITRE ATLAS | 34 | AI threat modeling |
| EU AI Act | 33 | European AI regulation |
| ISO/IEC 42001 | 38 | AI management systems |
Tamper-evident audit trails for AI agent sessions:
Production-ready integrations for large deployments:
Automatically detect project languages and enable appropriate scanners:
auto_detect: true to certification_scanComplete Ruby security scanning with Brakeman:
Full GDPR compliance mapping with 30+ controls:
Track and control LLM API costs across certifications:
Aggregate findings from multiple runs for higher confidence:
Note: These tools aggregate results from external runs. They do not call LLM APIs directly.
Map findings to enterprise compliance frameworks:
Software Bill of Materials and supply chain security:
Signing requires OIDC identity (GitHub Actions, GitLab CI, or SIGSTORE_ID_TOKEN).
Ground every finding in verifiable evidence with industry-standard scanners:
Multi-agent validation with cross-verification:
CI/CD integration with PR comments and Sigstore signing:
id-token: write)See .github/workflows/certify.yml for example.
Measure scanner accuracy with labeled test fixtures:
# npm
npm install vaspera
# pnpm (use -w flag for workspace root)
pnpm install -w vaspera
# yarn
yarn add vaspera
# From source
git clone https://github.com/RCOLKITT/hardening-mcp.git
cd hardening-mcp
npm install && npm run build
Edit ~/Library/Application Support/Claude/claude_desktop_config.json:
{
"mcpServers": {
"vaspera-hardening": {
"command": "node",
"args": ["/path/to/vaspera-hardening-mcp/dist/index.js"],
"env": {
"VASPERA_PROJECTS_DIR": "/path/to/your/projects"
}
}
}
}
| Tool | Description |
|---|---|
hardening_list_projects | Discover all projects in workspace |
hardening_install | Install hardening commands into a project |
hardening_install_all | Install commands into all projects |
hardening_get_command | Get a specific command prompt |
hardening_read_audit | Read AUDIT.md from a project |
hardening_read_report | Read HARDENING-REPORT.md |
hardening_dashboard | Portfolio-wide readiness dashboard |
hardening_list_commands | List available commands |
| Tool | Description |
|---|---|
certification_start | Initialize enterprise certification |
certification_scan | Run deterministic scanners (supports auto_detect) |
certification_detect_languages | Auto-detect project languages for scanner selection |
certification_scanners_available | Check scanner availability |
certification_install_scanners | Get install commands for missing scanners |
certification_status | Get certification progress |
certification_consensus | Calculate consensus score |
certification_finalize | Generate certification artifacts |
certification_dashboard | Portfolio certification view |
| Tool | Description |
|---|---|
certification_scan_binary | Scan compiled code and native modules |
certification_semantic_analysis | AI-powered semantic code analysis |
certification_analyze_chains | Analyze findings for exploitable attack chains |
| Tool | Description |
|---|---|
agent_submit_finding | Submit a finding from an agent |
agent_complete | Mark agent run as complete |
agent_cross_verify | Cross-verify another agent's finding |
redteam_challenge | Challenge an area marked clean |
| Tool | Description |
|---|---|
certification_cross_verify | Batch cross-verify critical findings |
certification_summary | Progressive disclosure summary |
certification_filter | Filter findings by criteria |
certification_export_sarif | Export to SARIF format |
autofix_preview | Preview auto-fix for a finding |
autofix_apply | Apply auto-fix |
autofix_batch | Batch apply all safe fixes |
autofix_list_patterns | List available fix patterns |
| Tool | Description |
|---|---|
rules_load | Load custom rules from config |
rules_templates | List built-in rule templates |
rules_generate_config | Generate sample rules config |
rules_check_file | Check file against custom rules |
| Tool | Description |
|---|---|
certification_eval | Run evaluation against test fixtures |
certification_eval_fixtures | Get fixture statistics |
| Tool | Description |
|---|---|
cost_track | Start tracking costs for a certification |
cost_estimate | Estimate cost before running |
cost_status | Get current cost status |
cost_report | Generate cost report |
cost_budget | Set/update budget limits |
cost_models | List supported models and pricing |
These tools aggregate findings from external runs - they do NOT call LLM APIs.
| Tool | Description |
|---|---|
consensus_record | Record findings from an external agent run |
consensus_calculate | Calculate consensus with Fleiss' kappa |
consensus_disagreements | Get disagreements between runs |
consensus_merged | Get deduplicated findings after consensus |
consensus_summary | Generate consensus summary |
consensus_models | List model configurations |
consensus_clear | Clear recorded results |
| Tool | Description |
|---|---|
compliance_report | Generate compliance report for a framework (audit-defensible) |
compliance_multi_report | Generate report for multiple frameworks (audit-defensible) |
compliance_controls | List controls for a framework |
healthcare_compliance | Unified HIPAA + 42 CFR Part 2 assessment (v2.9.0) |
| Tool | Description |
|---|---|
sbom_generate | Generate CycloneDX SBOM |
sbom_provenance | Generate SLSA provenance attestation |
sbom_sign | Sign content with Sigstore (requires OIDC) |
sbom_verify_provenance | Verify provenance attestation |
| Tool | Description |
|---|---|
agent_cert_scan | Full agent-system certification against MCP server |
agent_cert_fuzz | Quick prompt injection fuzzing (CI-friendly, <60s) |
agent_cert_attest | Generate Sigstore-signed attestation bundle |
agent_cert_verify | Verify attestation against live MCP server |
agent_cert_watch | Continuous monitoring with drift detection |
agent_scanners_available | Check agent scanner availability |
Agent Scanners:
manifest-audit - Parse MCP manifest, flag security issuestool-description-drift - Detect silent tool definition changesprompt-injection-fuzzer - Fuzz inputs with 200+ payloadsexfil-path-graph - Build secret→network data flow graphpermission-minimiser - Recommend tightened permissions from tracessupply-chain-mcp - SBOM + CVE scan for MCP dependenciessandbox-audit - Verify tools stay within declared boundariescredential-scope-audit - Flag over-scoped tokens| Tool | Description |
|---|---|
compliance_report | Generate report (now supports AI frameworks) |
Supported AI Frameworks:
OWASP-LLM - OWASP LLM Top 10 (10 controls)NIST-AI-RMF - NIST AI Risk Management Framework (33 controls)MITRE-ATLAS - ATLAS adversarial ML techniques (34 techniques)EU-AI-ACT - European AI Act compliance (33 controls)ISO-42001 - ISO/IEC 42001 AI management (38 controls)Programmatic API - not exposed as MCP tools:
import {
TranscriptLogger,
signTranscript,
verifyTranscriptBundle,
redactPII
} from "vaspera-hardening-mcp-server/transcripts";
// Create logger with Merkle chain
const logger = new TranscriptLogger("session-123");
logger.logPrompt("User prompt here");
logger.logToolCall("tool_name", "input data");
logger.logToolResult("tool_name", "output data");
// Generate signed transcript
const transcript = logger.generateSignedTranscript();
const bundle = await signTranscript(transcript, logger.getChain());
// Verify integrity
const result = await verifyTranscriptBundle(bundle, logger.getChain());
console.log(result.valid); // true
// Redact PII before logging
const { redacted, redactions } = redactPII("Contact: john@example.com");
// redacted = "Contact: [REDACTED:EMAIL]"
Programmatic API - not exposed as MCP tools:
import {
createOIDCClient,
createTicketingClient,
createChatClient,
createOPAClient,
createKMSClient
} from "vaspera-hardening-mcp-server/enterprise";
// OIDC SSO
const oidc = createOIDCClient({
provider: "okta",
clientId: "...",
clientSecret: "...",
issuerUrl: "https://company.okta.com",
redirectUri: "https://app.example.com/callback",
});
const { url } = await oidc.getAuthorizationUrl();
// Ticketing
const jira = createTicketingClient({
platform: "jira",
baseUrl: "https://company.atlassian.net",
apiToken: "...",
email: "...",
isCloud: true,
});
const ticket = await jira.createTicket({
title: "[CRITICAL] SQL Injection in auth.ts",
description: "...",
findings: certificationFindings,
});
// Chat notifications
const slack = createChatClient({
platform: "slack",
webhookUrl: "https://hooks.slack.com/...",
});
await slack.sendNotification({
certificationId: "cert-123",
target: "myapp",
status: "completed",
score: 87,
findings: { total: 12, critical: 0, high: 2, medium: 5, low: 5, info: 0 },
});
// OPA Policy
const opa = createOPAClient({
mode: "local",
bundlePath: "./policies/certification.json",
});
const policyResult = await opa.evaluate({ certification: {...} });
// KMS Signing (air-gapped alternative to Sigstore)
const kms = createKMSClient({
provider: "vault",
keyId: "signing-key",
vault: { address: "https://vault.example.com", token: "..." },
});
const signed = await kms.sign(certificationJson);
You: "Scan this project for security issues"
→ Claude calls certification_scan
→ Returns findings from Semgrep, gitleaks, npm audit, TypeScript
You: "Start enterprise certification for this project"
→ Claude calls certification_start
→ Claude calls certification_scan (deterministic pre-pass)
→ Claude runs each agent (security, reliability, typesafety, etc.)
→ Claude calls certification_cross_verify (batch verify critical findings)
→ Claude calls certification_consensus
→ Claude calls certification_finalize
→ Generates CERTIFICATION.md and CERTIFICATION.json
You: "Run the evaluation harness to test scanner accuracy"
→ Claude calls certification_eval
→ Returns precision, recall, F1 scores against labeled fixtures
You: "Run certification with a $5 budget limit"
→ Claude calls cost_track with budget: 5.00
→ Claude runs agents, tracking costs in real-time
→ If budget exceeded, certification pauses
→ Claude calls cost_report for final breakdown
You: "Calculate consensus from my security agent runs"
→ User runs security agent via different MCP clients or APIs
→ User calls consensus_record for each run's findings
→ Claude calls consensus_calculate for agreement metrics
→ Claude calls consensus_disagreements for disputed findings
Note: Consensus tools aggregate external results. Run agents separately.
You: "Generate SOC 2 compliance report from certification"
→ Claude calls compliance_report with framework: "SOC2"
→ Returns control-by-control status with findings mapped
→ Identifies at-risk controls and gaps
You: "Generate an SBOM for this project"
→ Claude calls sbom_generate
→ Returns CycloneDX SBOM with all dependencies
→ Claude calls sbom_provenance for build attestation
You: "What scanners are missing and how do I install them?"
→ Claude calls certification_install_scanners
→ Returns platform-specific install commands for each scanner
→ Claude calls with run_install: true to execute installation
You: "Apply all safe fixes to the certification findings"
→ Claude calls autofix_batch with dry_run: true (preview)
→ Shows what would be changed
→ Claude calls autofix_batch with dry_run: false (apply)
→ Reports fixes applied by pattern and file
You: "Scan this project with auto-detection"
→ Claude calls certification_scan with auto_detect: true
→ Detects Python, JavaScript, Go files
→ Automatically enables Bandit, npm-audit, Gosec
→ Returns unified findings from all relevant scanners
You: "Generate GDPR compliance report"
→ Claude calls compliance_report with framework: "GDPR"
→ Maps findings to GDPR articles (Art. 5, 25, 32, etc.)
→ Returns control status with gap analysis
You: "Generate audit-defensible SOC 2 report"
→ Claude calls compliance_report with:
- framework: "SOC2"
- collect_evidence: true
- verify_audit_trail: true
- include_attestation: true
→ Collects cryptographically signed evidence bundle
→ Verifies hash-chain integrity of audit trail
→ Generates report with attestation methodology
→ Returns audit-ready documentation
You: "Run healthcare compliance assessment"
→ Claude calls healthcare_compliance
→ Assesses both HIPAA and 42 CFR Part 2 frameworks
→ Generates unified report with cross-references
→ Collects evidence bundle for audit defensibility
You: "Sign the SBOM with Sigstore"
→ Claude calls sbom_sign with the SBOM content
→ Gets OIDC token from GitHub Actions / GitLab CI
→ Obtains certificate from Fulcio
→ Records signature in Rekor transparency log
→ Returns signed bundle with log index
Requires CI environment with OIDC (GitHub Actions: permissions: id-token: write)
You: "Certify this MCP server for prompt injection vulnerabilities"
→ Claude calls agent_cert_scan with target and scanners
→ Runs manifest-audit, prompt-injection-fuzzer, exfil-path-graph
→ Returns findings with severity and remediation
→ Claude calls agent_cert_attest to generate signed bundle
You: "Quick fuzz test on this MCP server - CI mode"
→ Claude calls agent_cert_fuzz with corpus: "quick"
→ Runs 50 high-priority payloads in <60 seconds
→ Returns pass/fail for each tool with behavior change detection
You: "Generate OWASP LLM Top 10 compliance report"
→ Claude calls compliance_report with framework: "OWASP-LLM"
→ Maps findings to LLM01-LLM10 controls
→ Returns control status with gap analysis
→ Identifies prompt injection, sensitive disclosure, excessive agency risks
You: "Scan native modules for security issues"
→ Claude calls certification_scan_binary
→ Detects binding.gyp, *.node, Rust FFI, Go CGO
→ Checks RELRO, NX, PIE, CANARY protections
→ Reports missing stack protections and dangerous imports
You: "Analyze findings for attack chains"
→ Claude calls certification_analyze_chains
→ Chains SSRF → internal API access
→ Chains XSS → session hijacking
→ Calculates escalated severity (medium + medium = critical)
→ Maps to MITRE ATT&CK techniques
// Programmatic - create Jira tickets for critical/high findings
const jira = createTicketingClient({ platform: "jira", ... });
const result = await jira.createTicketsForFindings(findings, {
project: "SEC",
groupByCategory: true,
minSeverity: "high",
});
console.log(`Created ${result.created.length} tickets`);
┌─────────────────────────────────────────────────────────────────────────────────────────┐
│ Codebase Scanner Layer │
├─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬─────────┬────────┤
│ Semgrep │npm audit│gitleaks │ tsc │ ESLint │ Bandit │ Gosec │Brakeman │ Trivy │
│ (OWASP) │ (CVEs) │(secrets)│ (types) │ (lint) │ (Python)│ (Go) │ (Ruby) │ (IaC) │
└────┬────┴────┬────┴────┬────┴────┬────┴────┬────┴────┬────┴────┬────┴────┬────┴───┬────┘
│ │ │ │ │ │ │ │ │
└─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴─────────┴────────┘
│
┌─────────────────────────────────────────────┼─────────────────────────────────────────┐
│ Mythos-Class Scanner Layer (v2.5.0) │
├─────────────────────┬─────────────────────┬─┴───────────────────┬─────────────────────┤
│ Binary Analysis │ Memory Safety │ Race Condition │ Exploit Chain │
│ (native modules) │ (C/C++/Rust bugs) │ (concurrency) │ (attack paths) │
└──────────┬──────────┴──────────┬──────────┴──────────┬──────────┴──────────┬──────────┘
│ │ │ │
└─────────────────────┴─────────────────────┴─────────────────────┘
│
┌─────────────────────────────────────────────┼─────────────────────────────────────────┐
│ Agent Scanner Layer (v2.3.0) │
├──────────────┬──────────────┬──────────────┬┴─────────────┬──────────────┬────────────┤
│ Manifest │ Tool Drift │ Prompt │ Exfil Path │ Permission │ Credential │
│ Audit │ Detection │ Injection │ Graph │ Minimizer │ Scope │
│ │ │ Fuzzer │ │ │ Audit │
└──────┬───────┴──────┬───────┴──────┬───────┴──────┬───────┴──────┬───────┴─────┬──────┘
│ │ │ │ │ │
└──────────────┴──────────────┴──────────────┴──────────────┴─────────────┘
│
┌─────────▼─────────┐
│ Finding Aggregator │
│ (confidence: 100) │
└─────────┬─────────┘
│
┌───────────────────┴───────────────────┐
▼ ▼
┌─────────────────┐ ┌─────────────────┐
│ Compliance │ │ LLM Agents │
│ Mapper │◄────────────────────│ (triage/enrich) │
│ (10 frameworks) │ │ + Privacy Agent │
└────────┬────────┘ │ + Integrity │
│ └─────────────────┘
▼
┌─────────────────┐
│ Transcript │
│ Logger │──► Merkle Chain ──► Sigstore Signing
│ + PII Redaction │
└────────┬────────┘
│
▼
┌─────────────────┐
│ Enterprise │──► OIDC SSO, OPA Policy, Ticketing, Chat
│ Integrations │
└─────────────────┘
Non-deterministic findings are validated to prevent hallucinations:
Target metrics for scanner accuracy:
| Metric | Target | Description |
|---|---|---|
| Precision | >90% | Low false positives |
| Recall | >85% | Catches real issues |
| Stability | >95% | Consistent across runs |
| Agreement | >85% | Cross-agent confirmation |
- uses: RCOLKITT/vaspera-hardening-action@v1
with:
mode: 'diff' # scan | certify | diff
fail-on: 'critical' # critical | high | medium | none
upload-sarif: true
comment-on-pr: true
anthropic-api-key: ${{ secrets.ANTHROPIC_API_KEY }} # Optional for LLM features
| Variable | Default | Description |
|---|---|---|
VASPERA_PROJECTS_DIR | ~/Documents/GitHub | Base directory to scan |
ANTHROPIC_API_KEY | - | API key for LLM features (optional) |
SIGSTORE_ID_TOKEN | - | OIDC token for Sigstore signing |
ACTIONS_ID_TOKEN_REQUEST_TOKEN | - | GitHub Actions OIDC (auto-set) |
VASPERA_OPA_BUNDLE | - | Path to OPA policy bundle |
VASPERA_OPA_SERVER | - | OPA server URL for remote evaluation |
VASPERA_TRANSCRIPT_DIR | .vaspera/transcripts | Transcript storage directory |
| Variable | Description |
|---|---|
VASPERA_OIDC_ISSUER | OIDC issuer URL (Okta, Auth0, Azure AD) |
VASPERA_OIDC_CLIENT_ID | OIDC client ID |
VASPERA_OIDC_CLIENT_SECRET | OIDC client secret |
VASPERA_JIRA_URL | Jira instance URL |
VASPERA_JIRA_TOKEN | Jira API token |
VASPERA_SLACK_WEBHOOK | Slack webhook URL |
VASPERA_TEAMS_WEBHOOK | Microsoft Teams webhook URL |
VASPERA_AWS_KMS_KEY | AWS KMS key ARN for signing |
VASPERA_VAULT_ADDR | HashiCorp Vault address |
VASPERA_VAULT_TOKEN | HashiCorp Vault token |
MIT
FAQs
Enterprise security certification with deterministic scanners, cost tracking, and compliance mapping
The npm package vaspera receives a total of 172 weekly downloads. As such, vaspera popularity was classified as not popular.
We found that vaspera demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Company News
Socket is joining the OpenJS Security Stewardship Program to fund Node.js vulnerability research, maintainer remediation, and security releases.
Security News
Two compromised GitHub Actions were re-enabled with malicious tags intact, exposing thousands of downstream repositories to Mini Shai-Hulud.
Research
/Security News
A malicious Firefox extension fetches its payload after installation to evade detection, steal Google session cookies, and automate account takeover.