SecureAI-Scan

ऑफ़लाइन CLI जो TypeScript, JavaScript और Python को LLM, MCP, Agent Skill और RAG जोखिमों के लिए स्कैन करता है — import-रिज़ॉल्व्ड डेटाफ़्लो साक्ष्य, शून्य डिफ़ॉल्ट गलत-सकारात्मक, OWASP LLM/ASI/MCP Top 10 से मैप किया गया।

इस क्षेत्र के अधिकांश स्कैनर किसी कीवर्ड का पैटर्न-मिलान करते हैं और उसे निष्कर्ष कह देते हैं। SecureAI-Scan वास्तविक, import-रिज़ॉल्व्ड कोड के माध्यम से वास्तविक स्रोत → प्रवाह → सिंक पथ का पता लगाता है — और एक डिफ़ॉल्ट स्कैन आपको केवल वही दिखाता है जो वह सिद्ध कर सकता है। कोई खाता नहीं, कोई क्लाउड अपलोड नहीं, कुछ भी आपकी मशीन से बाहर नहीं जाता।

लॉन्च सप्ताह से आधिकारिक OWASP Top 10 for LLM Applications 2026, Top 10 for Agentic Applications (2026), और MCP Top 10 को कवर करता है।

30 सेकंड में शुरू करें```bash

npx --yes [email protected] scan .

कोई खाता, क्लाउड अपलोड, Python इंटरप्रेटर, या कॉन्फ़िगरेशन आवश्यक नहीं है। TypeScript, JavaScript, Python, MCP कॉन्फ़िग, और Agent Skill बंडल स्वचालित रूप से पहचाने जाते हैं।

**मापा गया `0.9.0` रिलीज़ कैंडिडेट:** 136/136 टेस्ट · 88.08% स्टेटमेंट कवरेज · 9 सार्वजनिक रिपॉज़िटरीज़ में 12,676 फ़ाइलें · समीक्षित बेसलाइन के विरुद्ध 0 नए डिफ़ॉल्ट-टियर फ़िंगरप्रिंट। [साक्ष्य](https://github.com/akanthed/secureai-scan/blob/main/docs/benchmarks/v0.9.0.json) · [पद्धति और सीमाएँ](https://github.com/akanthed/secureai-scan/blob/main/docs/ReleaseAssurance.md)```
  ▌ HIGH  AI001  Prompt injection via user input
    PROVEN  LLM01:2026 Prompt Injection

    source src/chat.ts:8   request data `req.body.input`
    flow   src/chat.ts:13  passed as `systemPrompt`
    sink   src/chat.ts:10  openai.chat.completions.create — system role (OpenAI)

    fix    Keep system prompts static; pass user input as a user-role message.

क्या यह आपके लिए है? SecureAI-Scan जानबूझकर LLM, MCP, और RAG/agent जोखिमों तक सीमित है — prompt injection, tool poisoning, unsafe output handling, vector-store access control, agent-skill poisoning। यह एक सामान्य SAST या secrets scanner नहीं है, और बनने की कोशिश भी नहीं करता; एक ज्ञात-दुर्भावनापूर्ण पैकेज जिसमें कोई LLM-आकार का payload नहीं है (जैसे कि email API कॉल में हार्डकोडेड exfiltration address) offline advisory list (DEP003) द्वारा पकड़ा जाता है, pattern rule से नहीं। यदि आपका codebase किसी LLM, MCP server, vector store से बात करता है, या Agent Skills भेजता है, तो यह आपके लिए बनाया गया है।

_{नया: LiteLLM Proxy (config.yaml) के लिए static config scanning — hardcoded secrets, plaintext provider endpoints, missing guardrails। देखें Rules (LLC001–LLC003)।}

सामग्री

• यह scanner अलग क्यों है
• यह कैसे तुलना करता है
• 30 सेकंड में शुरू करें
• इसे काम करते देखें
• Commands
• GitHub Action
• Pre-commit hook
• Rules
• Architecture
• MCP server (इसे Claude से उपयोग करें)
• Claude Skill
• Trust और release assurance
• The precision contract
• Testing & benchmarking
• Roadmap
• Contributing

यह scanner अलग क्यों है

