SSD Nodes Learn Hosting plans →
கல்வி வழிகாட்டிகள் Matt Connorஆல் Matt Connor · புதுப்பிக்கப்பட்டது 2026-10-24

npm supply-chain attack தடுப்பது எப்படி?

npm packages மூலம் உங்கள் Node app-ல் ஊடுருவும் malicious scripts மற்றும் typosquats தாக்குதல்களைத் தடுக்கும் முறைகள். பாதுகாப்பான deploy செயல்முறைகளை இந்த வழிகாட்டி விளக்குகிறது.

உங்கள் server-ல் npm supply-chain attack என்றால் என்ன

நீங்கள் நிறுவத் தேர்ந்தெடுத்த package மூலம் npm supply-chain attack உங்கள் server-ஐ அடைகிறது. இதில் open port எதுவும் தேவையில்லை; exploit படியும் இல்லை. npm code-ஐ install செய்கிறது; code-ஐ install செய்வது அந்த code-ஐ இயக்குகிறது. எனவே, ஒரு சிறிய Node application-கூட நீங்கள் ஒருபோதும் படிக்காத பல நூறு packages-ஐ சார்ந்திருக்கும். அவற்றில் ஏதேனும் ஒன்று இன்னும் ஒரு மணி நேரத்தில் புதிய version-ஐ publish செய்யலாம்.

உங்கள் install command, பொருந்தும் versions-ல் newest version-ஐ கேட்டதால், உங்கள் deploy malicious version-ஐ fetch செய்கிறது. பின்னர் அந்த code, install command-ஐ இயக்கியவரின் privileges-உடன் இயங்கும். கீழே உள்ள அனைத்தும் இந்த இரண்டு வாக்கியங்களிலிருந்து பெறப்படுகின்றன.

ஒரு Node app-ஐ ஒரு VPS-ல் deploy செய்யும் ஒருவரை அவை எவ்வளவு அடிக்கடி பாதிக்கின்றன என்பதன் அடிப்படையில், இந்த attack வகைகள் வரிசைப்படுத்தப்பட்டுள்ளன. பெரிய நிறுவனத்தில் பயன்படுத்தப்படும் வரிசை இதுவல்ல. காரணம், பெரிய நிறுவனத்திடம் internal registry, review team, மற்றும் public registry-ன் mirror இருக்கும். உங்களிடம் ஒரு deploy script மட்டுமே உள்ளது.

வடிவம் 1: ஒரு பராமரிப்பாளர் கணக்கு சமரசம் செய்யப்பட்டு, ஒரு patch வெளியிடப்படுதல்

npm registry ஏற்கனவே உள்ள ஒரு version-ன் உள்ளடக்கத்தை மாற்ற யாரையும் அனுமதிப்பதில்லை. ஒரு பராமரிப்பாளரை phish செய்யும் அல்லது publish token-ஐ திருடும் ஒரு தாக்குதலால் 4.18.2-ஐ மாற்றியமைக்க முடியாது. அவர்கள் 4.18.3-ஐ வெளியிடுகிறார்கள்.

உங்கள் package.json-ஐ கவனியுங்கள். "express": "^4.18.2" போன்ற ஒரு வரி, version 4.18.2-ஐ மட்டும் குறிக்காது. இதில் உள்ள caret குறியீடு "இந்த version அல்லது அதற்கு மேல் உள்ள எந்தவொரு 4.x version-ம்" என்று பொருள்படும், மேலும் ~4.18.2 என்பது "எந்தவொரு 4.18.x version-ம்" என்று பொருள்படும். npm install அந்த range-ஐ இயங்கும் நேரத்தில் தீர்மானிக்கிறது, எனவே ஒரே git commit-ஐ ஒரே நாளில் இருமுறை deploy செய்யும்போது, அது இரண்டு வெவ்வேறு code தொகுப்புகளை நிறுவக்கூடும். அந்த இடைவெளிதான் தாக்குதல் பரப்பு (attack surface). அது திறப்பதற்கு உங்கள் கணினியில் எதுவும் சமரசம் செய்யப்பட வேண்டிய அவசியமில்லை.

தீங்கிழைக்கும் releases பொதுவாகப் புகாரளிக்கப்பட்டு நீக்கப்படுகின்றன, ஆனால் அந்த நீக்கம் மக்கள் அவற்றை நிறுவிய பின்னரே நடக்கிறது. அந்த இடைவெளியில் யார் deploy செய்தார்களோ, அவர்களின் வட்டில் அந்த code இருக்கும். ஒவ்வொரு முறையும் range-களைத் தீர்மானிக்கும் ஒரு pipeline, தானாகவே அந்த இடைவெளிக்குள் நுழைகிறது; யாரும் தீர்மானிக்காமலேயே வாரத்திற்குப் பலமுறை இது நிகழ்கிறது.

வடிவம் 2: deploy செய்யும் user-ஆக install script இயங்குகிறது

