SSD Nodes Learn Hosting plans →
मार्गदर्शक Matt Connorद्वारे Matt Connor · अपडेटेड 2026-10-24

npm सप्लाय-चेन अटॅकपासून सर्व्हर कसा सुरक्षित ठेवावा?

npm सप्लाय-चेन अटॅक तुमच्या Node ॲपमध्ये कसे शिरतात ते जाणून घ्या. मालिशिअस पॅच, पोस्ट-इन्स्टॉल स्क्रिप्ट्स आणि टायपोस्कॉटिंगपासून वाचण्यासाठी सुरक्षित डिप्लॉयमेंट पद्धती वापरा.

तुमच्या सर्व्हरवरील npm supply-chain attack म्हणजे काय

npm supply-chain attack तुम्ही install करण्यासाठी निवडलेल्या package द्वारे तुमच्या सर्व्हरपर्यंत पोहोचतो. यामध्ये कोणताही उघडा पोर्ट किंवा exploit टप्पा नसतो. npm code install करते आणि code install केल्यावर तो code चालतो. त्यामुळे छोटा Node application तुम्ही कधीही वाचलेले नसलेले शेकडो package install करू शकतो. त्यापैकी कोणतेही package एका तासानंतर नवीन version release करू शकते.

तुमच्या install command मध्ये सर्वात नवीन जुळणारे version मागितले असल्यामुळे deploy दरम्यान malicious version fetch होते. त्यानंतर तो code install चालवणाऱ्या वापरकर्त्याच्या privileges सह चालतो. पुढील सर्व मुद्दे या दोन वाक्यांमधून स्पष्ट होतात.

खालील प्रकार एक Node app एका VPS वर deploy करणाऱ्या एका व्यक्तीला किती वेळा प्रभावित करतात, यानुसार क्रमाने दिले आहेत. मोठी कंपनी हा क्रम वापरणार नाही. तिच्याकडे internal registry, review team आणि public registry ची mirror असते. तुमच्याकडे deploy script आहे.

आकार 1: मेंटेनर्सचे खाते हॅक होणे आणि त्याद्वारे पॅच प्रकाशित करणे

npm रजिस्ट्री अस्तित्वात असलेल्या व्हर्जनमधील मजकूर कोणालाही बदलू देत नाही. त्यामुळे, ज्या अटॅकरने मेंटेनरला फिशिंगद्वारे फसवले आहे किंवा ज्याने पब्लिश टोकन चोरले आहे, तो 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 कमिटमध्ये कोडचे दोन वेगवेगळे संच इन्स्टॉल होऊ शकतात. ही तफावत म्हणजे अटॅक सरफेस आहे. हे घडण्यासाठी तुमच्या मशीनवर काहीही कॉम्प्रमाइज होण्याची गरज नसते.

दुर्भावनापूर्ण रिलीज (malicious releases) सहसा रिपोर्ट केले जातात आणि काढून टाकले जातात, परंतु हे काढून टाकण्याचे काम लोक ते इन्स्टॉल केल्यानंतरच होते. ज्याने त्या कालावधीत डिप्लॉयमेंट केले आहे, त्याच्या डिस्कवर तो कोड आधीच आलेला असतो. जी पाइपलाइन प्रत्येक रनवर रेंज रिझॉल्व्ह करते, ती आपोआपच अशा धोक्याच्या कालावधीत प्रवेश करते; हे आठवड्यातून अनेकदा घडते, आणि यासाठी कोणाच्याही निर्णयाची गरज नसते.

आकार 2: deploy करणाऱ्या user म्हणून install script चालते

एखाद्या package चे package.json त्याच्या scripts block मध्ये preinstall, install, postinstall आणि prepare घोषित करू शकते. npm installation दरम्यान ही scripts चालवते. त्यांना sandbox केलेले नसते आणि त्यांचे कोणतेही परीक्षण केले जात नाही. install command टाइप करणाऱ्या user म्हणून चालणाऱ्या या shell commands असतात. त्या user च्या home directory मध्ये, त्या user च्या network access सह आणि त्या shell च्या संपूर्ण environment सह त्या चालतात.

8 July 2026 रोजी release झालेला npm 12 हा default बदलतो: project मधील package.json च्या allowScripts field ने मंजुरी दिल्याशिवाय तो dependency install scripts block करतो. 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 केलेले प्रत्येक variable यांचा समावेश होतो. DATABASE_URL सहसा याच ठिकाणी असते.