• Evidence tiers, noise नहीं। हर finding proven (traced dataflow या parsed config fact), likely (resolved sink, एक heuristic hop), या heuristic है। एक default scan केवल proven + likely दिखाता है। Heuristics --paranoid के माध्यम से opt-in हैं।
• Import-resolved detection। एक कॉल केवल "LLM call" है यदि यह एक वास्तविक SDK import (openai, @anthropic-ai/sdk, ai, @google/genai, LangChain, Bedrock, …) तक resolve होता है। आपका Google Maps client फिर कभी LLM के रूप में flagged नहीं होगा।
• Precision-gated, और वास्तविक repos के खिलाफ benchmarked। Test suite यह सुनिश्चित करता है कि हर vulnerable fixture fire होता है और हर safe fixture clean रहता है — safe corpus पर एक false positive build को fail कर देता है। इसके अलावा, npm run regression वास्तविक public repos (OpenAI/Anthropic/Vercel AI SDKs, official MCP servers, LlamaIndex) को एक committed, hand-reviewed baseline के खिलाफ scan करता है और किसी भी नए proven/likely finding पर fail होता है। वास्तविक before/after numbers के लिए देखें Testing & benchmarking, या उनके पीछे की कहानी के लिए What we found scanning real repos — एक labeled malicious-skill corpus पर 6/6 catch rate, और हम llama_index को एक ईमानदार library-level finding पर "vulnerable" क्यों नहीं कह रहे हैं। Discussion write-up →
• GitHub code scanning के लिए SARIF। --output report.sarif findings को pull requests पर और Security tab में inline रखता है।
• AI-BOM। secureai-scan bom . SDKs, model IDs, vector stores, agent frameworks, और MCP servers की एक syntax-derived inventory बनाता है, जो OWASP LLM Top 10 / EU AI Act documentation आवश्यकताओं से mapped है।
• MCP config scanning। .mcp.json, claude_desktop_config.json, .cursor/mcp.json parse करता है: unpinned npx -y servers, inline secrets, plaintext HTTP transports।
• MCP tool-poisoning detection। WhatsApp MCP rug-pull और postmark-mcp backdoor के पीछे के pattern को पकड़ता है — invisible Unicode, agent-directed injection phrases, और tool names/descriptions में cross-tool shadowing, statically, server चलाने से पहले।
• MCP command-injection detection। MCP stdio transport command/args को request data से बनाए जाने पर flag करता है — 2026 MCP STDIO RCE disclosure के पीछे का pattern।
• Agent Skill poisoning detection। वही invisible-Unicode, injection-phrase, और shadowing checks SKILL.md files पर लागू होते हैं — Agent Skills context में पूरी तरह load होते हैं, इसलिए एक poisoned skill दूसरे नाम से एक poisoned tool description है।
• Evasion-resistant skill scanning। Skill bundles को directories के रूप में scan किया जाता है, न कि केवल उनके SKILL.md, और हर content check text के deobfuscated variants के खिलाफ चलता है। यह प्रकाशित techniques को लक्षित करता है — homoglyphs, zero-width splitting, .git/ या build/ में staged payloads, *.test.ts file में छिपा exfiltration — जिन्होंने Cloak and Detonate (arXiv:2607.02357) में surveyed नौ scanners के >90% को bypass किया। देखें Evasion resistance।
• Known-vulnerable और known-malicious package advisories, version-aware। हर dependency और हर MCP-launched package को एक bundled advisory snapshot के खिलाफ check करता है — documented in-the-wild backdoors की एक hand-curated list, साथ ही LLM/MCP/RAG package watchlist के लिए HIGH/CRITICAL OSV advisories, जो scripts/sync-advisories.js द्वारा regenerated होती हैं। हर scan पर offline चलता है, कोई flag आवश्यक नहीं। एक CVE केवल तब fire होता है जब आपका pinned version प्रभावित range के अंदर provably हो; एक documented-malicious package ambiguous range पर भी fire होता है, क्योंकि backdoor install करना unrecoverable है।
• Local-first। कुछ भी आपकी machine से बाहर नहीं जाता।

यह कैसे तुलना करता है

SecureAI-Scan एक सामान्य SAST tool या container/IaC scanner का replacement नहीं है — इसे उसके साथ चलाएं, उसके बजाय नहीं। यह LLM/MCP/RAG attack surface के लिए purpose-built है और flat keyword findings पर dataflow evidence पर जोर देता है।

यदि आप पहले से Semgrep या GHAS चलाते हैं, तो उन्हें रखें — उस risk surface के लिए SecureAI-Scan जोड़ें जिसे वे बिल्कुल model नहीं करते।

पहले प्रश्न पूछना पसंद है? मुफ्त SecureAI-Scan AI Security Advisor on ChatGPT आज़माएं।

GitHub या Twitter पर मिला MCP server चलाने वाले हैं? पहले उसकी tool description MCP X-Ray में paste करें — यह आपके browser में hidden Unicode, injected instructions, और known-malicious packages के लिए check करता है, बिना install के।

इसे काम करते देखें

secureai-scan scan . end to end, एक वास्तविक (छोटी, जानबूझकर vulnerable) file के खिलाफ वास्तविक output — source:

Scanner end to end जिन attack shapes को trace करता है:

MCP tool-poisoning dataflow	RAG context-injection dataflow

Commands