ஒரு package-ன் package.json, அதன் scripts block-ல் preinstall, install, postinstall மற்றும் prepare ஆகியவற்றை அறிவிக்கலாம். npm அவற்றை installation நேரத்தில் இயக்கும். அவை sandbox செய்யப்படுவதில்லை; யாரும் அவற்றை review செய்வதில்லை. install command-ஐ உள்ளிட்ட user-ஆக அவை இயங்கும் shell commands ஆகும். அந்த user-ன் home directory, network access மற்றும் அந்த shell-ன் முழு environment ஆகியவற்றுடன் அவை இயங்கும்.

8 July 2026 அன்று வெளியிடப்பட்ட npm 12, இந்த default-ஐ மாற்றுகிறது: project-ன் allowScripts field, package.json-ல் அவற்றை அனுமதிக்காவிட்டால் dependency install scripts-ஐ அது block செய்யும். 12 October 2026 நிலவரப்படி எந்த Node.js release-உம் npm 12-ஐ bundle செய்யவில்லை (Node.js 26.11.1, npm 11.20.0-ஐ ship செய்கிறது). எனவே நீங்கள் npm-ஐ தனியாக upgrade செய்யவில்லை என்றால், உங்கள் server-ல் உள்ள npm இவற்றில் ஒவ்வொன்றையும் தொடர்ந்து இயக்கும்.

ஆகவே பயனுள்ள கேள்வி 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 install-script output-ஐ default-ஆக மறைப்பதால் உங்களுக்கு எதுவும் தெரியாது. அதை முடக்கி, உண்மையில் இயங்குவதைப் பாருங்கள்:

npm ci --foreground-scripts

foreground-scripts, npm process-உடன் standard input, output மற்றும் error-ஐ பகிர்கிறது. எனவே build scripts, npm வெற்றிகரமான installation-க்குப் பிறகு discard செய்யும் buffer-க்கு பதிலாக உங்கள் terminal-ல் output-ஐ அச்சிடும்.

வடிவம் 3: typosquats மற்றும் நீங்கள் தவறாகத் தட்டச்சு செய்த பெயர்

ஒரு typosquat என்பது பிரபலமான ஒரு தொகுப்பின் பெயருக்கு நெருக்கமான பெயரில் வெளியிடப்படும் தொகுப்பாகும். இது தவறான தட்டச்சு அல்லது தவறாக நகலெடுக்கப்பட்ட install கட்டளைக்காகக் காத்திருக்கும். இதன் செயல்முறை கட்டளையைச் சார்ந்தது, குறியீட்டை (code) அல்ல. எனவே, lockfile இங்கே உதவாது: நீங்கள் ஒருமுறை தவறான பெயரைச் சேர்த்தால், அதன் பிறகு lockfile அதைத் துல்லியமாகப் பதிந்துவிடும்.

தனிநபர்களை விட குழுக்களைப் பாதிக்கும் இதன் மாறுபட்ட வடிவம் dependency confusion ஆகும். உங்கள் உள்நாட்டுத் தொகுப்பு billing-utils என்று அழைக்கப்படுகிறது மற்றும் அது ஒரு private registry-ல் உள்ளது. பொதுவான registry-ல் billing-utils என்ற பெயரில் எதுவும் இல்லை என்றால், எவரும் அதை வெளியிட முடியும். npm, unscoped பெயர்களை இயல்புநிலை public registry-ல் தேடும், எனவே பொதுவான பதிப்பு வெற்றி பெறக்கூடும். இதற்கான தீர்வு, நீங்கள் வைத்திருக்கும் ஒரு scope மற்றும் அந்த scope-க்கான registry mapping ஆகும். இதை .npmrc-ல் அமைக்கலாம்:

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

இப்போது @yourorg/billing-utils அந்த host-லிருந்து மட்டுமே பெறப்படும், ஏனெனில் இயல்புநிலை registry-க்கு முன்பாகவே scope-to-registry mapping சரிபார்க்கப்படுகிறது. unscoped உள்நாட்டுப் பெயருக்கு mapping இல்லாததால், அதற்குப் பாதுகாப்பு இல்லை.

புதிய dependency எதையும் சேர்ப்பதற்கு முன், அதன் download badge-ஐ மட்டும் பார்க்காமல், அதைக் கூர்ந்து கவனியுங்கள்:

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

கடந்த மாதம் உருவாக்கப்பட்ட ஒரு தொகுப்பு, பொதுவான repository-உடன் தொடர்பில்லாத ஒரு கணக்கிலிருந்து வெளியிடப்பட்டிருந்தால், அது ஆறு வருட வரலாற்றைக் கொண்ட தொகுப்பிலிருந்து மாறுபட்ட ஆபத்தைக் கொண்டது. இதில் எந்த உண்மையும் ஆதாரமல்ல. ஆனால் இரண்டையும் சரிபார்ப்பது எளிது.

வடிவம் 4: உரிமையாளர் அமைதியாக மாறிய சார்புநிலை (dependency)