अशा payload ला persistence किंवा privilege escalation ची आवश्यकता नसते. तो काही files वाचतो, त्या HTTPS द्वारे एखाद्या host कडे पाठवतो आणि status 0 सह बंद होतो. तुम्हाला काहीही दिसत नाही, कारण npm default ने install-script output लपवते. ते बंद करून प्रत्यक्षात काय चालते ते पाहा:

npm ci --foreground-scripts

foreground-scripts standard input, output आणि error npm process सोबत share करते. त्यामुळे build scripts तुमच्या terminal मध्ये print होतात. Installation यशस्वी झाल्यावर npm ज्या buffer मधील output टाकून देते, त्यात ते जात नाही.

आकार 3: टायपोस्कॉट्स आणि तुम्ही न टाईप केलेले नाव

टायपोस्कॉट म्हणजे लोकप्रिय पॅकेजच्या नावाशी मिळतेजुळते नाव वापरून प्रकाशित केलेले पॅकेज. हे पॅकेज चुकीच्या स्पेलिंगमुळे किंवा चुकीच्या पद्धतीने पेस्ट केलेल्या इन्स्टॉल कमांडची वाट पाहत असते. ही यंत्रणा कमांडवर आधारित असते, कोडवर नाही, त्यामुळे येथे lockfile तुम्हाला मदत करू शकत नाही: तुम्ही एकदा चुकीचे नाव जोडले की, lockfile त्यानंतर तेच नाव विश्वासार्हपणे पिन करते.

व्यक्तींऐवजी टीमला लक्ष्य करणारा प्रकार म्हणजे dependency confusion. तुमचे अंतर्गत पॅकेज billing-utils नावाचे आहे आणि ते एका खाजगी रजिस्ट्रीवर असते. जर सार्वजनिक रजिस्ट्रीवर billing-utils नावाचे काहीही अस्तित्वात नसेल, तर कोणीही ते प्रकाशित करू शकते. npm हे unscoped नावे डीफॉल्ट सार्वजनिक रजिस्ट्रीवर शोधते, त्यामुळे सार्वजनिक कॉपी जिंकू शकते. यावर उपाय म्हणजे तुमच्या मालकीचा एक scope आणि त्या scope साठी रजिस्ट्री मॅपिंग, जे .npmrc मध्ये दिले आहे:

@yourorg:registry=https://npm.yourorg.example/
//npm.yourorg.example/:_authToken=${NPM_TOKEN}

आता @yourorg/billing-utils फक्त त्या होस्टवरूनच मिळवले जाते, कारण डीफॉल्ट रजिस्ट्री तपासण्यापूर्वी scope-to-registry मॅपिंग तपासले जाते. unscoped अंतर्गत नावासाठी कोणतेही मॅपिंग नसते, त्यामुळे त्याला कोणतेही संरक्षण नसते.

कोणतीही नवीन dependency जोडण्यापूर्वी, तिच्या डाउनलोड बॅजकडे पाहण्याऐवजी त्या पॅकेजची स्वतः तपासणी करा:

npm view some-lib repository.url maintainers time.created time.modified

गेल्या महिन्यात तयार केलेले आणि ज्याचा सार्वजनिक रिपॉझिटरीशी संबंध जोडता येत नाही अशा खात्याद्वारे प्रकाशित केलेले पॅकेज, सहा वर्षांचा इतिहास असलेल्या पॅकेजपेक्षा वेगळ्या प्रकारचा धोका निर्माण करते. यातील कोणतीही गोष्ट पुराव्यासारखी नाही. दोन्ही गोष्टी तपासणे सोपे आहे.

आकार 4: अशी डिपेंडन्सी जिचा मालक शांतपणे बदलला आहे

मेंटेनर्स पॅकेजची जबाबदारी इतरांकडे सोपवतात. एखादी व्यक्ती थकल्यामुळे काम थांबवते, एखादी अनोळखी व्यक्ती मदतीचा हात पुढे करते, पब्लिश करण्याचे अधिकार हस्तांतरित होतात आणि त्यावर अवलंबून असलेल्या प्रोजेक्ट्सना याची कोणतीही सूचना मिळत नाही. यात कोणतीही सुरक्षा त्रुटी (compromise) नसते. तुम्ही 2021 मध्ये ज्या व्यक्तीवर विश्वास ठेवला होता, तो आता दुसऱ्या व्यक्तीच्या हातात असतो.

हा सर्वात संथ आणि शोधण्यास कठीण असा प्रकार आहे. कोणतीही एक कमांड याचे थेट उत्तर देत नाही. दोन गोष्टींमुळे हे मर्यादित करता येते. एखादे पॅकेज स्वीकारण्यापूर्वी, वरील 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