वह जो आपको 95% समय चाहिए:```bash secureai-scan scan .

बाकी सब कुछ वहाँ है जब आपको ज़रूरत हो। `secureai-scan scan . --help` यह सब टर्मिनल में दिखाता है, उसी समूह में:

**रोज़मर्रा**

| फ़्लैग | यह क्या करता है |
|------|---------------|
| *(कोई नहीं)* | `proven` + `likely` निष्कर्ष — डिफ़ॉल्ट, किसी फ़्लैग की ज़रूरत नहीं |
| `--paranoid` | `heuristic`-स्तर के निष्कर्ष भी शामिल करें |
| `-s, --severity <level>` | केवल `low`\|`medium`\|`high`\|`critical` पर/से ऊपर के निष्कर्ष दिखाएँ |
| `--output <file>` | पूरी रिपोर्ट लिखें — `.sarif` (GitHub code scanning), `.json`, `.md`, या `.html` |

**कौन से नियम चलते हैं, उसका दायरा**

| फ़्लैग | यह क्या करता है |
|------|---------------|
| `-r, --rules <list>` | केवल ये नियम ID चलाएँ, जैसे `AI001,MCP007` |
| `--only-ai` / `--only-mcp` / `--only-vec` / `--only-skl` | केवल एक नियम श्रेणी चलाएँ |
| `--check-dependencies` | npm/PyPI रजिस्ट्री के विरुद्ध `package.json`/`requirements.txt` की टाइपो और काल्पनिक पैकेजों के लिए जाँच भी करें (`DEP001`/`DEP002`)। यदि आप उन नियमों को सीधे `-r` के माध्यम से चुनते हैं तो यह स्वतः सक्षम हो जाता है — आपको दोनों पास करना कभी याद नहीं रखना पड़ता। `DEP003` (ज्ञात-दुर्भावनापूर्ण पैकेज) के लिए आवश्यक नहीं, जो हमेशा ऑफ़लाइन चलता है |

**CI / वर्कफ़्लो**

| फ़्लैग | यह क्या करता है |
|------|---------------|
| `--fail-on <severity>` | यदि इस गंभीरता पर/से ऊपर के निष्कर्ष मौजूद हों तो `1` से बाहर निकलें |
| `--baseline <file>` | सहेजे गए बेसलाइन के विरुद्ध केवल नए/बदले हुए मुद्दों को ट्रैक करें |
| `--policy <file>` | `.secureai-policy.json` से थ्रेशोल्ड, छोड़े गए पथ, और अवरुद्ध नियम लोड करें (यदि मौजूद हो तो स्वतः पहचाना जाता है — `secureai-scan init` एक बनाता है) |

**उन्नत**

| फ़्लैग | यह क्या करता है |
|------|---------------|
| `--min-confidence <0-1>` | `--paranoid` से अधिक सूक्ष्म: सटीक कॉन्फिडेंस स्कोर से नीचे के निष्कर्ष छिपाएँ (`0.9` proven / `0.65` likely / `0.35` heuristic) |
| `--limit <n>` | टर्मिनल में दिखाए गए अधिकतम नियम समूह (डिफ़ॉल्ट `10`) — पूरा विवरण हमेशा `--output` में जाता है |
| `--debug` | स्कैन की गई हर फ़ाइल और कौन से नियम चले, प्रिंट करें |

**इंस्टॉल करने से पहले स्कैन करें — कोई क्लोन नहीं, कोई कॉन्फ़िग नहीं:**```bash
secureai-scan skill anthropics/skills          # a GitHub "owner/repo" shorthand
secureai-scan skill https://github.com/…       # or a full git URL
secureai-scan skill ./some/local/skill-dir     # or a local path
secureai-scan mcp some-mcp-server-package      # a bare npm package name
secureai-scan mcp owner/mcp-server-repo        # or git, same as `skill`

skill और mcp लक्ष्य को प्राप्त करते हैं और उसका स्कैन करते हैं, फिर प्राप्त की गई प्रति को हटा देते हैं (--keep इसे जाँचने के लिए रखता है)। प्राप्त की गई कोई भी चीज़ कभी निष्पादित नहीं होती: एक npm लक्ष्य npm pack के साथ डाउनलोड किया जाता है — केवल tarball, कोई install नहीं, कोई lifecycle scripts नहीं — और एक git लक्ष्य एक साधारण git clone --depth 1 होता है। यही वह क्षण है जो सबसे अधिक मायने रखता है: किसी skill के ~/.claude/skills/ में आने या किसी server के .mcp.json में आने से पहले, बाद में नहीं।

अन्य कमांड:```bash secureai-scan bom . --output AI_BOM.md # AI Bill of Materials secureai-scan explain AI001 # why + exploit + fix example, for any rule secureai-scan threat-model . # THREAT_MODEL.md with the OWASP coverage matrix — example: docs/examples/THREAT_MODEL.example.md secureai-scan init # policy file + CI workflow, one-time setup

समीक्षित फाइंडिंग को कोड में दबाएँ:```ts
// secureai-ignore AI001: reviewed, input sanitized via allowlist