Maintainer-கள் தொகுப்புகளை (packages) மற்றவர்களிடம் ஒப்படைக்கிறார்கள். ஒருவர் பணியிலிருந்து விலகும்போது, ஒரு புதிய நபர் உதவ முன்வருகிறார், வெளியீட்டு உரிமைகள் (publish rights) மாறுகின்றன, ஆனால் அதைச் சார்ந்திருக்கும் திட்டங்களுக்கு எந்தவிதமான அறிவிப்பும் கிடைப்பதில்லை. இதில் எந்த சமரசமும் (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

முதல் வடிவம் மாற்றப்பட்ட கோப்புப் பெயர்களை மட்டுமே அச்சிடும். நீங்கள் முக்கியமாகக் கருதும் தொகுப்புகளை மேம்படுத்தும் (upgrade) ஒவ்வொரு முறையும் இதைச் செய்வது எளிது. ஒரு build script-ஐ மாற்றும், தொகுப்பின் root-ல் ஒரு கோப்பைச் சேர்க்கும் அல்லது scripts தொகுப்பைத் திருத்தும் ஒரு patch release-ஐ, அது உங்கள் server-க்கு வரும் முன்பே முழுமையாகப் படித்துப் பார்ப்பது நல்லது.

npm ci மூலம் கமிட் செய்யப்பட்ட lockfile-லிருந்து உருவாக்குதல்

package-lock.json ஆனது, tree-ல் உள்ள ஒவ்வொரு package-ன் துல்லியமான பதிப்பு, அது வந்த URL, ஒவ்வொரு tarball-ன் sha512 integrity hash மற்றும் அதை எந்த package கோரியது ஆகிய விவரங்களைப் பதிவு செய்கிறது. இதை கமிட் செய்யவும். நீங்கள் உண்மையில் எதைச் சோதித்தீர்கள் என்பதை உறுதிப்படுத்தும் ஒரே கோப்பு இதுதான்.

பிறகு, டெவலப்பரின் லேப்டாப் அல்லாத எந்தவொரு கணினியிலும் npm install-க்கு பதிலாக, எப்போதும் npm ci-ஐப் பயன்படுத்தி install செய்யவும்:

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

npm ci மற்றும் npm install ஆகியவற்றுக்கு இடையே உள்ள வேறுபாடுகள் இங்கே முக்கியமானவை. npm ci-க்கு ஒரு lockfile கட்டாயம் இருக்க வேண்டும். இது தொடங்குவதற்கு முன்பே ஏற்கனவே உள்ள node_modules-ஐ நீக்கிவிடும், எனவே முந்தைய deploy-ன் எஞ்சிய கோப்புகள் இதில் இருக்காது. இது package.json-லிலோ அல்லது lockfile-லிலோ எதையும் எழுதாது, எனவே ஒரு install தானாகவே உங்களை அடுத்த பதிப்பிற்கு நகர்த்தாது. lockfile மற்றும் package.json ஆகியவற்றுக்கு இடையே முரண்பாடு இருந்தால், அது வேறுபாடுகளைச் சரிசெய்யாமல் பிழையுடன் வெளியேறிவிடும்.

அந்தப் பிழை ஒரு தொந்தரவு அல்ல, அது ஒரு சிறப்பம்சம். ஒரு dependency மாற்றம் என்பது யாரோ ஒருவரால் சரிபார்க்கப்பட்ட கமிட் மூலம் மட்டுமே வர வேண்டும், மாறாக 02:00 மணிக்கு நடக்கும் ஒரு deploy-ன் பக்கவிளைவாக வரக்கூடாது என்பதே இதன் பொருள்.

ஒவ்வொரு fetch-ன் போதும் integrity hash சரிபார்க்கப்படும். ஒரு tarball-ன் bytes பதிவு செய்யப்பட்ட hash-உடன் பொருந்தவில்லை என்றால், அது unpack செய்யப்படாமல் code EINTEGRITY பிழையுடன் install தோல்வியடையும். இது உங்களுக்கு என்ன பலனைத் தருகிறது என்பதைத் துல்லியமாகப் புரிந்துகொள்ளுங்கள்: lockfile-ல் குறிப்பிடப்பட்ட அதே கோப்புதான் உங்களுக்குக் கிடைத்துள்ளது என்பதை இது உறுதிப்படுத்துகிறது. இது checksums மூலம் பதிவிறக்கங்களைச் சரிபார்த்தல் உங்களுக்கு வழங்கும் அதே உத்தரவாதமாகும், அதே வரம்புகளையும் கொண்டது. அந்தப் பதிப்பு வெளியிடப்பட்டபோது அது தீங்கிழைக்கும் வகையில் இருந்ததா இல்லையா என்பதைப் பற்றி இது எதையும் கூறாது.

--omit=dev பற்றிய ஒரு விவரம்: அந்தப் packages இன்னும் resolve செய்யப்பட்டு lockfile-ல் எழுதப்படுகின்றன. அவை வட்டில் (disk) மட்டுமே வைக்கப்படுவதில்லை. வட்டில் குறைவான packages இருப்பது என்பது, குறைவான install scripts மற்றும் runtime-ல் குறைவான code மட்டுமே ஏற்றப்படும் என்பதால், இதைச் செய்வது பயனுள்ளது. இது உங்கள் tree-லிருந்து ஒரு dependency-ஐ நீக்காது.

Install scripts-ஐ code-ஆகக் கருதி, அவற்றை எப்போது மறுக்க வேண்டும் என்பதை அறிக

Install scripts-ஐ முடக்கலாம். Project-ன் .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 எழுதச் செய்கிறது. இதனால் resolving range தவறுதலாக உங்கள் manifest-க்குள் செல்லாது.

இதனால் சில அம்சங்கள் செயலிழக்கும். எனவே இதை enable செய்வதற்கு முன் அதன் விளைவுகளை அறிந்திருக்க வேண்டும். Native addon-ஐ compile செய்யும் அல்லது prebuilt binary-ஐ download செய்யும் packages, அந்தப் பணியை install script-ல் செய்கின்றன. Scripts முடக்கப்பட்ட நிலையில் install வெற்றிகரமாக முடியும். ஆனால் பின்னர் runtime-ல், binding file-ஐ load செய்ய முடியாத module என்ற error தோன்றும். இதற்கான தீர்வு allowlist ஆகும்:

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

npm rebuild <package> அந்த ஒரு package-க்கான build scripts-ஐ இயக்குகிறது. --ignore-scripts=false கட்டாயமானது. npm rebuild, நீங்கள் இப்போது commit செய்த ignore-scripts=true-ஐ .npmrc-ல் மதிக்கிறது. இந்த override இல்லாமல், அது package-ன் binaries-ஐ link செய்யும்; scripts எதையும் இயக்காது. இதன் மூலம், நீங்கள் ஒருபோதும் சந்திக்காத சில நூறு package maintainers-க்கு blanket execute permission வழங்குவதற்குப் பதிலாக, ஒவ்வொரு package-க்கும் தனித்தனியாக முடிவு செய்துள்ளீர்கள்.

நீங்கள் npm 12 பயன்படுத்தினால், இந்த allowlist ஏற்கனவே built in ஆக இருக்கும். npm approve-scripts better-sqlite3 approval-ஐ package.json-ன் allowScripts field-ல் பதிவு செய்கிறது. Approval பெறாத dependency scripts warning-உடன் skip செய்யப்படும். npm rebuild அதே list-ஐச் சரிபார்க்கிறது. ஆகவே npm 12-ல் மேலே உள்ள rebuild-க்கும் அந்த approval தேவைப்படும். Commit செய்யப்பட்ட ignore-scripts=true, allowScripts policy-ஐ முழுமையாக override செய்கிறது.

தற்போது அந்த permission grant எவ்வளவு விரிவாக உள்ளது என்பதைப் பார்க்க, npm-ஐ கேட்கவும்:

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

இது installed tree-ல் postinstall script கொண்டுள்ள ஒவ்வொரு package-ஐயும் அச்சிடும். வழக்கமான application-ல் இந்தப் பட்டியல் மக்கள் எதிர்பார்ப்பதைவிடச் சிறியதாக இருக்கும். இதுவே allowlist நடைமுறைக்கு ஏற்றதாக இருப்பதற்கான காரணம்.

build செயல்முறையையும் network traffic-ஐ வழங்கும் process-ஐயும் பிரிக்கவும்

deploy user, node_modules-ல் எழுத வேண்டியிருக்கும். HTTP requests-க்கு பதிலளிக்கும் process-க்கு அது தேவையில்லை. இரண்டும் ஒரே account ஆக இருந்தால், install நேரத்தில் இயங்கும் code, users-க்கு service வழங்கும் code-ஐ மாற்ற முடியும். Runtime-ல் இயங்கும் code-க்கும் அதையே மாற்ற முடியும்.

அவற்றைப் பிரிக்கவும். ஒரு user ஆக build செய்யவும்; மற்றொரு user ஆக service வழங்கவும். service வழங்கும் account-க்கு served 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, /dev, /proc, /sys மற்றும் ReadWritePaths-ல் நீங்கள் குறிப்பிடும் இடங்களைத் தவிர, இந்த service-க்கான முழு file system-ஐ read-only ஆக mount செய்கிறது. எனவே application, node_modules-ல் எழுத முயன்றால் EROFS: read-only file system ஏற்படும். இதை உங்கள் சொந்த logs-ல் சுமார் ஒரு நிமிடத்தில் சென்று மீண்டும் உருவாக்கிப் பார்க்கலாம். NoExecPaths, எழுதக்கூடிய upload directory-ஐ கையாள்கிறது. Service அங்கு files எழுதலாம்; ஆனால் அவற்றை execute செய்ய kernel மறுக்கும். இந்த option-க்கு systemd 248 அல்லது அதற்குப் புதிய version தேவை. Ubuntu 24.04, version 255-ஐ வழங்குகிறது.

இந்த unit file-ல் இரண்டு சிக்கல்கள் உள்ளன. முதலில், MemoryDenyWriteExecute=yes-ஐ சேர்க்க வேண்டாம். பெரும்பாலான systemd hardening lists-ல் இது இடம்பெறும். ஆனால் இது Node தொடங்குவதைத் தடுக்கிறது. காரணம், V8 runtime-ல் JavaScript-ஐ machine code-ஆக compile செய்கிறது; அதற்கு writable மற்றும் executable ஆகிய இரண்டாகவும் இருக்கும் pages தேவை. இரண்டாவதாக, ExecStart path-ஐ command -v node-ல் இருந்து எடுக்கவும். Node, version manager மூலம் நிறுவப்பட்டிருந்தால், அது deploy user's home directory-க்குள் இருக்கும். ProtectHome=yes அந்த directory-ஐ service-க்கு மறைத்து விடும். 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-உடன் பட்டியலிடுகிறது. இதன் மூலம் default நிலையில் உள்ள settings எவை என்பதைப் பார்க்கலாம். touch, Permission denied-உடன் தோல்வியடைய வேண்டும். ஏனெனில் nodeapp, current-ன் கீழ் எதற்கும் owner அல்ல. அது வெற்றியடைந்தால், file ownership தவறாக உள்ளது. systemd settings அதை மறைமுகமாகச் சமாளிக்கின்றன.

EnvironmentFile பற்றி ஒரு குறிப்பு: systemd, User=nodeapp-க்கு மாறுவதற்கு முன் அதை root ஆகப் படிக்கிறது. எனவே அந்த file, mode 600 உடன் root:root ஆக இருக்கலாம். Application-க்கு variables தொடர்ந்து கிடைக்கும். nodeapp ஆக shell அணுகல் உள்ள எவரும் அவற்றை /proc/<pid>/environ-ல் இருந்து படிக்க முடியும். எனவே இது secret-ஐ சேமிக்கப்பட்ட நிலையில் பாதுகாக்கிறது; இயங்கிக்கொண்டிருக்கும் process-ஐ அல்ல.

build environment-இல் deploy credentials-ஐ வைக்காதீர்கள்

Install scripts environment-ஐப் பெறுகின்றன. நீங்கள் எங்கு 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 செய்ய முடியாது. 9 December 2025 அன்று npm அனைத்து 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 செய்வது கட்டாயமானால், deploy user ஆக deliberately narrow environment-ல் build செய்யவும். Runtime secrets-ஐ /etc/nodeapp/env-ல் வைத்திருக்கவும்; அதை deploy படிக்க முடியாது. நீங்களே host செய்யும் build automation-க்கும் இதே காரணம் பொருந்தும்: self-hosted GitHub Actions runner tokens-ஐ வைத்திருப்பதுடன், ஒவ்வொரு job-லும் வெளியிடப்பட்ட code-ஐ arbitrary முறையில் execute செய்கிறது. இதனால் சிறிய deployment-ல் அது அதிக மதிப்புள்ள machine ஆகிறது. நீங்கள் எழுதாத எந்த program-க்கும் உங்கள் முழு environment கிடைத்தால், அதையும் இதே வகையில் கருத வேண்டும். அதனால் AI agent-ன் environment-இலிருந்து secrets-ஐ விலக்கி வைப்பது இதே பிரச்சினையின் மற்றொரு வடிவமாகும்; நடுவில் இருப்பது வேறு program மட்டுமே.

நீங்கள் audit செய்ய முடியாததை Pin அல்லது Vendor செய்யவும்

Pinned dependency என்பது commit இல்லாமல் அதன் version மாற முடியாத dependency ஆகும். முழு dependency tree-க்காக commit செய்யப்பட்ட lockfile ஏற்கனவே இதைச் செய்கிறது. மேலும் இரண்டு சூழல்களுக்கு கூடுதல் நடவடிக்கை தேவை.

முதலாவது transitive dependencies. உங்கள் dependencies எவற்றை சார்ந்துள்ளன என்பதை நீங்கள் கட்டுப்படுத்த முடியாது. overrides-ஐ package.json-ல் பயன்படுத்தினால், முழு tree-யிலும் அந்த version கட்டாயப்படுத்தப்படும்:

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

அதைச் சேர்த்த பிறகு ஒருமுறை npm install இயக்கவும். இதனால் lockfile-ல் முடிவு பதிவு செய்யப்படும். பின்னர் இரண்டு files-ஐயும் commit செய்யவும்.

இரண்டாவது சூழல், நீங்கள் audit செய்யவும் நீக்கவும் முடியாத package ஆகும். அதை Vendor செய்யவும். npm pack registry வழங்கும் அதே tarball-ஐ download செய்கிறது. file: dependency உங்கள் local 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, அந்தத் தேதியில் அல்லது அதற்கு முன் published செய்யப்பட்ட versions மட்டும் பயன்படுத்தி tree-ஐ மீண்டும் உருவாக்கும். Dependencies-ஐ refresh செய்யும்போது தேதியை ஒன்று அல்லது இரண்டு வாரங்கள் பின்னுக்குத் தள்ளவும். இதனால் புதிய release வெளியான பிறகும் அது bad release என report செய்யப்படாத கால இடைவெளியைத் தவிர்க்கலாம். இது ஒரு blunt tool ஆகும்; ஏனெனில் உண்மையான security fixes-ஐயும் இது தாமதப்படுத்தும். Dependency ranges-ஐத் தீர்க்க இதைப் பயன்படுத்தவும். மாற்றங்களைப் படித்த பிறகு lockfile-ஐ commit செய்யவும். சமீபத்திய npm releases min-release-age-ஐயும் ஏற்கின்றன. இது நாட்களில் குறிப்பிடப்படும் rolling window ஆகும் (min-release-age=7, .npmrc-ல்). நகர்த்திக்கொண்டிருக்க வேண்டிய date இல்லாமல் இதே வேலையைச் செய்கிறது. npm மூலம் install செய்யும் command-line tools-க்கும் இதே அணுகுமுறை பொருந்தும். அவற்றை dependency-ஆக பயன்படுத்தாதபோது, pin செய்யப்படாத npx call அந்தக் காலை வெளியான எந்த version-ஐயும் fetch செய்யும். இரண்டு machines-லும் ஒரே code இயங்க வேண்டுமெனில் exact dsh version-ஐ pin செய்ய வேண்டும்.

நான் எந்த version-ஐ வெளியிட்டேன் என்பதை எப்படி அறிவது?

Git-ல் உள்ள lockfile எதை நிறுவியிருக்க வேண்டும் என்று குறிப்பிடுகிறது. வட்டில் (disk) உள்ளதே உண்மையில் நிறுவப்பட்டது. இரண்டாவது மட்டுமே உண்மையான ஆதாரமாகும்.

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

npm ls ஆனது node_modules-ஐ வாசிக்கிறது, எனவே இது lockfile-ல் குறிப்பிடப்பட்டதை விட, வட்டில் தற்போது என்ன உள்ளதோ அதையே காட்டுகிறது. node -e வரியானது நிறுவப்பட்ட manifest-ஐ அதன் path மூலம் வாசிக்கிறது. இது exports field மூலம் subpath imports தடுக்கப்பட்ட packages-க்கும் வேலை செய்யும், மேலும் எந்தவிதமான tree வரைபடமும் இன்றி ஒரு version-ஐ மட்டும் அச்சிடும்.

ஒப்பீட்டின் மற்ற பாதிக்கு, git-ஐ வாசிக்கவும்:

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

Deploy layout-ல் commit-ஐச் சேர்ப்பதன் மூலம் இரண்டிற்கும் இடையிலான தொடர்பை நிரந்தரமாக்குங்கள். /srv/nodeapp/releases/<short commit sha>-க்குள் release செய்து, /srv/nodeapp/current-ஐ ஒரு symlink மூலம் அதற்குச் சுட்டிக்காட்டுங்கள். "தற்போது என்ன இயங்குகிறது" என்ற கேள்விக்கான பதில் readlink /srv/nodeapp/current என்று அமையும், மேலும் இதை deploy செய்யாத ஒருவர் கூட 03:00 மணிக்குச் சரிபார்க்க முடியும்.

இறுதியாக, registry எதை உறுதிப்படுத்துகிறது என்று பாருங்கள்:

npm audit signatures

இது உங்கள் installed tree-ல் உள்ள packages-ன் registry signatures-ஐச் சரிபார்க்கிறது, மேலும் provenance attestations கொண்ட packages-ஐயும் சரிபார்க்கிறது. Provenance என்பது வெளியிடப்பட்ட tarball-ஐ அதை உருவாக்கிய பொதுவான continuous integration (CI) build-உடன் இணைக்கிறது. எனவே, சரிபார்க்கப்பட்ட attestation என்பது, குறியீட்டை (code) ஒரு தெரியாத laptop-க்கு பதிலாக, ஒரு குறிப்பிட்ட commit-க்கு உங்களால் பின்னோக்கித் தேட முடியும் என்பதைக் குறிக்கிறது. அனைத்து packages-க்கும் இது பொருந்தாது என்பதால், attestation இல்லை என்றால் அதை "தகவல் இல்லை" என்று எடுத்துக்கொள்ள வேண்டுமே தவிர, "தவறான package" என்று கருதக்கூடாது.

தவறான release உங்கள் server-ஐ அடைந்த பிறகு செய்ய வேண்டியவை

எது இயங்கியது மற்றும் எந்த user-ஆக இயங்கியது என்பதிலிருந்து உங்கள் ஆய்வைத் தொடங்குங்கள்.

நிறுவலின் போது code இயங்கியிருந்தால், build user-ஆல் படிக்கக்கூடிய அனைத்தும் சமரசத்திற்கு உள்ளானதாகக் கருதுங்கள். registry token, அந்த home directory-ல் உள்ள SSH keys, cloud credentials மற்றும் அந்த shell-ல் export செய்யப்பட்ட அனைத்து secret-களையும் மாற்றிவிடுங்கள் (rotate). ஒரு கோப்பு படிக்கப்படவில்லை என்பதை உங்களால் நிரூபிக்க முடியாது என்பதால், அவற்றை மாற்றுவதே சரியான தீர்வாகும்.

ஒரு locked-down service account-ன் கீழ் runtime-ல் code இயங்கியிருந்தால், பாதிப்புக்குள்ளான பரப்பு மிகக் குறைவு: application-ன் environment variables மற்றும் அதன் network access மூலம் எட்டக்கூடியவை மட்டுமே. VPS-ல் unprivileged users-ஆக services-ஐ இயக்குவதற்கான முழுமையான வாதமும் இதுவே. இது பாதிப்பைத் தடுக்காது. மாறாக, அந்த பாதிப்பு machine-ன் எவ்வளவு பகுதியைச் சென்றடையும் என்பதையும், restart செய்த பிறகும் அது நீடிக்குமா என்பதையும் இது தீர்மானிக்கிறது.

அதன்பிறகு, கோப்புகளைச் சுத்தம் செய்வதற்குப் பதிலாக, மீண்டும் உருவாக்குங்கள் (rebuild). node_modules-ஐ நீக்குங்கள், பாதிக்கப்பட்ட package-ஐ package.json-ல் தவறான version-க்குக் கீழே pin செய்யுங்கள், lockfile-ஐப் புதுப்பிக்க npm install-ஐ ஒருமுறை இயக்குங்கள், அதை commit செய்யுங்கள், பிறகு npm ci மூலம் deploy செய்யுங்கள். ஏற்கனவே உள்ள கோப்பு அமைப்பை (tree) அங்கேயே வைத்துச் சரிசெய்யாதீர்கள். ஒரு install script எதையெல்லாம் மாற்றியது என்பதை உங்களால் துல்லியமாகக் கணக்கிட முடியாது.

பாதிப்பு நிகழ்ந்த கால அளவையும் குறித்துக்கொள்ளுங்கள்: அந்த version-ஐப் பதிவிறக்கியிருக்கக்கூடிய முதல் deploy மற்றும் அதை நீக்கிய deploy. அந்த இடைவெளிதான் எந்த logs-ஐப் படிக்க வேண்டும் என்பதை உங்களுக்குத் தெரிவிக்கும். உங்கள் releases-க்கு commit-களின் பெயர்களை வைத்தால் மட்டுமே இந்தத் தகவலை உங்களால் பெற முடியும்.

இவற்றில் எதுவும் சரிசெய்யாதவை

Lockfile ஒன்று dependency-ஐ பாதுகாப்பானதாக மாற்றாது. அந்த dependency-ஐ ஏற்றுக்கொண்ட தருணத்தை, deploy-ன் பக்கவிளைவாக விடாமல், தேதி குறிப்பிடப்பட்டு மதிப்பாய்வு செய்யப்பட்ட முடிவாக மாற்றுகிறது. மேலே கூறப்பட்ட ஒவ்வொரு நடைமுறையும் இதே மாற்றத்தையே செய்கிறது: எதிர்பாராத நிகழ்வைத் தேர்வாக மாற்றுகிறது.

npm audit இங்கு பாதுகாப்பு நடவடிக்கையாகாது. இது உங்கள் tree-ஐ வெளியிடப்பட்ட vulnerability-களின் database-உடன் ஒப்பிடுகிறது. ஆகவே ஏற்கனவே வெளியிடப்பட்டு பெயரிடப்பட்ட பிரச்சினைகளை மட்டுமே கண்டறியும். Supply-chain attack, பயனுள்ளதாக இருக்கும் முழுக் காலத்திலும் பெயரிடப்படாததாகவே இருக்கும். பழைய, அறியப்பட்ட bugs-க்காக npm audit-ஐ இயக்கலாம். ஆனால் நான்கு மணி நேரத்திற்கு முன்பு release செய்யப்பட்ட release குறித்து இதிலிருந்து எந்தத் தகவலையும் எதிர்பார்க்க வேண்டாம்.

இந்த guide-ல் உள்ள எந்த tool-ஐவிடவும் dependency count-ஐக் குறைப்பது அதிகம் உதவும். ஆனால் யாரும் வழங்க விரும்பாத ஆலோசனையும் இதுவே. நீங்கள் சேர்க்காத ஒவ்வொரு package-மும், உங்கள் சார்பாக phish செய்ய முடியாத மேலும் ஒரு publisher-ஐ உருவாக்குகிறது. உங்கள் deploy user ஆக ஒருபோதும் இயங்காத மேலும் ஒரு install script-ஐயும் அது நீக்குகிறது.

இவை npm-க்கு மட்டும் உரியவை அல்ல. இதே நான்கு வடிவங்கள் PyPI, RubyGems, container images மற்றும் உங்கள் distribution-ன் package manager ஆகியவற்றுக்கும் பொருந்தும். npm-ல் இந்தப் பிரச்சினை அதிகமாகத் தெரிகிறது. காரணம், அதன் trees மிகவும் ஆழமானவை; மேலும், பெரும்பாலான servers இயக்கும் npm, install scripts-ஐ default-ஆக இயக்குகிறது. நீங்கள் ஏற்கனவே இயக்கும் tool-ஐ நீட்டிக்கும் எதுவும் இதே பிரச்சினையைப் பெறும். அதனால்தான் ஒரு dsh plugin-ஐ install செய்வதற்கு முன் அது எவற்றை அணுக முடியும் என்பதை அறிதல், postinstall script-ஐப் படிப்பது போன்ற அதே ஆய்வாகும். இதில் உங்கள் deploy user-ன் permissions இடத்தில் உங்கள் agent-ன் permissions இருக்கும். சுற்றியுள்ள machine-ல் எவ்வளவு பகுதியை நீங்கள் பாதுகாக்க வேண்டும் என்பது அது எங்கு இயங்குகிறது என்பதைக் சார்ந்தது. இது VPS hosting பாதுகாப்பானதா என்ற விரிவான கேள்வியின் ஒரு பகுதியாகும்.

FAQ

npm ci பயன்படுத்துவதால் compromise செய்யப்பட்ட npm package-இலிருந்து நான் பாதுகாக்கப்படுவேனா?

உங்கள் அறிவில்லாமல் version மாறுவதை இது தடுக்கிறது. npm ci, package-lock.json பதிவுசெய்துள்ளதைத் துல்லியமாக install செய்கிறது. ஒவ்வொரு tarball-ஐயும் அதன் sha512 integrity hash-க்கு எதிராகச் சரிபார்க்கிறது. package.json மற்றும் lockfile ஆகியவற்றுக்கு இடையே முரண்பாடு இருந்தால், அந்த வேறுபாட்டைத் தானாகத் தீர்க்காமல் error-உடன் நிற்கிறது. Pinned version பாதுகாப்பானதா என்பதை இது தெரிவிக்காது. Malicious version-ஐ lockfile-ல் pin செய்து commit செய்தால், நீங்கள் நிர்வகிக்கும் ஒவ்வொரு server-லும் ஒவ்வொரு முறையும் npm ci அதே version-ஐத் துல்லியமாக install செய்யும்.

எல்லாவற்றுக்கும் ignore-scripts=true அமைக்க வேண்டுமா?

முதலில் அதை அமைக்கவும். பின்னர் தேவையானவற்றை allowlist செய்யவும். Project-ன் .npmrc-ல் ignore-scripts=true அமைத்தால் dependency install scripts இயங்காது. இதனால் தவறான package-இலிருந்து உங்கள் deploy user-ன் credentials-க்கு செல்லும் மிக நேரடியான பாதை நீக்கப்படுகிறது. Native addon-ஐ compile செய்யும் அல்லது prebuilt binary-ஐ fetch செய்யும் packages-க்கு அவற்றின் install scripts உண்மையில் தேவைப்படலாம். Scripts முடக்கப்பட்டால், அவை install நேரத்தில் அல்லாமல் runtime-ல் missing binding file காரணமாக பின்னர் தோல்வியடையும். npm ci --ignore-scripts இயக்கவும். நீங்கள் நம்பத் தீர்மானித்த சில packages-க்கு மட்டும் பின்னர் npm rebuild <package> --ignore-scripts=false இயக்கவும். இல்லையெனில் npm rebuild, .npmrc setting-ஐ மதித்து எந்த script-ஐயும் இயக்காது. உண்மையில் எத்தனை packages உள்ளன என்பதை npm query ":attr(scripts, [postinstall])" காட்டும்.

எனது server உண்மையில் எந்த 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-ஐ ஏற்கனவே report செய்யப்பட்ட vulnerabilities அடங்கிய database-உடன் ஒப்பிடுகிறது. ஆகவே ஏற்கனவே வெளியிடப்பட்டு identifier வழங்கப்பட்ட issues-ஐ மட்டுமே அது கண்டறியும். Malicious release ஒன்று வெளியிடப்பட்ட பிறகு, அதை install செய்வது முக்கியமான அந்த சில மணி நேரங்கள் அல்லது நாட்களில் report செய்யப்படாமல் இருக்கலாம். npm audit signatures மிகவும் பயனுள்ள command ஆகும். இது நீங்கள் install செய்த tree முழுவதும் registry signatures-ஐச் சரிபார்க்கிறது. Publisher வழங்கிய இடங்களில் provenance attestations-ஐயும் சரிபார்க்கிறது. இதன் மூலம் tarball public build-இலிருந்து வந்ததா அல்லது தெரியாத machine-இலிருந்து வந்ததா என்பதை அறியலாம்.

Attack install நேரத்தில் நடந்தால், 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's own environment மற்றும் அதன் database வரையிலேயே நிற்கும். Accounts-ஐப் பிரித்துப் பயன்படுத்துவதால் network traffic-ஐ வழங்கும் process-ஆல் node_modules-ஐ rewrite செய்ய முடியாது. எனவே runtime compromise அடுத்த restart-ல் நீங்கிவிடும்; அது நிரந்தரமாக மாறாது.

இந்தக் கட்டுரை பயனுள்ளதாக இருந்ததா?