पहिली पद्धत फक्त बदललेल्या फाईल्सची नावे दाखवते, जी तुम्ही काळजी घेत असलेल्या प्रत्येक पॅकेजच्या अपग्रेडवेळी तपासण्यासाठी पुरेशी वेगवान आहे. एखादे पॅच रिलीज जे बिल्ड स्क्रिप्टला स्पर्श करते, पॅकेजच्या रूटमध्ये नवीन फाईल जोडते किंवा scripts ब्लॉक संपादित करते, ते तुमच्या सर्व्हरवर पोहोचण्यापूर्वी पूर्णपणे वाचणे फायदेशीर ठरते.

npm ci वापरून कमिट केलेल्या lockfile वरून बिल्ड करा

package-lock.json ट्री मधील प्रत्येक पॅकेजची नेमकी आवृत्ती, ते ज्या URL वरून आले, प्रत्येक tarball चा sha512 इंटिग्रिटी हॅश आणि कोणत्या पॅकेजला त्याची गरज होती, याची नोंद ठेवते. ते कमिट करा. तुम्ही प्रत्यक्ष कशाची चाचणी केली आहे, हे सांगणारी ही एकमेव फाईल आहे.

त्यानंतर, डेव्हलपर लॅपटॉप सोडून इतर कोणत्याही मशीनवर npm ci ने इन्स्टॉल करा, कधीही npm install वापरू नका:

npm ci --omit=dev --ignore-scripts

npm ci आणि npm install मध्ये काही महत्त्वाचे फरक आहेत जे येथे लागू होतात. npm ci साठी lockfile असणे आवश्यक आहे. ते सुरू करण्यापूर्वी अस्तित्वात असलेले node_modules काढून टाकते, त्यामुळे मागील डिप्लॉयमधील जुने घटक नवीन डिप्लॉयमध्ये राहत नाहीत. ते कधीही package.json किंवा lockfile मध्ये बदल करत नाही, त्यामुळे इन्स्टॉलेशन दरम्यान आवृत्ती आपोआप अपडेट होत नाही. जर lockfile आणि package.json मध्ये विसंगती असेल, तर ते फरक सोडवण्याऐवजी त्रुटी (error) देऊन थांबते.

ती त्रुटी ही एक सोय आहे, अडथळा नाही. याचा अर्थ असा की, डिपेंडन्सीमधील कोणताही बदल हा एखाद्याने रिव्ह्यू केलेल्या कमिटद्वारेच आला पाहिजे, पहाटे 02:00 वाजता होणाऱ्या डिप्लॉयचा तो एक अनपेक्षित परिणाम नसावा.

प्रत्येक फेच (fetch) वेळी इंटिग्रिटी हॅश तपासला जातो. ज्या tarball चे बाइट्स रेकॉर्ड केलेल्या हॅशशी जुळत नाहीत, त्याचे इन्स्टॉलेशन code EINTEGRITY त्रुटी देऊन थांबवले जाते, ते अनपॅक केले जात नाही. यामुळे काय फायदा होतो ते नीट समजून घ्या: तुम्हाला मिळालेली फाईल हीच ती फाईल आहे जी lockfile मध्ये पिन केली होती, याची ही खात्री देते. हीच हमी checksums वापरून डाउनलोड पडताळणे तुम्हाला देते आणि तिची व्याप्तीही तितकीच मर्यादित आहे. पिन केलेली आवृत्ती प्रकाशित झाली तेव्हा ती घातक (malicious) होती की नाही, याबद्दल हे काहीही सांगत नाही.

--omit=dev बद्दल एक तपशील: ती पॅकेजेस अजूनही रिझॉल्व्ह केली जातात आणि lockfile मध्ये लिहिली जातात. फक्त ती डिस्कवर ठेवली जात नाहीत. डिस्कवर कमी पॅकेजेस असण्याचा अर्थ असा की कमी इन्स्टॉल स्क्रिप्ट्स आणि रनटाइमला कमी कोड लोड होतो, त्यामुळे हे करणे फायदेशीर आहे. हे तुमच्या ट्री मधून डिपेंडन्सी काढून टाकत नाही.

Install scripts कडे code म्हणून पाहा आणि ते नाकारण्याची वेळ ओळखा

तुम्ही install scripts बंद करू शकता. हे प्रकल्पाच्या .npmrc मध्ये ठेवा आणि lockfile च्या शेजारी commit करा:

ignore-scripts=true
save-exact=true