GitHub Action```yaml

name: SecureAI-Scan on: [pull_request] permissions: contents: read security-events: write jobs: scan: runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - uses: akanthed/[email protected] with: scanner-version: 0.10.0 fail-on: high

निष्कर्ष PR पर इनलाइन एनोटेशन और रिपॉजिटरी के Security टैब में दिखाई देते हैं। (`secureai-scan init` CLI का उपयोग करके सीधे एक समकक्ष वर्कफ़्लो उत्पन्न करता है।)

स्कैन साफ़ है? अपने स्वयं के README में बैज जोड़ें:```md
[![secureai-scan](https://img.shields.io/badge/secureai--scan-passing-brightgreen)](https://github.com/akanthed/SecureAI-Scan)

प्री-कमिट हुक

क्या आप फाइंडिंग्स को पुश करने से पहले ही पकड़ना पसंद करते हैं? GitHub Action के बजाय, या उसके साथ, इस रिपो को pre-commit हुक स्रोत के रूप में जोड़ें:```yaml repos:

• repo: https://github.com/akanthed/SecureAI-Scan rev: v0.10.0 hooks:
  • id: secureai-scan

हुक हर कमिट पर पूरे प्रोजेक्ट को स्कैन करता है (सिर्फ बदली हुई फाइलें नहीं — फाइल A में डेटाफ्लो ट्रेस फाइल B पर निर्भर हो सकती है, जिसे आंशिक स्कैन मिस कर देगा) और डिफ़ॉल्ट रूप से `high`+ गंभीरता वाले निष्कर्षों पर कमिट को ब्लॉक कर देता है। अपने खुद के कॉन्फ़िग में थ्रेशोल्ड को ओवरराइड करें:```yaml
      - id: secureai-scan
        args: ["--fail-on", "critical"]

नियम

42 नियम, LLM अनुप्रयोगों के लिए आधिकारिक OWASP Top 10 (2026) से मैप किए गए — साथ ही, जहाँ लागू हो, एजेंटिक अनुप्रयोगों के लिए OWASP Top 10 (2026, ASI), OWASP MCP Top 10 (2025), और एक EU AI Act अनुच्छेद। संस्करणित 2026 कवरेज और सीमाएँ देखें; threat-model प्रत्येक स्कैन किए गए प्रोजेक्ट के लिए मैट्रिक्स प्रस्तुत करता है।

secureai-scan explain <RULE_ID> किसी भी नियम के लिए शोषण वॉकथ्रू और पहले/बाद का कोड उदाहरण देता है।

आर्किटेक्चर

तीन स्वतंत्र स्कैनिंग सतहें एक विलयित, डीडुप्लिकेटेड फ़ाइंडिंग सूची को फ़ीड करती हैं:``` ┌─────────────────────┐ *.ts / *.js ───▶ │ ts-morph AST rules │───┐ │ (import-resolved │ │ │ sinks + dataflow) │ │ └─────────────────────┘ │ │ ┌─────────────────────┐ │ ┌──────────────┐ ┌─────────────────┐ *.py ───▶ │ tree-sitter AST + │───┼───▶ │ scan.ts │───▶ │ evidence filter │ │ local taint flow │ │ │ merge/dedupe│ │ → confidence │ └─────────────────────┘ │ │ + suppress │ │ → severity │ │ │ (// secure- │ │ → baseline diff │ .mcp.json, ┌─────────────────────┐ │ │ ai-ignore) │ │ → report │ SKILL.md ───▶ │ Config/bundle scan │──┘ └──────────────┘ └─────────────────┘ │ (off-disk, evasion- │ │ │ resistant) │ ▼ └─────────────────────┘ terminal · sarif · json · md · html

package.json, requirements.txt ─▶ dependency-guard.ts (advisories.ts, offline, version-aware)

हर AST नियम किसी फ़ंक्शन को "LLM कॉल" तभी कहता है जब वह वास्तविक imports के माध्यम से किसी ज्ञात SDK तक पहुँचता है — कभी भी केवल नाम-मिलान से नहीं। प्रत्येक सतह के पूर्ण विवरण के लिए [`docs/Architecture.md`](https://github.com/akanthed/secureai-scan/blob/main/docs/Architecture.md) देखें, और evidence-tier अनुबंध कैसे काम करता है इसके लिए [`docs/DetectionEngine.md`](https://github.com/akanthed/secureai-scan/blob/main/docs/DetectionEngine.md) देखें।

## MCP सर्वर (इसे Claude से उपयोग करें)

पैकेज एक MCP सर्वर के साथ आता है जो `scan_repository`, `explain_rule`, `generate_bom`, और `scan_untrusted_target` (Claude के इसे इंस्टॉल करने की सिफारिश करने से पहले किसी skill या MCP सर्वर को fetch और scan करता है — `skill`/`mcp` CLI कमांड के समान fetch-without-executing व्यवहार) को उजागर करता है:```json
{
  "mcpServers": {
    "secureai-scan": {
      "command": "node",
      "args": ["/path/to/secureai-scan/mcp-server/index.js"]
    }
  }
}

क्लॉड स्किल

क्लॉड कोड / क्लॉड.एआई उपयोगकर्ताओं के लिए, skills/secureai-scan/SKILL.md क्लॉड को सिखाता है कि स्कैन कब चलाना है (AI/LLM कोड की समीक्षा करते समय, या किसी MCP सर्वर/एजेंट स्किल को इंस्टॉल करने से पहले जाँचते समय) और परिणाम कैसे पढ़ने हैं — ऊपर दिए गए MCP सर्वर के विपरीत, इसे चलाने के लिए कोई अलग प्रक्रिया नहीं है। इसका उपयोग करने के लिए skills/secureai-scan/ निर्देशिका को अपनी .claude/skills/ में कॉपी करें।

एवेज़न प्रतिरोध

जुलाई 2026 में, दो सार्वजनिक शोधों ने दिखाया कि एजेंट स्किल स्कैनर को आसानी से बायपास किया जा सकता है।

क्लोक एंड डेटोनेट (जी, ज़ू, ली, गाओ, वेई, वांग और चेउंग — HKUST, arXiv:2607.02357) ने 1,613 वास्तविक दुनिया के दुर्भावनापूर्ण स्किल्स का उपयोग करके नौ प्रकाशित स्किल स्कैनर के खिलाफ एक प्रतिकूल अध्ययन चलाया। दो अटैक परिवार, दोनों पेलोड को बिल्कुल वैसा ही संरक्षित करते हैं:

• रीफ़ाई — उन बाइट्स को फिर से लिखना जिनसे नियम मेल खाता है, जबकि एजेंट रनटाइम पर मूल को फिर से असेंबल करता है। अधिकांश स्टैटिक स्कैनर पर >80% बायपास।
• डिस्पर्स / SFS पैकिंग — पेलोड को नियम के दायरे से बाहर ले जाना: ऐसी निर्देशिका में जिसे स्कैनर छोड़ देता है, नाम बदले गए एक्सटेंशन के पीछे, या .git/ में संग्रहीत और एन्कोडेड, एक हानिरहित कवर SKILL.md के साथ जो पहले रन पर इसे फिर से बनाता है। परीक्षण किए गए हर स्कैनर पर ≥90% बायपास, अधिकांश पर ≥96%। एक हाइब्रिड स्कैनर की पहचान दर ~99% से घटकर ~10% हो गई।

अलग से, गेको सिक्योरिटी (VentureBeat) ने एक *.test.ts फ़ाइल में पेलोड भेजा। हर सार्वजनिक स्कैनर ने इसे छोड़ दिया — लेकिन Jest और Vitest अगले npm test पर उन फ़ाइलों को स्वतः खोज और निष्पादित करते हैं।

SecureAI-Scan प्रत्येक प्रकाशित तकनीक को संभालता है। नीचे दी गई हर पंक्ति के लिए test/deobfuscate.test.js में एक संबंधित परीक्षण या test-fixtures/vulnerable/skills/ में एक फिक्स्चर है:

यह प्रिसिज़न अनुबंध को कमज़ोर नहीं करता

डीओबफस्केशन आमतौर पर एक प्रिसिज़न जोखिम है — अधिक मैच, अधिक शोर। यहाँ तर्क उलटा है: एक मैच जो केवल डीओबफस्केशन के बाद दिखाई देता है, उसे डिमोट नहीं, बल्कि proven में प्रमोट किया जाता है। सामान्य दस्तावेज़ीकरण में "ignore previous instructions" के अंदर ज़ीरो-विड्थ जॉइनर नहीं होता, न ही curl के अंदर सिरिलिक с होता है। छिपाव स्वयं इरादे का सकारात्मक प्रमाण है।

तुलना कच्चे मैचों के सेट के खिलाफ है, न कि केवल "क्या कच्चा टेक्स्ट बिल्कुल मेल खाया" — अन्यथा एक हमलावर एक हानिरहित वाक्यांश को स्पष्ट रूप से छोड़कर सिग्नल को मास्क कर सकता था।

दो नए बंडल नियम केवल संयोजनों पर सक्रिय होते हैं, कभी किसी कीवर्ड पर नहीं:

• SKL004 को एक अपारदर्शी ब्लॉब और एक अनपैक निर्देश की आवश्यकता होती है जो उस ब्लॉब को नाम से संदर्भित करता है — एक असंबंधित बाइनरी एसेट के पास tar -x का उल्लेख करने वाला README पर्याप्त नहीं है। वास्तविक आर्काइव (gzip/zip/png/pdf/wasm — मैजिक बाइट्स द्वारा जाँचे गए, एक्सटेंशन से नहीं) कभी भी "अपारदर्शी" नहीं होते, चाहे वे कैसे भी कंप्रेस किए गए हों।
• SKL005 को एक ठोस क्रेडेंशियल सिग्नल की आवश्यकता होती है — एक पथ (~/.aws/credentials, शब्द "token" नहीं) या बल्क एनवायरनमेंट-वेरिएबल एन्यूमरेशन (os.environ.items(), os.environ["API_KEY"] नहीं) — और एक हार्डकोडेड गैर-लोकल होस्ट के लिए ईग्रेस, एक ही फ़ाइल में एक दूसरे के 25 लाइनों के भीतर, या एक रिमोट फ़ेच जो एक या अधिक रीनाम के माध्यम से पुनः असाइन किए जाने के बाद निष्पादित होता है। एक पब्लिश हेल्पर जो एक फ़ंक्शन में ~/.npmrc पढ़ता है और चालीस लाइन बाद एक रजिस्ट्री को कॉल करता है, साफ रहता है, और एक API कॉल के लिए एक नामित एनवी वेरिएबल पढ़ना कभी फ़्लैग नहीं होता — दोनों आकृतियाँ सुरक्षित फिक्स्चर के रूप में पिन की गई हैं।

केवल हमारे द्वारा लिखे गए फिक्स्चर के खिलाफ नहीं, बल्कि दो वास्तविक-दुनिया के कॉर्पोरा के खिलाफ मान्य: anthropics/skills के सभी 18 वास्तविक स्किल बंडलों में 0 निष्कर्ष और vercel/ai के सभी 14 में, और cisco-ai-defense/skill-scanner के लेबल किए गए इवैल कॉर्पस पर 6/6 सही (20 स्किल्स, प्रत्येक में _expected.json वर्डिक्ट के साथ) और सुरक्षित लेबल वाली किसी भी चीज़ पर शून्य फॉल्स पॉज़िटिव। टेस्टिंग और बेंचमार्किंग देखें।

यह क्या नहीं है

ईमानदार सीमा: पेपर का निष्कर्ष यह है कि रनटाइम डेटोनेशन स्टैटिक विश्लेषण से बेहतर है, और यह सही है। एक अनुकूली प्रतिद्वंद्वी जो इन नियमों को जानता है, वह एक ऐसा ट्रांसफॉर्मेशन लिख सकता है जिसे ये कवर नहीं करते। यहाँ जो बदलता है वह एवेज़न की लागत है — प्रकाशित, वर्तमान में प्रचलित तकनीकें अब काम नहीं करतीं, और उन्हें हराने के लिए आवश्यक ओबफस्केशन अब स्वयं निष्कर्ष की गंभीरता को बढ़ाता है। स्टैटिक स्कैनिंग एक फ़िल्टर है, सुरक्षा सीमा नहीं। किसी अविश्वसनीय स्किल को किसी भी स्कैनर के कहने की परवाह किए बिना अविश्वसनीय कोड के रूप में मानें।

विश्वास और रिलीज़ आश्वासन

• CI समर्थित Node संस्करणों में Linux, Windows और macOS पर चलता है।
• CodeQL, प्रोडक्शन डिपेंडेंसी ऑडिट, OpenSSF स्कोरकार्ड, Dependabot और इस स्कैनर का अपना ब्लॉकिंग सेल्फ-स्कैन स्वतंत्र जाँच प्रदान करते हैं।
• हर मैनुअल npm प्रकाशन prepublishOnly के माध्यम से टेस्ट, कवरेज फ्लोर, समीक्षित वास्तविक-रिपॉजिटरी रिग्रेशन गेट और टारबॉल निरीक्षण को आमंत्रित करता है।
• GitHub Actions को कोई npm पासवर्ड या टोकन नहीं मिलता और वह पैकेज प्रकाशित नहीं कर सकता।
• रिलीज़ आश्वासन, एकल-मेंटेनर शासन, सुरक्षा रिपोर्टिंग और संस्करणित बेंचमार्क साक्ष्य सार्वजनिक हैं।

यह एक एकल-मेंटेनर प्रोजेक्ट है जिसमें कोई संविदात्मक SLA या स्वतंत्र प्रमाणन नहीं है। उपरोक्त नियंत्रण जोखिम कम करते हैं; वे स्टैटिक स्कैन को सुरक्षा के प्रमाण में नहीं बदलते।

प्रिसिज़न अनुबंध

फॉल्स पॉज़िटिव स्कैनर को मार देते हैं। SecureAI-Scan का नियम इंजन तीन कठोर नियमों का पालन करता है:

1. सिंक इम्पोर्ट के माध्यम से हल किए जाते हैं। यदि एक आइडेंटिफ़ायर किसी ऐसे मॉड्यूल में हल होता है जो LLM SDK नहीं है, तो यह निश्चित रूप से LLM कॉल नहीं है — चाहे उसका नाम कुछ भी हो।
2. साक्ष्य लेबल किया जाता है, कभी मिश्रित नहीं। एक ट्रेस किया गया डेटाफ्लो और एक शब्द-निकटता मैच एक ही चीज़ नहीं हैं, इसलिए वे कभी एक टियर साझा नहीं करते।
3. सुरक्षित कॉर्पस हर रिलीज़ को गेट करता है। test-fixtures/safe/ में वे पैटर्न हैं जो पहले फॉल्स पॉज़िटिव का कारण बनते थे (रेडैक्टेड PII पेलोड, Google Maps क्लाइंट, LLM क्लाइंट के पास एनवी-वेरिएबल API कुंजियाँ, सामान्य रिस्पॉन्स लॉगिंग, OAuth मेटाडेटा फ़ील्ड, स्ट्रीमिंग-रिस्पॉन्स chunks, फिक्शन/नैरेटिव प्रॉम्प्ट टेक्स्ट)। वहाँ कोई भी निष्कर्ष सूट को विफल करता है।

टेस्टिंग और बेंचमार्किंग

तीन परतें, क्योंकि स्कैनर के दावों पर भरोसा करने के लिए अकेली एक पर्याप्त नहीं है — प्रिसिज़न और रिकॉल अलग-अलग विफलता मोड हैं, और दोनों की जाँच की जाती है।

1. फिक्स्चर कॉर्पस — प्रिसिज़न + रिकॉल, हर बिल्ड पर चलता है।```bash npm test

[`test-fixtures/vulnerable/`](https://github.com/akanthed/secureai-scan/blob/main/test-fixtures/vulnerable) और [`test-fixtures/safe/`](https://github.com/akanthed/secureai-scan/blob/main/test-fixtures/safe) को एक साथ स्कैन किया जाता है: हर असुरक्षित फिक्स्चर को `proven`/`likely` साक्ष्य पर अपेक्षित नियम को ट्रिगर करना चाहिए (recall), हर सुरक्षित फिक्स्चर को **शून्य** `proven`/`likely` निष्कर्ष उत्पन्न करने चाहिए (precision)। तेज़ और निर्धारित — लेकिन यह केवल यह साबित करता है कि स्कैनर उस कोड पर व्यवहार करता है जो विशेष रूप से इसका परीक्षण करने के लिए लिखा गया है।

**2. वास्तविक-विश्व प्रतिगमन बेंचमार्क — सार्वजनिक रिपॉजिटरी के विरुद्ध जो हमने नहीं लिखे।**```bash
npm run regression                          # scan the full curated repo set
npm run regression -- --fresh               # re-clone everything first
npm run regression -- openai-node           # scan just one repo by name
npm run regression -- --update-baseline     # accept the current findings

scripts/regression-scan.js वास्तविक सार्वजनिक रिपॉजिटरीज़ का एक क्यूरेटेड, विविध सेट क्लोन करता है (OpenAI/Anthropic/Vercel AI SDKs, आधिकारिक MCP सर्वर और TypeScript SDK, LlamaIndex, साथ ही anthropics/skills और cisco-ai-defense/skill-scanner स्किल-बंडल कवरेज के लिए — TS और Python दोनों, SDK-उपभोक्ता उदाहरण कोड और SDK-लेखक स्रोत को कवर करते हुए) और निर्मित CLI के साथ प्रत्येक को स्कैन करता है।

यह किसी भी proven/likely निष्कर्ष पर गैर-शून्य निकास करता है जो पहले से test/regression-baseline.json में नहीं है — निष्कर्षों का एक हाथ से समीक्षित रिकॉर्ड जो पहले से उनकी स्रोत पंक्ति के विरुद्ध पढ़ा गया है। फ़िंगरप्रिंट repo|rule|file हैं, लाइन नंबर नहीं, इसलिए सामान्य अपस्ट्रीम परिवर्तन शोर पैदा नहीं करता। एक नया फ़िंगरप्रिंट एक दावा है जिसे स्कैनर को उचित ठहराना होता है: यदि यह वास्तविक समस्या नहीं है तो यह एक नियम बग है, जिसे मूल कारण पर ठीक किया जाता है और नए test-fixtures/safe/ फिक्स्चर के रूप में लॉक किया जाता है। किसी निष्कर्ष को बेसलाइन करना जिसे आपने नहीं पढ़ा है, पूरे तंत्र को विफल कर देता है।

स्किल-बंडल कवरेज को अपनी अलग पंक्ति मिलती है क्योंकि cisco-ai-defense/skill-scanner का evals/ कॉर्पस लेबल किया गया है — इसके 20 फिक्स्चर में से प्रत्येक एक _expected.json निर्णय के साथ आता है और शाब्दिक रूप से malicious/ या safe/ नामक निर्देशिका के अंतर्गत स्थित है, इसलिए यह केवल परिशुद्धता जांच नहीं बल्कि रिकॉल जांच के रूप में भी दोगुना काम करता है: 6/6 इन-स्कोप दुर्भावनापूर्ण फिक्स्चर फायर करते हैं, safe लेबल वाली किसी भी चीज़ पर 0 निष्कर्ष, और anthropics/skills के सभी 18 वास्तविक बंडलों और vercel/ai के सभी 14 में 0 निष्कर्ष। (शेष Cisco श्रेणियाँ — SQL इंजेक्शन, पाथ ट्रैवर्सल, संसाधन थकावट, फ़ंक्शन तर्क का सामान्य eval(), चार फ़ाइलों में जानबूझकर विभाजित एक पेलोड — या तो प्रलेखित LLM/MCP/RAG दायरे से बाहर हैं या एकल-फ़ाइल संयोजन विश्लेषण से परे हैं; प्रत्येक पर विशिष्ट तर्क के लिए 0.6.0 चेंजलॉग प्रविष्टि देखें।)

मूल परिशुद्धता सुधारों को चलाने वाले रन से ऐतिहासिक पहले/बाद (डिफ़ॉल्ट साक्ष्य स्तर पर निष्कर्ष, कोई --paranoid नहीं):

वर्तमान रन (2026-08-06) — संस्करणित साक्ष्य docs/benchmarks/v0.9.0.json में दर्ज हैं:

vercel/ai ट्राइएज ने तीन वास्तविक, मूल-कारण वाले बग पाए — कोई भी v0.6.0 स्किल नियमों के लिए विशिष्ट नहीं, सभी साझा लॉजिक में जो कई नियमों में उपयोग होता है:

1. resolveLlmSink ने LLM SDK मॉड्यूल में हल किए गए किसी भी कॉल को विधि नाम की परवाह किए बिना मॉडल इनवोकेशन के रूप में माना — isToolUIPart (एक टाइप गार्ड जो ai पैकेज generateText के ठीक साथ निर्यात करता है) को LLM कॉल के रूप में फ़्लैग करना। यह अकेले 5 निष्कर्ष समूहों में से 3 (AI001, AI003, AI010) का कारण बना।
2. AI005 में DANGEROUS_CALLEES में SQL-इंजेक्शन-शैली सिंक के लिए "query" शामिल है, लेकिन "query" एक वैध LLM/एजेंट इनवोकेशन क्रिया भी है — claudeSdk.query({ prompt, options }), Claude Agent SDK का अपना मॉडल कॉल, केवल साझा विधि नाम के कारण "खतरनाक सिंक में पारित LLM आउटपुट" के रूप में फ़्लैग किया गया था।
3. REQUEST_SOURCES (MCP002, MCP010, VEC003 में समान रूप से डुप्लिकेट) एक बेयर "params." से मेल खाता था — कोई भी फ़ंक्शन पैरामीटर जो पारंपरिक रूप से params नामित है, जरूरी नहीं कि HTTP अनुरोध डेटा हो। एक URL-स्कीम वैलिडेटर (assertOpenLinkParams(params: unknown)) को "उपयोगकर्ता इनपुट से MCP सर्वर URL" के रूप में फ़्लैग किया गया।

तीनों को मूल कारण पर ठीक किया गया (विशिष्ट कॉल साइट पर नहीं) और test-fixtures/ के अंतर्गत स्थायी फिक्स्चर के रूप में पिन किया गया। पूर्ण विवरण CHANGELOG.md में।

3. कमज़ोर-बनाम-पैच्ड सत्यापन — केवल परिशुद्धता नहीं, रिकॉल साबित करता है।

उपरोक्त दो परतें केवल जाँचती हैं कि स्कैनर सुरक्षित कोड पर शांत रहता है। DEP003 की सलाहकार जाँच दूसरे तरीके से सत्यापित की जाती हैं: एक पैकेज को प्रलेखित-कमज़ोर संस्करण पर पिन करें और पुष्टि करें कि यह फ़्लैग किया गया है, फिर इसे पैच किए गए संस्करण पर पिन करें और पुष्टि करें कि यह नहीं है।```bash node --test test/dependency-guard.test.js

कवर: `[email protected]` (CVE-2025-6514, असुरक्षित) फ़्लैग किया गया / `[email protected]` (पैच किया गया) साफ़; `[email protected]` (बैकडोर से पहले) साफ़ / `[email protected]` (बाद में — एक दुर्भावनापूर्ण पैकेज के लिए कोई वैध पैच मौजूद नहीं है) फिर भी फ़्लैग किया गया; `llama-cpp-python==0.2.71` (CVE-2024-34359, OSV-जनित सेट से) फ़्लैग किया गया / `==0.2.72` (पैच किया गया) साफ़, जिसमें PyPI नाम सामान्यीकरण (`llama_cpp_python`) के अंतर्गत भी शामिल है; और `langchain>=0.1.0`-शैली के बिना-पिन किए गए स्पेसिफायर जो **शून्य** डिफ़ॉल्ट-रिपोर्ट निष्कर्ष उत्पन्न करते हैं। इस परीक्षण को बनाने से एक वास्तविक अंतर पकड़ा गया: `DEP003` पहले केवल पैकेज नाम से सलाहों का मिलान करता था, घोषित संस्करण की तुलना सलाह की प्रभावित सीमा से कभी वास्तव में नहीं करता था — [`src/scanner/semver.ts`](https://github.com/akanthed/secureai-scan/blob/main/src/scanner/semver.ts) में ठीक किया गया।

अस्पष्टता को जानबूझकर प्रत्येक सलाह प्रकार के अनुसार अलग तरीके से हल किया जाता है। एक **दुर्भावनापूर्ण** पैकेज तब भी सक्रिय होता है जब घोषित संस्करण हल नहीं किया जा सकता — बैकडोर इंस्टॉल करना अपरिवर्तनीय है, इसलिए यह फ़्लैगिंग की ओर विफल होता है। एक **CVE** केवल `proven` पर तब सक्रिय होता है जब घोषित संस्करण एक सटीक पिन हो जो सिद्ध रूप से प्रभावित सीमा के भीतर है; बिना-पिन-लेकिन-संभावित-प्रभावित `heuristic` पर गिर जाता है (केवल `--paranoid`)। दुर्भावनापूर्ण-प्रकार के नियम को 162-प्रविष्टि वाले CVE स्नैपशॉट पर लागू करने से हर रिपॉजिटरी पर एक गंभीर निष्कर्ष आएगा जो `langchain>=0.1.0` घोषित करता है — बड़े पैमाने पर अकार्यशील शोर।

## रोडमैप

क्या शिप किया गया है और क्या योजनाबद्ध है, इसके लिए [`ROADMAP.md`](https://github.com/akanthed/secureai-scan/blob/main/ROADMAP.md) देखें। दोनों भाषा इंजन AST-आधारित हैं: TypeScript/JavaScript के लिए ts-morph और Python के लिए Tree-sitter। Python इम्पोर्ट, कॉल, असाइनमेंट, डेकोरेटर, स्कोप, कीवर्ड आर्ग्युमेंट, डिक्शनरी फ़ील्ड और स्ट्रिंग सिंटैक्स नोड हैं; लक्ष्य कोड कभी इम्पोर्ट या निष्पादित नहीं किया जाता, और किसी Python इंटरप्रेटर की आवश्यकता नहीं होती। शेष Python अंतर सीमित क्रॉस-फ़ंक्शन/क्रॉस-फ़ाइल टेंट गहराई है, पार्सिंग नहीं। स्कैन प्रदर्शन और ज्ञात सीमाएँ [`docs/Performance.md`](https://github.com/akanthed/secureai-scan/blob/main/docs/Performance.md) में प्रलेखित हैं।

## योगदान

योगदान का स्वागत है — वर्कफ़्लो के लिए [`CONTRIBUTING.md`](https://github.com/akanthed/secureai-scan/blob/main/CONTRIBUTING.md) देखें, और ऊपर दिए गए परिशुद्धता मानक को पूरा करने वाला डिटेक्शन नियम जोड़ने के तरीके के लिए [`docs/WritingRules.md`](https://github.com/akanthed/secureai-scan/blob/main/docs/WritingRules.md) / [`docs/RuleDevelopment.md`](https://github.com/akanthed/secureai-scan/blob/main/docs/RuleDevelopment.md) देखें। प्रत्येक नए नियम को [`test-fixtures/vulnerable/`](https://github.com/akanthed/secureai-scan/blob/main/test-fixtures/vulnerable) और [`test-fixtures/safe/`](https://github.com/akanthed/secureai-scan/blob/main/test-fixtures/safe) दोनों में एक फिक्स्चर, `src/scanner/catalog.ts` में एक प्रविष्टि, और `test/corpus.test.js` में एक केस चाहिए — `npm test` तीनों को लागू करता है।

## लाइसेंस

MIT © Akshay Kanthed