npm supply-chain attack से सर्वर को कैसे सुरक्षित रखें
npm supply-chain attack आपके Node app को कैसे प्रभावित करते हैं। malicious patch, postinstall scripts और typosquats से बचने के लिए सही deploy practice के बारे में विस्तार से जानें।
npm supply-chain attack क्या है और यह आपके सर्वर को कैसे प्रभावित करता है
npm supply-chain attack आपके सर्वर तक उस पैकेज के माध्यम से पहुँचता है जिसे आपने इंस्टॉल करने के लिए चुना है। इसमें किसी open port का उपयोग नहीं होता और न ही कोई exploit step शामिल होती है। npm कोड इंस्टॉल करता है, और कोड इंस्टॉल करने का अर्थ है उसे रन करना। इसलिए, एक छोटा Node application उन सैकड़ों पैकेजों को खींच लेता है जिन्हें आपने कभी पढ़ा नहीं है, और उनमें से कोई भी पैकेज एक घंटे बाद अपना नया version जारी कर सकता है।
आपका deploy एक malicious version को fetch करता है क्योंकि आपके install command ने सबसे नए matching version की मांग की थी। वह कोड फिर उसी व्यक्ति के privileges के साथ रन होता है जिसने install command चलाया था। नीचे दी गई हर बात इन्हीं दो वाक्यों का परिणाम है।
ये स्थितियाँ इस आधार पर क्रमबद्ध हैं कि वे एक व्यक्ति द्वारा एक VPS पर एक Node app deploy करने के दौरान कितनी बार घटित होती हैं। यह क्रम वह नहीं है जिसका उपयोग कोई बड़ी कंपनी करेगी, क्योंकि एक बड़ी कंपनी के पास internal registry, एक review team और public registry का एक mirror होता है। आपके पास केवल एक deploy script है।
स्थिति 1: एक मेंटेनर अकाउंट हैक हो जाता है और एक पैच पब्लिश करता है
npm registry किसी ऐसे वर्ज़न की सामग्री को बदलने की अनुमति नहीं देती जो पहले से मौजूद है। एक हमलावर जो किसी मेंटेनर को फिशिंग का शिकार बनाता है या पब्लिश टोकन चुराता है, वह 4.18.2 को फिर से नहीं लिख सकता। वे 4.18.3 पब्लिश करते हैं।
अपनी package.json को देखें। "express": "^4.18.2" जैसी लाइन का मतलब वर्ज़न 4.18.2 नहीं होता है। कैरेट (caret) का अर्थ है "इस वर्ज़न या इससे ऊपर का कोई भी 4.x वर्ज़न", और ~4.18.2 का अर्थ है "कोई भी 4.18.x वर्ज़न"। npm install रन होने के समय उस रेंज को रिज़ॉल्व करता है, इसलिए एक ही git commit, जिसे एक ही दोपहर में दो बार डिप्लॉय किया जाए, कोड के दो अलग-अलग सेट इंस्टॉल कर सकता है। यह अंतर ही अटैक सरफेस है। इसे खोलने के लिए आपकी मशीन पर किसी चीज़ का हैक होना ज़रूरी नहीं है।
दुर्भावनापूर्ण रिलीज़ की आमतौर पर रिपोर्ट की जाती है और उन्हें हटा दिया जाता है, लेकिन यह हटाना लोगों द्वारा उन्हें इंस्टॉल करने के बाद होता है। जिसने भी उस समय के दौरान डिप्लॉय किया है, उसके डिस्क पर वह कोड मौजूद है। एक पाइपलाइन जो हर रन पर रेंज को रिज़ॉल्व करती है, वह बिना किसी के निर्णय लिए, सप्ताह में कई बार स्वचालित रूप से उस जोखिम के दायरे में आ जाती है।
Shape 2: एक install script उस user के रूप में चलती है जो deploy कर रहा है
किसी package का package.json अपने scripts block में preinstall, install, postinstall और prepare घोषित कर सकता है। npm इन्हें installation के दौरान चलाता है। ये sandboxed नहीं होते और कोई इनकी समीक्षा नहीं करता। ये shell commands उस user के रूप में चलते हैं जिसने install command टाइप की है, उसी user की home directory में, उस user के network access के साथ और उस shell के पूरे environment के साथ।
8 July 2026 को release हुआ npm 12, इस default व्यवहार को बदल देता है: यह dependency install scripts को तब तक रोकता है जब तक कि project के package.json में मौजूद allowScripts field उन्हें मंजूरी न दे दे। 12 October 2026 तक किसी भी Node.js release में npm 12 शामिल नहीं है (Node.js 26.11.1 में npm 11.20.0 है), इसलिए जब तक आपने खुद npm upgrade नहीं किया है, आपके server पर मौजूद npm अभी भी इन सभी scripts को चलाता है।
इसलिए उपयोगी सवाल यह नहीं है कि package क्या कर सकता है। बल्कि यह है कि वह user क्या पढ़ सकता है। एक सामान्य deploy box पर इसका जवाब है: registry token रखने वाली ~/.npmrc, SSH (secure shell) के लिए deploy key के रूप में इस्तेमाल होने वाली ~/.ssh/id_ed25519, ~/.aws/credentials, ~/.docker/config.json, और shell में export किए गए सभी variables, जहाँ आमतौर पर DATABASE_URL मौजूद होता है।
इस तरह के payload को न तो persistence की जरूरत है और न ही privilege escalation की। यह कुछ files पढ़ता है, उन्हें HTTPS के जरिए एक host पर भेजता है, और status 0 के साथ exit हो जाता है। आपको कुछ दिखाई नहीं देता, क्योंकि npm default रूप से install-script के output को छिपा देता है। इसे बंद करें और देखें कि वास्तव में क्या चल रहा है:
npm ci --foreground-scriptsforeground-scripts, npm process के साथ standard input, output और error को साझा करता है, इसलिए build scripts आपके terminal में print करती हैं, न कि उस buffer में जिसे npm install सफल होने पर हटा देता है।
Shape 3: typosquats, और वह नाम जो आपने ठीक से टाइप नहीं किया
Typosquat एक ऐसा पैकेज है जिसे किसी लोकप्रिय पैकेज के नाम से मिलते-जुलते नाम से पब्लिश किया जाता है। यह गलत टाइप किए गए या गलत तरीके से पेस्ट किए गए install कमांड का इंतजार करता है। इसका तंत्र कमांड है, कोड नहीं, इसलिए lockfile यहाँ आपकी मदद नहीं करती: आप एक बार गलत नाम जोड़ते हैं, और उसके बाद lockfile निष्ठापूर्वक उसे पिन कर देती है।
जो वेरिएंट व्यक्तियों के बजाय टीमों को फंसाता है, वह dependency confusion है। मान लीजिए आपका internal पैकेज billing-utils है और वह एक private registry पर स्थित है। यदि public registry पर billing-utils नाम का कुछ भी मौजूद नहीं है, तो कोई भी उसे पब्लिश कर सकता है। npm unscoped नामों को default public registry के आधार पर resolve करता है, इसलिए public कॉपी जीत सकती है। इसका समाधान एक ऐसा scope है जिसे आप own करते हैं, साथ ही उस scope के लिए एक registry mapping, जो .npmrc में दी गई है:
@yourorg:registry=https://npm.yourorg.example/
//npm.yourorg.example/:_authToken=${NPM_TOKEN}अब @yourorg/billing-utils को हमेशा उसी host से fetch किया जाता है, क्योंकि default registry से पहले scope-to-registry mapping को देखा जाता है। एक unscoped internal नाम की कोई mapping नहीं होती, इसलिए उसे कोई सुरक्षा नहीं मिलती।
किसी भी नई dependency को जोड़ने से पहले, उसके download badge के बजाय उसे ध्यान से देखें:
npm view some-lib repository.url maintainers time.created time.modifiedपिछले महीने बनाया गया एक पैकेज, जिसे ऐसे account द्वारा पब्लिश किया गया है जिसे आप किसी public repository से नहीं जोड़ सकते, वह छह साल के इतिहास वाले पैकेज की तुलना में एक अलग जोखिम है। इनमें से कोई भी तथ्य प्रमाण नहीं है। दोनों की जाँच करना आसान है।
आकृति 4: वह dependency जिसका स्वामी चुपचाप बदल गया
Maintainers पैकेज सौंप देते हैं। कोई थक जाता है, कोई अजनबी मदद की पेशकश करता है, publish करने के अधिकार स्थानांतरित हो जाते हैं, और इस पर निर्भर प्रोजेक्ट्स तक किसी भी प्रकार की सूचना नहीं पहुँचती है। कुछ भी compromised नहीं होता है। 2021 में आपने जिस पर भरोसा किया था, वह अब किसी और व्यक्ति के पास है।
यह सबसे धीमी आकृति है और इसे पहचानना सबसे कठिन है, और कोई भी command सीधे इसका उत्तर नहीं देती है। दो चीजें इसे सीमित करती हैं। किसी पैकेज को अपनाने से पहले जांचें कि कौन publish कर सकता है, इसके लिए ऊपर दी गई npm view लाइन का उपयोग करें। फिर जब कोई पैकेज जिस पर आप वास्तव में निर्भर हैं, स्थानांतरित हो जाए तो diff पढ़ें:
npm diff --diff-name-only --diff=some-lib@1.4.2 --diff=some-lib@1.4.3
npm diff --diff=some-lib@1.4.2 --diff=some-lib@1.4.3पहला प्रारूप केवल बदली हुई फाइलों के नाम प्रिंट करता है, जो आपके द्वारा उपयोग किए जाने वाले किसी भी पैकेज के हर upgrade पर करने के लिए पर्याप्त तेज है। एक patch release जो build script को छूती है, पैकेज root पर कोई फाइल जोड़ती है, या scripts ब्लॉक को edit करती है, उसे आपके सर्वर तक पहुँचने से पहले पूरा पढ़ना उचित है।
npm ci के साथ कमिट की गई lockfile से बिल्ड करें
package-lock.json ट्री में मौजूद हर पैकेज का सटीक वर्ज़न, वह URL जहाँ से उसे प्राप्त किया गया, हर tarball का sha512 इंटीग्रिटी हैश, और उसे किस पैकेज ने आवश्यक बनाया, इन सभी का रिकॉर्ड रखता है। इसे कमिट करें। यही एकमात्र फाइल है जो यह बताती है कि आपने वास्तव में किसका परीक्षण किया है।
इसके बाद, डेवलपर लैपटॉप के अलावा किसी भी मशीन पर npm ci का उपयोग करके इंस्टॉल करें, कभी भी npm install का उपयोग न करें:
npm ci --omit=dev --ignore-scriptsnpm ci और npm install के बीच कुछ अंतर हैं जो यहाँ महत्वपूर्ण हैं। इसके लिए एक lockfile का होना अनिवार्य है। यह शुरू होने से पहले किसी भी मौजूदा node_modules को हटा देता है, ताकि पिछले डिप्लॉयमेंट के अवशेष इस डिप्लॉयमेंट में न रह जाएं। यह कभी भी package.json या lockfile में कुछ नहीं लिखता है, इसलिए इंस्टॉल प्रक्रिया आपको चुपचाप किसी नए वर्ज़न पर नहीं ले जा सकती। यदि lockfile और package.json में असहमति है, तो यह अंतर को हल करने के बजाय त्रुटि (error) के साथ बंद हो जाता है।
वह त्रुटि एक फीचर है, न कि कोई परेशानी। इसका अर्थ यह है कि निर्भरता (dependency) में कोई भी बदलाव किसी के द्वारा रिव्यू किए गए कमिट के रूप में आना चाहिए, न कि 02:00 बजे किए गए डिप्लॉयमेंट के साइड इफेक्ट के रूप में।
हर फेच (fetch) पर इंटीग्रिटी हैश की जाँच की जाती है। जिस tarball के बाइट्स रिकॉर्ड किए गए हैश से मेल नहीं खाते, उसका इंस्टॉल code EINTEGRITY के साथ विफल हो जाता है और वह अनपैक नहीं होता। यह आपको क्या लाभ देता है, इसके बारे में सटीक रहें: यह साबित करता है कि जो फाइल आपको मिली है, वही फाइल है जिसे lockfile ने पिन किया था, जो कि वही गारंटी है जो checksums के साथ डाउनलोड सत्यापित करना आपको देता है, और यह उसी तरह सीमित भी है। यह इस बारे में कुछ नहीं कहता कि पिन किया गया वर्ज़न पब्लिश होते समय दुर्भावनापूर्ण (malicious) था या नहीं।
--omit=dev के बारे में एक विवरण: उन पैकेजों को अभी भी रिज़ॉल्व किया जाता है और अभी भी lockfile में लिखा जाता है। उन्हें बस डिस्क पर नहीं रखा जाता है। डिस्क पर कम पैकेज होने का मतलब है कम इंस्टॉल स्क्रिप्ट और रनटाइम पर कम कोड लोड होना, इसलिए ऐसा करना फायदेमंद है। यह आपके ट्री से किसी निर्भरता को हटाता नहीं है।
Install scripts को कोड की तरह मानें और उन्हें अस्वीकार करना सीखें
आप install scripts को बंद कर सकते हैं। इसे प्रोजेक्ट की .npmrc में डालें और lockfile के साथ commit करें:
ignore-scripts=true
save-exact=trueignore-scripts=true, npm को dependencies में घोषित scripts चलाने से रोकता है। save-exact=true यह सुनिश्चित करता है कि npm install some-lib, ^1.4.2 के बजाय 1.4.2 को package.json में लिखे, ताकि कोई resolving range गलती से आपके manifest में न आ जाए।
यह सेटअप कुछ चीजों को बाधित कर सकता है, और इसे enable करने से पहले आपको यह पता होना चाहिए कि ऐसा क्यों होता है। जो packages native addon compile करते हैं या prebuilt binary डाउनलोड करते हैं, वे यह काम install script में करते हैं। scripts बंद होने पर, install तो सफल हो जाता है, लेकिन विफलता बाद में runtime पर दिखाई देती है, जहाँ एक module अपनी binding file को load नहीं कर पाता। इसका समाधान एक allowlist है:
npm ci --ignore-scripts
npm rebuild better-sqlite3 --ignore-scripts=falsenpm rebuild <package> केवल उस एक package के लिए build scripts चलाता है। --ignore-scripts=false वैकल्पिक नहीं है: npm rebuild उस ignore-scripts=true का पालन करता है जिसे आपने अभी .npmrc में commit किया है, और override के बिना यह केवल package की binaries को link करता है और उसकी कोई भी script नहीं चलाता। अब आपने सैकड़ों अनजान लोगों को execute permission देने के बजाय, हर package के लिए एक निर्णय लिया है।
यदि आप npm 12 का उपयोग करते हैं, तो यह allowlist पहले से ही शामिल है। npm approve-scripts better-sqlite3, package.json के allowScripts field में स्वीकृति को record करता है, अस्वीकृत dependency scripts को एक चेतावनी के साथ छोड़ दिया जाता है, और npm rebuild भी उसी सूची की जाँच करता है, इसलिए npm 12 पर ऊपर बताया गया rebuild भी उसी स्वीकृति की मांग करता है। एक committed ignore-scripts=true, allowScripts policy को पूरी तरह से override कर देता है।
यह देखने के लिए कि वर्तमान में यह अनुमति कितनी व्यापक है, npm से पूछें:
npm query ":attr(scripts, [postinstall])"यह installed tree के हर उस package को print करता है जिसमें postinstall script मौजूद है। एक सामान्य application पर यह सूची लोगों की अपेक्षा से छोटी होती है, और यही कारण है कि allowlist व्यावहारिक है।
बिल्ड प्रक्रिया को ट्रैफिक सर्व करने वाली प्रक्रिया से अलग करें
Deploy user को node_modules लिखने की आवश्यकता होती है। HTTP requests का उत्तर देने वाली प्रक्रिया को इसकी आवश्यकता नहीं होती। यदि वे एक ही account हैं, तो install के दौरान चलने वाला code उस code को rewrite कर सकता है जो आपके users को serve करता है, और runtime पर चलने वाला code भी उसे rewrite कर सकता है।
उन्हें अलग करें। एक user के रूप में build करें, दूसरे के रूप में serve करें, और served directory को serving account के लिए read-only बना दें:
sudo useradd --system --home-dir /srv/nodeapp --shell /usr/sbin/nologin nodeapp
sudo chown -R deploy:nodeapp /srv/nodeapp
sudo chmod -R o-rwx /srv/nodeappफिर systemd से इसे लागू करवाएं। /etc/systemd/system/nodeapp.service लिखें:
[Unit]
Description=Node application
After=network-online.target
[Service]
User=nodeapp
Group=nodeapp
WorkingDirectory=/srv/nodeapp/current
EnvironmentFile=/etc/nodeapp/env
ExecStart=/usr/bin/node server.js
Restart=on-failure
NoNewPrivileges=yes
ProtectSystem=strict
ProtectHome=yes
PrivateTmp=yes
ReadWritePaths=/srv/nodeapp/shared
NoExecPaths=/srv/nodeapp/shared
RestrictAddressFamilies=AF_INET AF_INET6 AF_UNIX
[Install]
WantedBy=multi-user.targetProtectSystem=strict इस service के लिए पूरे file system को read-only mount करता है, सिवाय /dev, /proc, /sys और उन directories के जिन्हें आप ReadWritePaths में सूचीबद्ध करते हैं। इसलिए application द्वारा node_modules में लिखने का कोई भी प्रयास EROFS: read-only file system के साथ विफल हो जाएगा, जिसे आप लगभग एक मिनट में अपने logs में जाकर देख सकते हैं। NoExecPaths writable upload directory को कवर करता है: service वहां files लिख सकती है और kernel उन्हें execute करने से मना कर देता है। उस option के लिए systemd 248 या उससे नया version चाहिए, और Ubuntu 24.04 में 255 आता है।
इस unit file में दो सावधानियां बरतें। पहला, MemoryDenyWriteExecute=yes न जोड़ें। यह अधिकांश systemd hardening सूचियों में दिखाई देता है, और यह Node को start होने से रोकता है, क्योंकि V8 runtime पर JavaScript को machine code में compile करता है और उसे ऐसे pages की आवश्यकता होती है जो writable और executable दोनों हों। दूसरा, command -v node से ExecStart path लें। यदि Node को version manager के साथ install किया गया था, तो यह deploy user की home directory के अंतर्गत रहता है, ProtectHome=yes फिर उस directory को service से छिपा देता है, और unit तुरंत status=203/EXEC के साथ विफल हो जाती है और एक log line यह बताती है कि executable नहीं मिल सका।
file पर भरोसा करने के बजाय परिणाम की जाँच करें:
sudo systemctl daemon-reload
sudo systemctl enable --now nodeapp
sudo systemd-analyze security nodeapp.service
sudo -u nodeapp touch /srv/nodeapp/current/probesystemd-analyze security हर hardening setting को उसकी exposure के साथ सूचीबद्ध करता है, ताकि आप देख सकें कि कौन सी अभी भी default पर है। touch को Permission denied के साथ विफल होना चाहिए, क्योंकि nodeapp current के अंतर्गत किसी भी चीज़ का स्वामी नहीं है। यदि यह सफल हो जाता है, तो आपकी file ownership गलत है और systemd settings चुपचाप इसे कवर कर रही हैं।
EnvironmentFile पर एक नोट: systemd इसे root के रूप में पढ़ता है इससे पहले कि वह User=nodeapp पर drop हो, इसलिए वह file mode 600 के साथ root:root हो सकती है। Application को अभी भी variables प्राप्त होते हैं। nodeapp के रूप में shell रखने वाला कोई भी व्यक्ति अभी भी उन्हें /proc/<pid>/environ से पढ़ सकता है, इसलिए यह secret को at rest सुरक्षित करता है, न कि running process को।
Deploy credentials को build environment से बाहर रखें
Install scripts environment को inherit करते हैं। यह एक तथ्य यह तय करने के लिए पर्याप्त है कि आपको build कहाँ करना चाहिए।
सबसे सुरक्षित तरीका यह है कि आप production server के अलावा किसी अन्य स्थान पर build करें और तैयार directory को वहाँ copy करें। ऐसी स्थिति में build machine के पास केवल एक read-only registry token होता है और कुछ नहीं। इसमें कोई SSH deploy key, cloud access key, database password या container registry login नहीं होता है।
npm token create --name=build-readonly --packages-and-scopes-permission=read-only --packages-all --expires=30एक read-only token packages को fetch कर सकता है, लेकिन उन्हें publish नहीं कर सकता। npm ने 9 December 2025 को सभी classic tokens को रद्द कर दिया था, इसलिए अब यह एक granular access token है, और permission flag ही इसे read-only बनाता है: वर्तमान npm अभी भी पुराने --read-only flag को स्वीकार करता है, लेकिन npm token create इसे registry तक नहीं भेजता है। यदि build environment से token चोरी हो जाता है, तो नुकसान केवल उन packages तक read access का होता है जिन्हें यह cover करता है।
यदि आपको server पर ही build करना अनिवार्य है, तो deploy user के रूप में build करें जिसका environment जानबूझकर सीमित रखा गया हो, और runtime secrets को /etc/nodeapp/env में रखें, जिसे deploy पढ़ न सके। यही तर्क आपके द्वारा host की गई build automation पर भी लागू होता है: एक self-hosted GitHub Actions runner tokens को hold करता है और हर job पर मनमाना published code execute करता है, जो इसे एक छोटे deployment में सबसे अधिक मूल्यवान machine बनाता है। कोई भी program जिसे आपने नहीं लिखा है और जो आपके पूरे environment को प्राप्त करता है, वह इसी श्रेणी में आता है, और यही कारण है कि AI agent के environment से secrets को बाहर रखना इसी समस्या का एक अलग रूप है जिसमें बीच में एक दूसरा program होता है।
जिसे आप ऑडिट नहीं कर सकते उसे पिन करें या वेंडर करें
एक pinned dependency वह है जिसका version बिना commit किए नहीं बदल सकता। committed lockfile पहले से ही पूरे tree के लिए ऐसा करता है। दो स्थितियों में और अधिक करने की आवश्यकता होती है।
Transitive dependencies पहली स्थिति है। आप यह नियंत्रित नहीं करते कि आपकी dependencies किस पर निर्भर हैं। overrides, package.json में tree में कहीं भी एक version को force करता है:
{
"overrides": {
"some-transitive-lib": "1.4.2"
}
}इसे जोड़ने के बाद एक बार npm install चलाएं ताकि lockfile परिणाम को record कर सके, फिर दोनों files को commit करें।
दूसरी स्थिति एक ऐसा package है जिसे आप न तो audit कर सकते हैं और न ही हटा सकते हैं। उसे vendor करें। npm pack ठीक वही tarball download करता है जिसे registry serve करेगी, और एक file: dependency आपकी copy से install होती है:
npm pack some-lib@1.4.2
mkdir -p vendor && mv some-lib-1.4.2.tgz vendor/{
"dependencies": {
"some-lib": "file:vendor/some-lib-1.4.2.tgz"
}
}Tarball अब आपके repository में रहता है और आपके बिना बदले नहीं बदल सकता। आपने इसके updates की जिम्मेदारी हमेशा के लिए ले ली है, इसलिए इसका उपयोग उस छोटे abandoned package के लिए करें जिससे आप बंधे हैं, न कि अपने web framework के लिए।
एक cooling-off period भी होता है, जिसकी कोई लागत नहीं है:
npm install --before=2026-08-01before option केवल उन versions का उपयोग करके tree को rebuild करता है जो उस तारीख को या उससे पहले publish किए गए थे। जब आप dependencies को refresh करें, तो इसे एक या दो सप्ताह पीछे सेट करें, और आप उस window को छोड़ देंगे जिसमें एक खराब release live होती है और अभी तक report नहीं की गई होती है। यह एक blunt tool है, क्योंकि यह वास्तविक security fixes को भी रोक देता है। ranges को resolve करने, क्या बदला है यह पढ़ने, और फिर lockfile को commit करने के लिए इसका उपयोग करें। हाल के npm releases min-release-age को भी स्वीकार करते हैं, जो दिनों में एक rolling window है (.npmrc में min-release-age=7), जो बिना तारीख के वही काम करता है ताकि इसे आगे बढ़ाया जा सके। यही प्रवृत्ति उन command line tools के लिए भी अपनानी चाहिए जिन्हें आप npm से install करते हैं, न कि उन पर निर्भर रहते हैं, जहाँ एक unpinned npx call उस सुबह जो भी release हुआ उसे fetch कर लेती है और dsh version को पिन करना ही वह चीज है जो दो मशीनों पर एक ही code को चलाती है।
मुझे कैसे पता चलेगा कि मैंने कौन सा version ship किया है?
Git में मौजूद lockfile यह बताता है कि क्या install होना चाहिए था। डिस्क यह बताती है कि क्या install हुआ है। केवल दूसरा वाला ही प्रमाण है।
npm ls some-lib
node -e "console.log(require('./node_modules/some-lib/package.json').version)"npm ls, node_modules को पढ़ता है, इसलिए यह lockfile के इरादे के बजाय भौतिक रूप से मौजूद version की रिपोर्ट करता है। node -e लाइन installed manifest को path के अनुसार पढ़ती है, जो उन packages के लिए भी काम करती है जिनके exports field subpath imports को ब्लॉक करते हैं, और यह बिना किसी tree drawing के एक version print करती है।
तुलना के दूसरे भाग के लिए, git को पढ़ें:
git log --oneline -- package-lock.json
git show <commit>:package-lock.json | grep -A3 '"node_modules/some-lib"'Commit को deploy layout में डालकर दोनों के बीच संबंध को स्थायी बनाएँ। /srv/nodeapp/releases/<short commit sha> में release करें और एक symlink के साथ /srv/nodeapp/current को उस पर point करें। "अभी क्या चल रहा है" का उत्तर readlink /srv/nodeapp/current हो जाता है, और यह उस व्यक्ति के लिए भी 03:00 बजे उपलब्ध होता है जिसने इसे deploy नहीं किया था।
अंत में, जाँचें कि registry किसके लिए पुष्टि (vouch) करेगी:
npm audit signaturesयह आपके installed tree में मौजूद packages पर registry signatures को verify करता है, और जिन packages में provenance attestations हैं, उनके लिए उन्हें भी verify करता है। Provenance एक published tarball को उसे बनाने वाले public continuous integration (CI) build से जोड़ता है, इसलिए एक verified attestation का मतलब है कि आप code को किसी अज्ञात laptop के बजाय एक commit तक trace कर सकते हैं। कवरेज सार्वभौमिक नहीं है, इसलिए missing attestation को "कोई जानकारी नहीं" के रूप में पढ़ें, न कि "खराब package" के रूप में।
जब कोई खराब release आपके सर्वर तक पहुँच जाए तो क्या करें
जो चला है और जिस user के रूप में चला है, वहाँ से बाहर की ओर जाँच करें।
यदि कोड install के दौरान चला था, तो मान लें कि build user द्वारा पढ़ी जा सकने वाली हर चीज़ compromised है। registry token, उस home directory में मौजूद SSH keys, cloud credentials और उस shell में export किए गए किसी भी secret को rotate करें। Rotation ही एकमात्र ईमानदार प्रतिक्रिया है, क्योंकि आप यह साबित नहीं कर सकते कि कोई फ़ाइल नहीं पढ़ी गई थी।
यदि कोड runtime पर एक locked-down service account के तहत चला था, तो पहुँच योग्य दायरा बहुत छोटा होता है: केवल application के अपने environment variables और जो कुछ भी उसका network access प्राप्त कर सकता है। यही VPS पर unprivileged users के रूप में services चलाने का पूरा तर्क है। यह compromise को रोकता नहीं है। यह तय करता है कि compromise को मशीन का कितना हिस्सा मिलता है, और क्या वह restart के बाद भी बना रहता है।
फिर सफाई करने के बजाय rebuild करें। node_modules को delete करें, प्रभावित package को package.json में खराब version से नीचे pin करें, lockfile को update करने के लिए एक बार npm install चलाएँ, उसे commit करें और npm ci के साथ deploy करें। किसी tree को उसी स्थान पर repair न करें। आप यह नहीं बता सकते कि install script ने किन चीज़ों को छुआ है।
उस समय-सीमा को भी लिख लें: पहला deploy जिसने version को pull किया हो सकता है, और वह deploy जिसने इसे हटा दिया। वह दायरा आपको बताता है कि आपको अपने कौन से logs पढ़ने हैं, और इसका उत्तर तभी दिया जा सकता है जब आपके releases के नाम commits के आधार पर रखे गए हों।
इनमें से कोई भी उपाय क्या ठीक नहीं करता
Lockfile किसी dependency को सुरक्षित नहीं बनाता। यह उस क्षण को, जब आपने उस dependency को स्वीकार किया था, एक deploy के दुष्प्रभाव के बजाय एक पुराने, समीक्षित निर्णय में बदल देता है। ऊपर बताई गई हर प्रक्रिया इसी रूपांतरण को अंजाम देती है: दुर्घटना से विकल्प की ओर।
npm audit यहाँ कोई बचाव नहीं है। यह आपकी tree की तुलना रिपोर्ट की गई vulnerabilities के डेटाबेस से करता है, इसलिए यह उन समस्याओं को ढूँढता है जो पहले ही प्रकाशित और नामित हो चुकी हैं। एक supply-chain attack अपने पूरे उपयोगी जीवनकाल के दौरान अनाम रहता है। पुरानी ज्ञात खामियों के लिए npm audit चलाएँ, लेकिन चार घंटे पहले जारी हुए किसी release के बारे में इससे किसी मदद की उम्मीद न रखें।
अपनी dependency की संख्या कम करना इस गाइड के किसी भी टूल से अधिक मदद करता है, और यह सबसे कम लोकप्रिय सलाह है जो कोई भी देता है। हर package जिसे आप नहीं जोड़ते, वह एक ऐसा publisher कम करता है जिसे आपकी ओर से phish नहीं किया जा सकता, और एक ऐसी install script कम करता है जो आपके deploy user के रूप में कभी नहीं चलती।
इनमें से कुछ भी केवल npm तक सीमित नहीं है। यही चार स्थितियाँ PyPI, RubyGems, container images और आपके distribution के package manager पर भी लागू होती हैं। npm में यह सबसे अधिक दिखाई देता है क्योंकि यहाँ trees सबसे गहरी होती हैं और अधिकांश npm सर्वर अभी भी डिफ़ॉल्ट रूप से install scripts को निष्पादित करते हैं। जो कुछ भी आपके द्वारा पहले से चलाए जा रहे टूल का विस्तार करता है, वह उसी समस्या को विरासत में प्राप्त करता है। यही कारण है कि install करने से पहले यह पता लगाना कि एक dsh plugin कहाँ तक पहुँच सकता है वही अभ्यास है जो एक postinstall script को पढ़ना है, जहाँ आपके deploy user की अनुमतियों की जगह आपके agent की अनुमतियाँ होती हैं। आसपास की मशीन का कितना हिस्सा आपकी सुरक्षा के दायरे में है, यह इस पर निर्भर करता है कि वह कहाँ चलती है, जो कि क्या VPS hosting सुरक्षित है, इस व्यापक प्रश्न का एक हिस्सा है।
FAQ
क्या npm ci मुझे किसी compromised npm package से बचाता है?
यह आपको आपकी जानकारी के बिना version बदलने से बचाता है। npm ci ठीक वही install करता है जो package-lock.json रिकॉर्ड करता है। यह प्रत्येक tarball की sha512 integrity hash से जाँच करता है। यदि package.json और lockfile में अंतर हो, तो यह अंतर को हल करने के बजाय error के साथ बंद हो जाता है। यह इस बारे में कुछ नहीं कहता कि pinned version सुरक्षित है या नहीं। यदि आप ऐसी lockfile commit करते हैं जो किसी malicious version को pin करती है, तो npm ci आपके हर सर्वर पर हर बार उस version को पूरी निष्ठा से install कर देगा।
क्या मुझे हर चीज़ के लिए ignore-scripts=true सेट करना चाहिए?
इसे सेट करें, फिर allowlist का उपयोग करें। प्रोजेक्ट की .npmrc में ignore-scripts=true लगाने से dependency install scripts का चलना रुक जाता है। यह किसी खराब package से आपके deploy user के credentials तक पहुँचने का सबसे सीधा रास्ता बंद कर देता है। जो packages native addon compile करते हैं या prebuilt binary fetch करते हैं, उन्हें वास्तव में scripts की आवश्यकता होती है। scripts बंद होने पर वे install के समय के बजाय बाद में runtime पर missing binding file error के साथ fail हो जाते हैं। npm ci --ignore-scripts चलाएँ, फिर उन कुछ packages के लिए npm rebuild <package> --ignore-scripts=false चलाएँ जिन पर आपने भरोसा करने का निर्णय लिया है, क्योंकि npm rebuild अन्यथा .npmrc सेटिंग का पालन करता है और कुछ भी नहीं चलाता है। npm query ":attr(scripts, [postinstall])" दिखाता है कि वास्तव में ऐसे कितने packages हैं।
मुझे कैसे पता चलेगा कि मेरे सर्वर ने वास्तव में package का कौन सा version install किया है?
lockfile के बजाय disk को पढ़ें। npm ls <package> रिपोर्ट करता है कि node_modules में क्या मौजूद है, और node -e "console.log(require('./node_modules/<package>/package.json').version)" केवल version string प्रिंट करता है। git में मौजूद lockfile एक अलग सवाल का जवाब देता है, जो यह है कि क्या install होना चाहिए था, और इन दोनों की तुलना करना ही मुख्य उद्देश्य है। git commit के नाम पर बनी directory में deploy करने से महीनों बाद भी दोनों जवाब उपलब्ध रहते हैं, जब आपको उनकी आवश्यकता होती है।
क्या npm audit supply-chain attacks को ढूँढता है?
नहीं। npm audit आपके tree का मिलान रिपोर्ट की गई vulnerabilities के database से करता है, इसलिए यह केवल उन्हीं समस्याओं को ढूँढता है जो पहले से प्रकाशित हो चुकी हैं और जिन्हें identifier दिया गया है। एक malicious release उन घंटों या दिनों के दौरान unreported रहता है जब उसे install करना मायने रखता है। npm audit signatures अधिक उपयोगी command है: यह आपके installed tree में registry signatures को verify करता है और provenance attestations की जाँच करता है जहाँ publisher ने उन्हें बनाया है। यह आपको बताता है कि tarball किसी अज्ञात मशीन के बजाय public build से आया है।
यदि हमला install के समय होता है, तो app को unprivileged user के रूप में चलाना क्यों मायने रखता है?
क्योंकि दोनों विफलताओं का दायरा अलग-अलग होता है और आप दोनों के खिलाफ बचाव कर रहे होते हैं। install-time code, deploy user के रूप में चलता है और उस user की SSH keys, registry tokens और cloud credentials को पढ़ सकता है। runtime code, service account के रूप में चलता है, और User=nodeapp, ProtectSystem=strict तथा disk पर किसी भी readable credential के न होने से, इसकी पहुँच केवल application के अपने environment और उसके database तक सीमित रहती है। accounts को अलग रखने का मतलब यह भी है कि traffic serve करने वाली process node_modules को rewrite नहीं कर सकती, इसलिए runtime compromise अगले restart पर खत्म हो जाता है, न कि स्थायी बन जाता है।