ignore-scripts=true dependencies मध्ये घोषित केलेल्या scripts npm ने चालवणे थांबवते. save-exact=true मुळे npm install some-lib हे ^1.4.2 ऐवजी package.json मध्ये 1.4.2 लिहिते. त्यामुळे dependency resolve करणारी range चुकून तुमच्या manifest मध्ये समाविष्ट होत नाही.

यामुळे अडचणी निर्माण होऊ शकतात. त्यामुळे हे सक्षम करण्यापूर्वी त्याची कार्यपद्धत समजून घ्या. Native addon compile करणारी किंवा prebuilt binary download करणारी packages हे काम install script मध्ये करतात. Scripts बंद असताना install यशस्वी होते; पण नंतर runtime वेळी binding file load न होणारे module अशी त्रुटी दिसते. यासाठी allowlist वापरा:

npm ci --ignore-scripts
npm rebuild better-sqlite3 --ignore-scripts=false

npm rebuild <package> त्या पॅकेजसाठी build scripts चालवते. --ignore-scripts=false पर्यायी नाही: npm rebuild तुम्ही नुकतेच .npmrc मध्ये commit केलेल्या ignore-scripts=true चा आदर करते. override शिवाय ते पॅकेजच्या binaries ला link करते आणि त्यातील कोणतेही scripts चालवत नाही. आता तुम्ही प्रत्येक पॅकेजसाठी स्वतंत्र निर्णय घेतला आहे. कधीही भेटणार नसलेल्या काहीशे अनोळखी लोकांना सर्व पॅकेजेससाठी blanket execute permission देण्याऐवजी हा अधिक नियंत्रित पर्याय आहे.

तुम्ही npm 12 वापरत असल्यास, ही allowlist अंगभूत असते. npm approve-scripts better-sqlite3 ही मंजुरी package.json मधील allowScripts फील्डमध्ये नोंदवते, मंजुरी नसलेल्या dependency scripts इशाऱ्यासह वगळल्या जातात आणि npm rebuild हीच यादी तपासते. त्यामुळे npm 12 मध्ये वरील rebuild साठीही ती मंजुरी आवश्यक आहे. Commit केलेले ignore-scripts=true allowScripts धोरण पूर्णपणे override करते.

ते grant सध्या किती मोठे आहे हे पाहण्यासाठी npm ला विचारा:

npm query ":attr(scripts, [postinstall])"

यामुळे स्थापित tree मधील postinstall script असलेले प्रत्येक package छापले जाते. सामान्य application मध्ये ही यादी अपेक्षेपेक्षा लहान असते. त्यामुळे allowlist प्रत्यक्षात वापरणे सुलभ होते.

build प्रक्रिया आणि network traffic सेवा देणारी प्रक्रिया वेगळी ठेवा

deploy वापरकर्त्याला node_modules मध्ये लिहिता आले पाहिजे. HTTP विनंत्यांना उत्तर देणाऱ्या प्रक्रियेला त्याची गरज नसते. दोन्ही एकाच account अंतर्गत चालत असतील, तर install दरम्यान चालणारा code वापरकर्त्यांना सेवा देणारा code पुन्हा लिहू शकतो. Runtime दरम्यान चालणारा code देखील तसे करू शकतो.

दोन्ही वेगळे करा. एका वापरकर्त्याच्या account अंतर्गत build करा, दुसऱ्या वापरकर्त्याच्या account अंतर्गत सेवा द्या आणि सेवा देणाऱ्या account साठी सेवा दिली जाणारी directory 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.target

ProtectSystem=strict या सेवेसाठी संपूर्ण file system read-only mount करते. मात्र /dev, /proc, /sys आणि ReadWritePaths मध्ये नमूद केलेल्या इतर ठिकाणांना अपवाद असतो. त्यामुळे application ने node_modules मध्ये लिहिण्याचा प्रयत्न केल्यास तो EROFS: read-only file system मुळे अयशस्वी होतो. ही बाब तुम्ही स्वतःच्या logs मध्ये सुमारे एका मिनिटात पुन्हा निर्माण करून पाहू शकता. NoExecPaths writable upload directory साठी आहे. सेवेला तेथे files लिहिता येतात, परंतु kernel त्या files चे execution नाकारतो. या पर्यायासाठी systemd 248 किंवा त्यानंतरचे version आवश्यक आहे. Ubuntu 24.04 मध्ये 255 समाविष्ट आहे.

या unit file मध्ये दोन अडचणी आहेत. पहिली, MemoryDenyWriteExecute=yes जोडू नका. बहुतेक systemd hardening lists मध्ये हा पर्याय असतो. तो Node सुरू होण्यापासून थांबवतो, कारण V8 runtime दरम्यान JavaScript चे machine code मध्ये compilation करते आणि त्याला writable तसेच executable अशा दोन्ही प्रकारची pages आवश्यक असतात. दुसरी, ExecStart चा path command -v node मधून घ्या. Node version manager वापरून install केले असल्यास ते deploy वापरकर्त्याच्या home directory अंतर्गत असते. ProtectHome=yes नंतर ती directory सेवेसाठी लपवते. त्यामुळे unit लगेच status=203/EXEC सह अयशस्वी होते आणि executable सापडले नाही अशी log line दिसते.

File वर विश्वास ठेवण्याऐवजी परिणाम तपासा:

sudo systemctl daemon-reload
sudo systemctl enable --now nodeapp
sudo systemd-analyze security nodeapp.service
sudo -u nodeapp touch /srv/nodeapp/current/probe

systemd-analyze security प्रत्येक hardening setting आणि तिचे exposure list करते. त्यामुळे कोणत्या settings अजूनही default वर आहेत ते दिसते. touch Permission denied सह अयशस्वी झाले पाहिजे, कारण nodeapp कडे current अंतर्गत काहीही नाही. ते यशस्वी झाल्यास file ownership चुकीचे आहे आणि systemd settings ते शांतपणे झाकत आहेत.

EnvironmentFile बाबत एक नोंद: systemd User=nodeapp वर switch होण्यापूर्वी ते root म्हणून read करते. त्यामुळे ती file mode 600 सह root:root असू शकते. Application ला variables तरीही मिळतात. nodeapp म्हणून shell access असलेली कोणतीही व्यक्ती ती variables /proc/<pid>/environ मधून वाचू शकते. त्यामुळे हे secret at rest चे संरक्षण करते; चालू process चे नाही.

बिल्ड वातावरणापासून deploy credentials वेगळे ठेवा

Install scriptsना environment वारशाने मिळते. त्यामुळे build कुठे करायचा हे ठरवताना ही बाब महत्त्वाची आहे.

सर्वात सुरक्षित पद्धत म्हणजे production server व्यतिरिक्त इतर ठिकाणी build करणे आणि तयार directory serverवर 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 token revoke केला. त्यामुळे हा granular access token आहे. Permission flag मुळे तो read-only होतो: सध्याचा npm जुना --read-only flag अजूनही स्वीकारतो, पण npm token create तो registryकडे पाठवत नाही. Build environmentमधून token चोरीला गेला, तरी तो ज्या packagesसाठी लागू आहे त्यांवरील read accessपुरतेच नुकसान मर्यादित राहते.

Serverवरच build करणे आवश्यक असल्यास, जाणीवपूर्वक मर्यादित environment वापरून deploy user म्हणून build करा. Runtime secrets /etc/nodeapp/env मध्ये ठेवा; deploy त्यांना वाचू शकत नाही. हीच कारणमीमांसा तुम्ही स्वतः host केलेल्या build automationलाही लागू होते: self-hosted GitHub Actions runner कडे tokens असतात आणि प्रत्येक jobमध्ये मनमानीपणे प्रकाशित केलेला code execute केला जातो. त्यामुळे छोट्या deploymentमधील हा सर्वाधिक मौल्यवान machine ठरतो. तुमच्या संपूर्ण environmentचा access असलेला, पण तुम्ही लिहिलेला नसलेला कोणताही program याच वर्गात येतो. म्हणूनच AI agentच्या environmentमधून secrets वेगळे ठेवणे हीच समस्या वेगळ्या programच्या माध्यमातून हाताळण्यासारखी आहे.

तुम्ही audit करू शकत नाही ते pin करा किंवा vendor करा

Pinned dependency ही अशी dependency असते जिची version commit केल्याशिवाय बदलता येत नाही. संपूर्ण tree साठी committed lockfile हे काम आधीच करते. आणखी दोन परिस्थितींमध्ये वेगळी कृती आवश्यक असते.

Transitive dependencies हा पहिला प्रकार आहे. तुमच्या dependencies कशांवर अवलंबून आहेत, हे तुम्ही नियंत्रित करत नाही. overrides मधील package.json वापरल्यास संपूर्ण tree मध्ये कुठेही एकच version लागू होते:

{
  "overrides": {
    "some-transitive-lib": "1.4.2"
  }
}

ते जोडल्यानंतर एकदा npm install चालवा, जेणेकरून lockfile मध्ये परिणाम नोंदवला जाईल. त्यानंतर दोन्ही files commit करा.

दुसरी परिस्थिती म्हणजे अशी package जी तुम्ही audit करू शकत नाही आणि काढूनही टाकू शकत नाही. तिचे vendor करा. npm pack registry कडून मिळणारा अचूक tarball download करते, आणि 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-01

before option वापरल्यास tree पुन्हा तयार करताना त्या तारखेला किंवा त्यापूर्वी publish झालेल्या versionsच वापरल्या जातात. Dependencies refresh करताना ही तारीख एक किंवा दोन आठवडे मागे ठेवा. त्यामुळे एखादा खराब release live झाल्यानंतर आणि त्याची तक्रार नोंदवली जाण्यापूर्वी असलेली वेळ तुम्ही टाळू शकता. ही पद्धत blunt आहे, कारण genuine security fixes देखील पुढे ढकलले जातात. Ranges resolve करण्यासाठी ती वापरा, काय बदलले ते वाचा आणि नंतर lockfile commit करा. अलीकडील npm releases मध्ये min-release-age देखील स्वीकारले जाते. हे days मधील rolling window आहे (min-release-age=7 in .npmrc), त्यामुळे सतत बदलत ठेवावी लागणारी तारीख न वापरता तेच काम होते. npm वरून install केलेल्या command line tools साठीही हीच काळजी घ्या, विशेषतः त्यांच्यावर dependency न ठेवता ते install करत असल्यास. Unpinned npx call त्या सकाळी release झालेली कोणतीही गोष्ट fetch करते, तर अचूक dsh version pin करणे हेच दोन machines वर समान code चालवते.

मी कोणती आवृत्ती प्रत्यक्षात रिलीज केली आहे हे कसे ओळखावे?

git मधील lockfile मध्ये काय इन्स्टॉल व्हायला हवे होते हे नमूद असते. डिस्कवर काय इन्स्टॉल झाले आहे हे प्रत्यक्ष पुरावा असते. केवळ दुसरा पर्याय हाच खरा पुरावा आहे.

npm ls some-lib
node -e "console.log(require('./node_modules/some-lib/package.json').version)"

npm ls हे node_modules वाचते, त्यामुळे lockfile मध्ये काय अपेक्षित होते यापेक्षा प्रत्यक्षात काय उपस्थित आहे, याची माहिती ते देते. node -e ओळ इन्स्टॉल केलेल्या मॅनिफेस्टला पाथद्वारे वाचते. हे अशा पॅकेजेससाठीही काम करते ज्यांचे exports फील्ड सबपाथ इम्पोर्ट्सना प्रतिबंधित करते आणि ते कोणत्याही ट्री स्ट्रक्चरशिवाय एक आवृत्ती प्रिंट करते.

तुलनेच्या दुसऱ्या भागासाठी, git वाचा:

git log --oneline -- package-lock.json
git show <commit>:package-lock.json | grep -A3 '"node_modules/some-lib"'

डिप्लॉय लेआउटमध्ये कमिट टाकून या दोन गोष्टींमध्ये कायमस्वरूपी संबंध प्रस्थापित करा. /srv/nodeapp/releases/<short commit sha> मध्ये रिलीज करा आणि symlink वापरून /srv/nodeapp/current ला त्याकडे निर्देशित करा. "सध्या काय चालू आहे" या प्रश्नाचे उत्तर readlink /srv/nodeapp/current असे मिळते आणि ज्या व्यक्तीने डिप्लॉयमेंट केले नाही, त्यालाही ते 03:00 वाजता उपलब्ध असते.

शेवटी, रजिस्ट्री कशाची खात्री देते ते तपासा:

npm audit signatures

हे तुमच्या इन्स्टॉल केलेल्या ट्री मधील पॅकेजेसवरील रजिस्ट्री स्वाक्षऱ्यांची पडताळणी करते आणि ज्या पॅकेजेसकडे provenance attestations आहेत, त्यांचीही खात्री करते. Provenance हे प्रकाशित केलेल्या tarball ला ते तयार करणाऱ्या सार्वजनिक continuous integration (CI) बिल्डशी जोडते. त्यामुळे, प्रमाणित attestation चा अर्थ असा की तुम्ही कोडचा मागोवा एखाद्या अज्ञात लॅपटॉपपर्यंत न नेता थेट कमिटपर्यंत घेऊ शकता. सर्व पॅकेजेससाठी हे उपलब्ध नसते, म्हणून attestation नसल्यास त्याचा अर्थ "माहिती उपलब्ध नाही" असा घ्या, "खराब पॅकेज" असा घेऊ नका.

एखादी सदोष release सर्व्हरवर पोहोचल्यावर काय करावे

काय चालले होते आणि कोणत्या युजरच्या अधिकारात चालले होते, इथून तपासणीला सुरुवात करा.

जर कोड इन्स्टॉलेशन दरम्यान चालला असेल, तर बिल्ड युजरला वाचता येण्याजोग्या सर्व फाईल्स सुरक्षित नाहीत असे समजा. registry token, त्या home directory मधील SSH keys, cloud credentials आणि त्या शेलमध्ये export केलेले कोणतेही secret त्वरित बदला (rotate करा). rotation हाच एकमेव प्रामाणिक उपाय आहे, कारण कोणती फाईल वाचली गेली नाही हे तुम्ही सिद्ध करू शकत नाही.

जर कोड रनटाइम दरम्यान मर्यादित (locked-down) सर्व्हिस अकाउंट अंतर्गत चालला असेल, तर त्याचा आवाका खूपच कमी असतो: फक्त ॲप्लिकेशनचे स्वतःचे environment variables आणि त्याच्या नेटवर्क ॲक्सेसद्वारे पोहोचता येण्याजोग्या गोष्टी. VPS वर unprivileged युजर म्हणून सर्व्हिसेस चालवण्यामागे हाच मुख्य युक्तिवाद आहे. यामुळे सर्व्हर सुरक्षित होतो असे नाही, तर त्या सुरक्षिततेच्या उल्लंघनाचा (compromise) मशीनवर किती परिणाम होईल आणि रीबूटनंतर ते टिकून राहील का, हे ठरते.

त्यानंतर, साफसफाई करण्याऐवजी सर्व्हिस पुन्हा बिल्ड करा. node_modules डिलीट करा, package.json मध्ये प्रभावित पॅकेजला सदोष व्हर्जनच्या खाली पिन करा, lockfile अपडेट करण्यासाठी एकदा npm install चालवा, ते commit करा आणि npm ci वापरून deploy करा. सर्व्हरवर थेट दुरुस्ती (repair) करू नका. इन्स्टॉल स्क्रिप्टने नेमके कुठे बदल केले आहेत, याची यादी करणे अशक्य असते.

तसेच, सदोष व्हर्जनचा कालावधी नोंदवून ठेवा: ज्या पहिल्या deploy मुळे ते व्हर्जन आले आणि ज्या deploy मुळे ते काढून टाकले गेले, तो काळ. हा कालावधी तुम्हाला तुमचे स्वतःचे logs तपासण्यासाठी मदत करतो आणि जर तुमच्या releases ची नावे commits वरून ठेवली असतील, तरच हे शक्य होते.

यापैकी काहीही काय दुरुस्त करत नाही

lockfile dependency सुरक्षित असल्याची हमी देत नाही. तो dependency स्वीकारल्याचा क्षण दिनांकासह आणि पुनरावलोकन केलेला निर्णय बनवतो. त्यामुळे तो निर्णय deploy चा अनपेक्षित परिणाम राहत नाही. वरील प्रत्येक पद्धत हाच बदल घडवते: अपघाती गोष्टीचे जाणीवपूर्वक घेतलेल्या निर्णयात रूपांतर.

npm audit हा येथे संरक्षण नाही. तो तुमच्या tree ची तुलना नोंदवलेल्या vulnerabilities च्या database शी करतो. त्यामुळे आधीच प्रकाशित आणि नाव दिलेल्या समस्या त्याला सापडतात. Supply-chain attack त्याच्या संपूर्ण उपयुक्त कालावधीत अनामित असतो. जुन्या ज्ञात bugs साठी npm audit चालवा. चार तासांपूर्वी release झालेल्या आवृत्तीबद्दल त्याच्याकडून काहीही अपेक्षा ठेवू नका.

या मार्गदर्शकातील कोणत्याही tool पेक्षा dependency ची संख्या कमी करणे अधिक उपयुक्त आहे. तरीही हा सल्ला सर्वांत कमी दिला जातो. तुम्ही न जोडलेला प्रत्येक package म्हणजे तुमच्या वतीने phishing करता न येणारा आणखी एक publisher. तसेच deploy user म्हणून कधीही न चालणारा आणखी एक install script.

यापैकी काहीही केवळ npm पुरते मर्यादित नाही. हेच चार नमुने PyPI, RubyGems, container images आणि तुमच्या distribution च्या package manager ला लागू होतात. npm मध्ये ही समस्या सर्वाधिक दिसते, कारण trees सर्वांत खोल असतात आणि बहुतांश servers वर चालणारा npm install scripts default ने execute करतो. तुम्ही आधीपासून चालवत असलेल्या tool ची क्षमता वाढवणाऱ्या कोणत्याही गोष्टीला हीच समस्या वारशाने मिळते. म्हणूनच dsh plugin install करण्यापूर्वी तो कोणत्या गोष्टींना पोहोचू शकतो हे ठरवणे आणि postinstall script वाचणे हा समान प्रकारचा सराव आहे. येथे तुमच्या deploy user च्या permissions ऐवजी तुमच्या agent च्या permissions लागू होतात. आजूबाजूच्या machine पैकी किती भागाचे संरक्षण करणे तुमची जबाबदारी आहे हे तो कुठे चालतो यावर अवलंबून असते. हा VPS hosting सुरक्षित आहे का या व्यापक प्रश्नाचा एक भाग आहे.

FAQ

npm ci मला compromised npm package पासून संरक्षण देते का?

तुमच्या माहितीशिवाय version बदलला जाण्यापासून ते संरक्षण देते. npm ci, package-lock.json मध्ये नोंदवलेलेच install करते, प्रत्येक tarball चा sha512 integrity hash शी मेळ तपासते आणि package.json व lockfile मध्ये विसंगती असल्यास ती सोडवण्याऐवजी error देऊन थांबते. Pin केलेली version सुरक्षित आहे की नाही, याबद्दल ते काहीही सांगत नाही. तुम्ही malicious version ला pin करणारे lockfile commit केले, तर npm ci तुमच्या प्रत्येक सर्व्हरवर प्रत्येक वेळी तीच version अचूकपणे install करेल.

सर्व गोष्टींसाठी ignore-scripts=true सेट करावे का?

ते सेट करा आणि त्यानंतर allowlist वापरा. प्रकल्पाच्या .npmrc मधील ignore-scripts=true dependency install scripts चालू देत नाही. त्यामुळे खराब package पासून deploy user च्या credentials पर्यंत पोहोचण्याचा सर्वात थेट मार्ग बंद होतो. Native addon compile करणाऱ्या किंवा prebuilt binary fetch करणाऱ्या packages ना त्यांचे scripts खरोखर आवश्यक असतात. Scripts बंद असताना install time ऐवजी runtime ला missing binding file मुळे ती packages fail होतात. npm ci --ignore-scripts चालवा. त्यानंतर ज्या काही packages वर तुम्ही विश्वास ठेवण्याचे ठरवले आहे त्यांच्यासाठी npm rebuild <package> --ignore-scripts=false वापरा, कारण अन्यथा npm rebuild .npmrc setting मान्य करते आणि काहीही चालवत नाही. प्रत्यक्षात अशी किती packages आहेत हे npm query ":attr(scripts, [postinstall])" दाखवते.

माझ्या सर्व्हरने प्रत्यक्षात 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 वेगळ्या प्रश्नाचे उत्तर देते: कोणती version install व्हायला हवी होती. या दोन्हींची तुलना करणे हाच उद्देश आहे. Git commit नंतरच्या नावाच्या directory मध्ये deploy केल्यास, काही महिन्यांनी दोन्ही उत्तरे उपलब्ध राहतात.

npm audit supply-chain attacks शोधते का?

नाही. npm audit तुमच्या tree ची नोंद झालेल्या vulnerabilities च्या database शी तुलना करते. त्यामुळे आधीच प्रकाशित करून identifier दिलेल्या issuesच ती शोधू शकते. Malicious release प्रकाशित नोंद नसलेली असताना ती install करणे धोकादायक ठरू शकते. npm audit signatures ही अधिक उपयुक्त command आहे. ती तुमच्या installed tree मधील registry signatures पडताळते आणि publisher ने दिले असल्यास provenance attestations तपासते. त्यामुळे tarball unknown machine वरून नव्हे, तर public build मधून आला आहे का हे समजते.

Attack install time ला होत असेल, तर app unprivileged user म्हणून चालवणे महत्त्वाचे का आहे?

कारण या दोन failures ची व्याप्ती वेगळी आहे आणि तुम्ही दोन्हींपासून संरक्षण करत आहात. Install-time code deploy user म्हणून चालतो आणि त्या user चे SSH keys, registry tokens आणि cloud credentials वाचू शकतो. Runtime code service account म्हणून चालतो. User=nodeapp, ProtectSystem=strict आणि disk वर credentials नसल्यामुळे तो application च्या स्वतःच्या environment आणि database पलीकडे पोहोचू शकत नाही. Accounts वेगळे ठेवल्यामुळे traffic serve करणारी process node_modules पुन्हा लिहू शकत नाही. त्यामुळे runtime compromise कायमस्वरूपी होण्याऐवजी पुढील restart वेळी नाहीसा होतो.

हा लेख उपयुक्त होता का?