SSD Nodes Learn Hosting plans →
คู่มือ Matt Connorโดย Matt Connor · อัปเดตเมื่อ 2026-10-23

วิธีป้องกัน npm Supply-Chain Attack บน Node.js Server

เรียนรู้วิธีที่มัลแวร์เข้าถึง Node.js บน VPS ผ่าน malicious patch, postinstall scripts และ typosquatting พร้อมแนวทางการ deploy เพื่อบล็อกการติดตั้งแพ็กเกจอันตราย

การโจมตีผ่านห่วงโซ่อุปทานของ npm บนเซิร์ฟเวอร์ของคุณ

การโจมตีผ่านห่วงโซ่อุปทานของ npm เข้าถึงเซิร์ฟเวอร์ของคุณผ่านแพ็กเกจที่คุณเลือกติดตั้ง โดยไม่มีการเปิดพอร์ตหรือขั้นตอนการเจาะระบบเข้ามาเกี่ยวข้อง npm จะติดตั้งโค้ด และการติดตั้งโค้ดก็คือการรันโค้ด ดังนั้นแอปพลิเคชัน Node ขนาดเล็กจึงดึงแพ็กเกจหลายร้อยรายการที่คุณไม่เคยอ่านโค้ดเข้ามา และแพ็กเกจใดก็ตามในนั้นสามารถออกเวอร์ชันใหม่ได้ทุกเมื่อ

การ deploy ของคุณจะดึงเวอร์ชันที่เป็นอันตรายเข้ามาเพราะคำสั่งติดตั้งของคุณระบุให้ใช้เวอร์ชันล่าสุดที่ตรงตามเงื่อนไข โค้ดดังกล่าวจะทำงานด้วยสิทธิ์ของผู้ที่รันคำสั่งติดตั้ง ทุกสิ่งที่ตามมาหลังจากนี้ล้วนเป็นผลลัพธ์จากสองประโยคข้างต้น

รูปแบบการโจมตีเหล่านี้ถูกจัดลำดับตามความถี่ที่ส่งผลกระทบต่อบุคคลที่ deploy แอป Node หนึ่งแอปไปยัง VPS หนึ่งเครื่อง ลำดับนี้ไม่ใช่ลำดับที่บริษัทขนาดใหญ่ใช้ เนื่องจากบริษัทขนาดใหญ่มี registry ภายใน มีทีมตรวจสอบ และมี mirror ของ public registry ส่วนคุณมีเพียงสคริปต์สำหรับ deploy เท่านั้น

รูปแบบที่ 1: บัญชีผู้ดูแลถูกบุกรุกและเผยแพร่แพตช์

npm registry ไม่อนุญาตให้ผู้ใดเปลี่ยนแปลงเนื้อหาของเวอร์ชันที่มีอยู่แล้ว ผู้โจมตีที่ใช้วิธีฟิชชิงผู้ดูแลหรือขโมย publish token จึงไม่สามารถเขียนทับ 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 เดียวกันที่ถูก deploy สองครั้งในช่วงบ่ายวันเดียวกัน อาจติดตั้งชุดโค้ดที่แตกต่างกันได้ ช่องว่างนี้คือพื้นที่ที่ถูกโจมตีได้ โดยที่คุณไม่จำเป็นต้องถูกบุกรุกเครื่องเลยแม้แต่น้อย

การเผยแพร่ซอฟต์แวร์ที่เป็นอันตรายมักจะถูกรายงานและลบออก แต่การลบจะเกิดขึ้นหลังจากที่มีคนติดตั้งไปแล้ว ใครก็ตามที่ deploy ในช่วงเวลานั้นจะมีโค้ดดังกล่าวอยู่ในดิสก์ ระบบ pipeline ที่ทำการระบุเวอร์ชันจากช่วง (range) ในทุกครั้งที่รัน จะเข้าสู่ช่วงเวลาเสี่ยงนี้โดยอัตโนมัติสัปดาห์ละหลายครั้ง โดยที่ไม่มีใครตัดสินใจให้เกิดขึ้น

รูปแบบที่ 2: สคริปต์ติดตั้งทำงานในฐานะผู้ใช้ที่ดำเนินการ deploy

package.json ของแพ็กเกจสามารถประกาศ preinstall, install, postinstall และ prepare ไว้ในบล็อก scripts ได้ โดย npm จะเรียกใช้งานสคริปต์เหล่านี้ระหว่างการติดตั้ง สคริปต์ดังกล่าวไม่มีการทำ sandbox และไม่มีผู้ตรวจสอบความปลอดภัย สคริปต์เหล่านี้คือคำสั่ง shell ที่ทำงานในฐานะผู้ใช้ที่พิมพ์คำสั่งติดตั้ง โดยทำงานใน home directory ของผู้ใช้รายนั้น พร้อมสิทธิ์การเข้าถึงเครือข่ายและ environment ทั้งหมดของ shell นั้น

npm 12 ซึ่งปล่อยออกมาเมื่อวันที่ 8 กรกฎาคม 2026 ได้เปลี่ยนค่าเริ่มต้นดังกล่าว โดยจะบล็อกสคริปต์ติดตั้งของ dependency เว้นแต่ฟิลด์ allowScripts ใน package.json ของโปรเจกต์จะอนุญาตไว้ ณ วันที่ 12 ตุลาคม 2026 ยังไม่มี Node.js รุ่นใดที่มาพร้อมกับ npm 12 (Node.js 26.11.1 มาพร้อมกับ npm 11.20.0) ดังนั้นหากคุณไม่ได้อัปเกรด npm ด้วยตนเอง npm บนเซิร์ฟเวอร์ของคุณจะยังคงเรียกใช้งานสคริปต์เหล่านี้ทั้งหมด

ดังนั้น คำถามที่สำคัญไม่ใช่ว่าแพ็กเกจสามารถทำอะไรได้บ้าง แต่คือผู้ใช้รายนั้นสามารถอ่านไฟล์ใดได้บ้าง บนเครื่องสำหรับ deploy ทั่วไป คำตอบจะรวมถึง ~/.npmrc ที่เก็บ registry token, ~/.ssh/id_ed25519 ที่ใช้เป็น deploy key สำหรับ SSH (secure shell), ~/.aws/credentials, ~/.docker/config.json และตัวแปรทุกตัวที่ถูก export ไว้ใน shell ซึ่งมักเป็นที่อยู่ของ DATABASE_URL

payload ลักษณะนี้ไม่จำเป็นต้องมีการคงอยู่ (persistence) หรือการยกระดับสิทธิ์ (privilege escalation) มันเพียงแค่อ่านไฟล์บางไฟล์ ส่งไปยังโฮสต์ผ่าน HTTPS แล้วจบการทำงานด้วยสถานะ 0 คุณจะไม่เห็นสิ่งผิดปกติใดๆ เนื่องจาก npm ซ่อน output ของสคริปต์ติดตั้งไว้เป็นค่าเริ่มต้น ให้ปิดการตั้งค่านี้เพื่อดูว่ามีอะไรทำงานอยู่จริง:

npm ci --foreground-scripts

foreground-scripts จะใช้ standard input, output และ error ร่วมกับกระบวนการของ npm ดังนั้น build script จะแสดงผลลัพธ์ลงใน terminal ของคุณโดยตรง แทนที่จะเก็บไว้ใน buffer ที่ npm จะทิ้งไปเมื่อการติดตั้งเสร็จสมบูรณ์

รูปแบบที่ 3: typosquat และชื่อที่คุณพิมพ์ผิดไปเล็กน้อย

Typosquat คือแพ็กเกจที่ถูกเผยแพร่ภายใต้ชื่อที่ใกล้เคียงกับแพ็กเกจยอดนิยม โดยรอให้ผู้ใช้พิมพ์คำสั่งติดตั้งผิดหรือวางคำสั่งที่ผิดพลาด กลไกนี้อยู่ที่ตัวคำสั่ง ไม่ใช่ตัวโค้ด ดังนั้น lockfile จึงไม่ช่วยคุณในกรณีนี้ เพราะเมื่อคุณเพิ่มชื่อที่ผิดเข้าไปเพียงครั้งเดียว lockfile จะทำการล็อกเวอร์ชันนั้นไว้อย่างซื่อตรงตั้งแต่นั้นเป็นต้นไป

รูปแบบที่มักจะสร้างปัญหาให้กับทีมมากกว่ารายบุคคลคือ dependency confusion หากแพ็กเกจภายในของคุณชื่อ billing-utils และอยู่บน registry ส่วนตัว แต่ไม่มีแพ็กเกจชื่อ billing-utils อยู่บน registry สาธารณะ ใครก็ตามสามารถเผยแพร่แพ็กเกจชื่อนั้นขึ้นไปได้ npm จะทำการตรวจสอบชื่อที่ไม่มี scope กับ registry สาธารณะที่เป็นค่าเริ่มต้น ทำให้สำเนาบน registry สาธารณะอาจถูกดึงมาใช้แทน วิธีแก้ไขคือการใช้ scope ที่คุณเป็นเจ้าของร่วมกับการกำหนด registry mapping สำหรับ scope นั้นในไฟล์ .npmrc:

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

ตอนนี้ @yourorg/billing-utils จะถูกดึงมาจากโฮสต์นั้นเสมอ เพราะการตรวจสอบ scope-to-registry mapping จะเกิดขึ้นก่อนการตรวจสอบ registry หลัก ส่วนชื่อภายในที่ไม่มี scope จะไม่มีการทำ mapping จึงไม่มีการป้องกันในส่วนนี้

ก่อนที่คุณจะเพิ่ม dependency ใหม่ ให้ตรวจสอบที่ตัวแพ็กเกจแทนที่จะดูเพียงแค่ป้ายแสดงจำนวนการดาวน์โหลด:

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

แพ็กเกจที่เพิ่งสร้างเมื่อเดือนที่แล้วและเผยแพร่โดยบัญชีที่คุณไม่สามารถเชื่อมโยงไปยัง repository สาธารณะได้นั้น มีความเสี่ยงที่แตกต่างจากแพ็กเกจที่มีประวัติการใช้งานมานานหกปี แม้ว่าข้อเท็จจริงทั้งสองอย่างนี้จะไม่ใช่เครื่องพิสูจน์ความปลอดภัย แต่ทั้งคู่ก็เป็นสิ่งที่ตรวจสอบได้ง่าย

รูปแบบที่ 4: dependency ที่เจ้าของเปลี่ยนไปโดยไม่มีการแจ้งเตือน

ผู้ดูแลโครงการมักมีการส่งมอบแพ็กเกจต่อกัน เมื่อคนหนึ่งหมดไฟและมีคนแปลกหน้าเสนอตัวเข้ามาช่วยเหลือ สิทธิ์ในการเผยแพร่จะถูกโอนย้ายโดยที่โครงการที่พึ่งพาแพ็กเกจนั้นไม่ได้รับทราบข้อมูลใดๆ ทั้งสิ้น แม้จะไม่มีการบุกรุกระบบเกิดขึ้น แต่ความเชื่อมั่นที่คุณเคยให้ไว้ในปี 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

รูปแบบแรกจะแสดงเฉพาะชื่อไฟล์ที่มีการเปลี่ยนแปลง ซึ่งรวดเร็วพอที่จะทำได้ทุกครั้งที่มีการอัปเกรดแพ็กเกจที่คุณให้ความสำคัญ การอัปเดตแบบ patch release ที่มีการแก้ไข build script, การเพิ่มไฟล์ที่ root ของแพ็กเกจ หรือการแก้ไขบล็อก scripts เป็นสิ่งที่ควรตรวจสอบอย่างละเอียดก่อนที่จะนำไปใช้งานบนเซิร์ฟเวอร์ของคุณ

การสร้างโปรเจกต์จาก lockfile ที่คอมมิตไว้ด้วย npm ci

package-lock.json จะบันทึกเวอร์ชันที่แน่นอนของทุกแพ็กเกจใน dependency tree, URL ต้นทาง, ค่า sha512 integrity hash ของแต่ละ tarball และระบุว่าแพ็กเกจใดเป็นตัวเรียกใช้งาน ให้คอมมิตไฟล์นี้ไว้ เพราะเป็นไฟล์เดียวที่ยืนยันได้ว่าคุณได้ทดสอบอะไรไปจริง ๆ

จากนั้นให้ติดตั้งด้วย npm ci เสมอ ห้ามใช้ npm install บนเครื่องใดก็ตามที่ไม่ใช่เครื่องของนักพัฒนา:

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

npm ci แตกต่างจาก npm install ในประเด็นสำคัญทั้งหมดนี้ โดย npm ci จำเป็นต้องมี lockfile อยู่ก่อนเสมอ มันจะลบโฟลเดอร์ node_modules ที่มีอยู่เดิมทิ้งก่อนเริ่มการทำงาน เพื่อป้องกันไม่ให้ไฟล์ตกค้างจากการ deploy ครั้งก่อนหลุดรอดเข้ามาในการ deploy ครั้งนี้ นอกจากนี้มันจะไม่เขียนข้อมูลลงใน package.json หรือแก้ไข lockfile ดังนั้นการติดตั้งจะไม่ทำให้เวอร์ชันของแพ็กเกจขยับขึ้นโดยที่คุณไม่รู้ตัว หาก lockfile และ package.json ไม่ตรงกัน ระบบจะหยุดทำงานและแสดงข้อผิดพลาดแทนที่จะพยายามแก้ไขความแตกต่างนั้นเอง

ข้อผิดพลาดดังกล่าวคือฟีเจอร์ ไม่ใช่เรื่องน่ารำคาญ เพราะมันหมายความว่าการเปลี่ยนแปลง dependency จะต้องเกิดขึ้นผ่านการคอมมิตที่มีคนตรวจสอบแล้วเท่านั้น ไม่ใช่ผลข้างเคียงที่เกิดขึ้นโดยไม่ตั้งใจระหว่างการ deploy ตอนตี 2

ค่า integrity hash จะถูกตรวจสอบทุกครั้งที่มีการดึงข้อมูล หาก tarball ใดมีไบต์ไม่ตรงกับ hash ที่บันทึกไว้ การติดตั้งจะล้มเหลวด้วย code EINTEGRITY แทนที่จะแตกไฟล์ออกมา เพื่อให้เข้าใจชัดเจนว่าสิ่งนี้ช่วยคุณได้อย่างไร: มันพิสูจน์ว่าไฟล์ที่คุณได้รับคือไฟล์เดียวกับที่ lockfile ระบุไว้ ซึ่งเป็นการรับประกันแบบเดียวกับที่ การตรวจสอบไฟล์ดาวน์โหลดด้วย checksum มอบให้ แต่ก็มีข้อจำกัดในลักษณะเดียวกัน คือมันไม่ได้บอกว่าเวอร์ชันที่ถูกระบุไว้นั้นมีเจตนาร้ายแฝงมาตั้งแต่ตอนเผยแพร่หรือไม่

รายละเอียดเพิ่มเติมเกี่ยวกับ --omit=dev: แพ็กเกจเหล่านั้นจะยังคงถูก resolve และบันทึกลงใน lockfile เพียงแต่จะไม่ถูกติดตั้งลงบนดิสก์ การมีแพ็กเกจบนดิสก์น้อยลงหมายถึงการรัน install script น้อยลงและมีการโหลดโค้ดขณะรันไทม์น้อยลง จึงเป็นสิ่งที่ควรทำ ทั้งนี้การตั้งค่าดังกล่าวไม่ได้เป็นการลบ dependency ออกจาก tree ของคุณแต่อย่างใด

จัดการสคริปต์ติดตั้งเสมือนซอร์สโค้ดและรู้วิธีปฏิเสธการทำงาน

คุณสามารถปิดการทำงานของสคริปต์ติดตั้งได้ โดยเพิ่มการตั้งค่านี้ลงใน .npmrc ของโปรเจกต์และ commit ไฟล์นี้ไว้คู่กับ lockfile:

ignore-scripts=true
save-exact=true

ignore-scripts=true จะหยุดไม่ให้ npm เรียกใช้สคริปต์ที่ประกาศไว้ใน dependencies ส่วน save-exact=true จะทำให้ npm install some-lib เขียน 1.4.2 ลงใน package.json แทนที่จะเป็น ^1.4.2 เพื่อป้องกันไม่ให้ช่วงเวอร์ชันที่ระบุไว้หลุดเข้าไปใน manifest ของคุณโดยไม่ตั้งใจ

การตั้งค่านี้อาจทำให้บางอย่างใช้งานไม่ได้ คุณจึงควรทราบผลกระทบก่อนเปิดใช้งาน แพ็กเกจที่ต้องคอมไพล์ native addon หรือดาวน์โหลด prebuilt binary จะทำงานเหล่านั้นผ่านสคริปต์ติดตั้ง เมื่อปิดสคริปต์ การติดตั้งจะเสร็จสมบูรณ์ แต่ความผิดพลาดจะไปปรากฏในภายหลังขณะรันโปรแกรม ในรูปแบบของโมดูลที่ไม่สามารถโหลดไฟล์ binding ได้ วิธีแก้ไขคือการใช้รายการอนุญาต (allowlist):

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

npm rebuild <package> จะรันสคริปต์ build สำหรับแพ็กเกจนั้นเพียงตัวเดียว โดย --ignore-scripts=false เป็นสิ่งที่จำเป็นต้องมี เพราะ npm rebuild จะเคารพค่า ignore-scripts=true ที่คุณเพิ่ง commit ลงใน .npmrc และหากไม่มีการ override ตัว npm จะทำการเชื่อมโยงไฟล์ binary ของแพ็กเกจเท่านั้นโดยไม่รันสคริปต์ใดๆ เลย ตอนนี้คุณได้ตัดสินใจเลือกเป็นรายแพ็กเกจ แทนที่จะอนุญาตให้สิทธิ์การรันโค้ดแบบเหมาเข่งแก่คนแปลกหน้าหลายร้อยคนที่คุณไม่รู้จัก

หากคุณใช้ npm 12 รายการอนุญาตนี้จะถูกรวมไว้ในตัวโปรแกรมแล้ว โดย npm approve-scripts better-sqlite3 จะบันทึกการอนุมัติไว้ในฟิลด์ allowScripts ของ package.json สคริปต์ของ dependency ที่ไม่ได้รับอนุมัติจะถูกข้ามไปพร้อมกับคำเตือน และ npm rebuild ก็จะตรวจสอบรายการเดียวกันนี้ ดังนั้นใน npm 12 การ rebuild ตามตัวอย่างข้างต้นจึงจำเป็นต้องได้รับการอนุมัติเช่นกัน ทั้งนี้ ignore-scripts=true ที่ถูก commit ไว้จะ override นโยบายของ allowScripts ทั้งหมด

หากต้องการดูว่าปัจจุบันคุณได้ให้สิทธิ์การรันสคริปต์ไปมากน้อยเพียงใด ให้ใช้คำสั่ง npm ดังนี้:

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

คำสั่งนี้จะแสดงรายการแพ็กเกจทั้งหมดใน tree ที่ติดตั้งไว้ซึ่งมีสคริปต์ postinstall อยู่ ในแอปพลิเคชันทั่วไป รายการนี้มักจะสั้นกว่าที่หลายคนคาดคิด ซึ่งนั่นคือเหตุผลที่ทำให้การใช้รายการอนุญาตเป็นสิ่งที่ทำได้จริง

แยกขั้นตอนการ build ออกจากกระบวนการรับส่งข้อมูล

ผู้ใช้ที่ทำหน้าที่ deploy จำเป็นต้องมีสิทธิ์เขียนใน node_modules แต่กระบวนการที่ตอบสนองคำขอ HTTP ไม่จำเป็นต้องมีสิทธิ์ดังกล่าว หากทั้งสองส่วนใช้บัญชีผู้ใช้เดียวกัน โค้ดที่ทำงานระหว่างการติดตั้งอาจเขียนทับโค้ดที่ให้บริการผู้ใช้ของคุณได้ และโค้ดที่ทำงานขณะรันไทม์ก็สามารถเขียนทับได้เช่นกัน

ให้แยกส่วนออกจากกัน โดยใช้ผู้ใช้หนึ่งในการ build และอีกผู้ใช้หนึ่งในการให้บริการ พร้อมทั้งกำหนดให้ไดเรกทอรีที่ให้บริการเป็นแบบอ่านได้อย่างเดียวสำหรับบัญชีผู้ใช้ที่ให้บริการ:

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 จะทำการ mount ระบบไฟล์ทั้งหมดเป็นแบบอ่านได้อย่างเดียวสำหรับ service นี้ ยกเว้น /dev, /proc, /sys และรายการใดก็ตามที่คุณระบุไว้ใน ReadWritePaths ดังนั้นหากแอปพลิเคชันพยายามเขียนลงใน node_modules จะล้มเหลวด้วยข้อผิดพลาด EROFS: read-only file system ซึ่งคุณสามารถตรวจสอบและจำลองเหตุการณ์ได้ใน log ของคุณภายในเวลาไม่กี่นาที NoExecPaths จะครอบคลุมถึงไดเรกทอรีสำหรับอัปโหลดที่เขียนได้ โดย service สามารถเขียนไฟล์ลงไปได้แต่ kernel จะปฏิเสธการสั่งรันไฟล์เหล่านั้น ตัวเลือกนี้ต้องการ systemd เวอร์ชัน 248 หรือใหม่กว่า ซึ่ง Ubuntu 24.04 มาพร้อมกับเวอร์ชัน 255

มีกับดักสองประการใน unit file นี้ ประการแรก ห้าม เพิ่ม MemoryDenyWriteExecute=yes เข้าไป แม้ว่ามันจะปรากฏอยู่ในรายการ hardening ของ systemd ส่วนใหญ่ แต่มันจะทำให้ Node ไม่สามารถเริ่มทำงานได้ เนื่องจาก V8 ต้องคอมไพล์ JavaScript เป็น machine code ในขณะรันไทม์ ซึ่งจำเป็นต้องใช้หน่วยความจำที่ทั้งเขียนได้และสั่งรันได้ ประการที่สอง ให้ใช้พาธ ExecStart จาก command -v node หาก Node ถูกติดตั้งผ่านตัวจัดการเวอร์ชัน (version manager) มันจะอยู่ในโฮมไดเรกทอรีของผู้ใช้ที่ deploy ซึ่ง ProtectHome=yes จะซ่อนไดเรกทอรีนั้นจาก service ทำให้ unit ล้มเหลวทันทีด้วย status=203/EXEC พร้อมข้อความใน log ว่าไม่พบไฟล์ executable

ตรวจสอบผลลัพธ์แทนการเชื่อถือไฟล์เพียงอย่างเดียว:

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 ทั้งหมดพร้อมระดับความเสี่ยง เพื่อให้คุณเห็นว่าค่าใดที่ยังคงเป็นค่าเริ่มต้น touch ควรจะล้มเหลวด้วย Permission denied เนื่องจาก nodeapp ไม่ได้เป็นเจ้าของไฟล์ใดๆ ภายใต้ current หากคำสั่งทำงานสำเร็จ แสดงว่าการกำหนดความเป็นเจ้าของไฟล์ของคุณไม่ถูกต้อง และการตั้งค่าของ systemd กำลังปกปิดความผิดพลาดนั้นอยู่

ข้อควรทราบเกี่ยวกับ EnvironmentFile: systemd จะอ่านไฟล์นี้ในฐานะ root ก่อนที่จะเปลี่ยนสิทธิ์ไปเป็น User=nodeapp ดังนั้นไฟล์ดังกล่าวสามารถกำหนดสิทธิ์เป็น root:root ด้วยโหมด 600 ได้ โดยที่แอปพลิเคชันยังคงได้รับตัวแปรเหล่านั้นตามปกติ อย่างไรก็ตาม ผู้ที่มี shell ในฐานะ nodeapp ยังคงสามารถอ่านค่าเหล่านั้นได้จาก /proc/<pid>/environ ดังนั้นวิธีนี้จึงเป็นการป้องกันความลับในขณะที่จัดเก็บ (at rest) ไม่ใช่การป้องกันกระบวนการที่กำลังทำงานอยู่

เก็บข้อมูลยืนยันตัวตนสำหรับการ deploy ไว้นอกสภาพแวดล้อมการ build

สคริปต์ติดตั้งจะสืบทอดสภาพแวดล้อม (environment) มาด้วย ข้อเท็จจริงนี้ควรเป็นตัวกำหนดว่าคุณควร build ซอฟต์แวร์ที่ไหน

วิธีที่ปลอดภัยที่สุดคือการ build ในที่ที่ไม่ใช่เซิร์ฟเวอร์ production แล้วค่อยคัดลอกไดเรกทอรีที่เสร็จสมบูรณ์ข้ามไป เครื่องที่ใช้ build ควรเก็บเพียงแค่ registry token แบบอ่านอย่างเดียว (read-only) เท่านั้น โดยไม่มี SSH deploy key, cloud access key, รหัสผ่านฐานข้อมูล หรือข้อมูลล็อกอินของ container registry ใดๆ ทั้งสิ้น

npm token create --name=build-readonly --packages-and-scopes-permission=read-only --packages-all --expires=30

token แบบอ่านอย่างเดียวสามารถดึงแพ็กเกจได้แต่ไม่สามารถเผยแพร่ (publish) ได้ npm ได้ยกเลิกการใช้งาน classic token ทั้งหมดเมื่อวันที่ 9 ธันวาคม 2025 ดังนั้นนี่จึงเป็น granular access token โดย permission flag คือสิ่งที่ทำให้มันเป็นแบบอ่านอย่างเดียว npm เวอร์ชันปัจจุบันยังคงยอมรับ flag --read-only แบบเก่า แต่ npm token create จะไม่ส่ง flag ดังกล่าวไปยัง registry หาก token ถูกขโมยไปจากสภาพแวดล้อมการ build ความเสียหายที่เกิดขึ้นจะมีเพียงการเข้าถึงเพื่ออ่านแพ็กเกจที่ token นั้นครอบคลุมอยู่เท่านั้น

หากคุณจำเป็นต้อง build บนเซิร์ฟเวอร์ ให้ build ในฐานะผู้ใช้ deploy ที่มีสภาพแวดล้อมจำกัดอย่างตั้งใจ และเก็บความลับที่ใช้ขณะรันไทม์ (runtime secrets) ไว้ใน /etc/nodeapp/env ซึ่ง deploy ไม่สามารถอ่านได้ แนวคิดเดียวกันนี้ใช้กับระบบ build automation ที่คุณโฮสต์เอง: a self-hosted GitHub Actions runner จะถือครอง token และรันโค้ดที่เผยแพร่โดยใครก็ได้ในทุกงาน ซึ่งทำให้มันกลายเป็นเครื่องที่มีมูลค่าสูงที่สุดในระบบขนาดเล็ก โปรแกรมใดก็ตามที่คุณไม่ได้เป็นผู้เขียนแต่ได้รับสภาพแวดล้อมทั้งหมดของคุณไป จะถูกจัดอยู่ในหมวดหมู่เดียวกัน ซึ่งเป็นเหตุผลว่าทำไม การเก็บความลับไว้นอกสภาพแวดล้อมของ AI agent จึงเป็นปัญหาเดียวกันนี้เพียงแต่มีโปรแกรมอื่นเข้ามาอยู่ตรงกลางเท่านั้น

ตรึงเวอร์ชันหรือทำ vendor สำหรับสิ่งที่คุณตรวจสอบไม่ได้

Dependency ที่ถูกตรึง (pinned dependency) คือ dependency ที่เวอร์ชันจะไม่เปลี่ยนแปลงหากไม่มีการ commit ไฟล์ lockfile ที่ถูก commit ไว้จะทำหน้าที่นี้ให้กับ dependency ทั้งหมดใน tree อยู่แล้ว แต่มี 2 กรณีที่ต้องการการจัดการเพิ่มเติม

กรณีแรกคือ transitive dependencies คุณไม่สามารถควบคุมได้ว่า dependency ของคุณจะเรียกใช้ dependency ตัวใดต่อ overrides ใน package.json จะบังคับให้ใช้เวอร์ชันที่กำหนดไว้ในทุกจุดของ tree:

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

ให้รัน npm install หนึ่งครั้งหลังจากเพิ่ม dependency ดังกล่าว เพื่อให้ lockfile บันทึกผลลัพธ์ จากนั้นจึง commit ไฟล์ทั้งสอง

กรณีที่สองคือ package ที่คุณไม่สามารถตรวจสอบโค้ดได้และไม่สามารถเลิกใช้งานได้ ให้ใช้วิธีทำ vendor (vendor it) npm pack จะดาวน์โหลด tarball ฉบับเดียวกับที่ registry ให้บริการ และ dependency แบบ file: จะติดตั้งจากสำเนาที่คุณเก็บไว้:

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 ของคุณและไม่สามารถเปลี่ยนแปลงได้โดยที่คุณไม่รู้ตัว อย่างไรก็ตาม คุณจะต้องรับผิดชอบการอัปเดต package นี้ตลอดไป ดังนั้นให้ใช้วิธีนี้กับ package ขนาดเล็กที่ถูกทิ้งร้างซึ่งคุณจำเป็นต้องใช้เท่านั้น ไม่ควรใช้กับ web framework หลักของคุณ

นอกจากนี้ยังมีช่วงเวลาพัก (cooling-off period) ซึ่งไม่มีค่าใช้จ่ายเพิ่มเติม:

npm install --before=2026-08-01

ตัวเลือก before จะสร้าง tree ขึ้นใหม่โดยใช้เฉพาะเวอร์ชันที่ถูกเผยแพร่ในหรือก่อนวันที่ระบุ ให้ตั้งค่าถอยหลังไปหนึ่งหรือสองสัปดาห์เมื่อคุณรีเฟรช dependencies วิธีนี้จะช่วยให้คุณหลีกเลี่ยงช่วงเวลาที่ release ที่มีปัญหาถูกปล่อยออกมาแต่ยังไม่มีการรายงาน นี่เป็นเครื่องมือที่ค่อนข้างหยาบเพราะมันจะกั้นการอัปเดตด้านความปลอดภัยที่จำเป็นไปด้วย ให้ใช้เพื่อกำหนดช่วงเวอร์ชัน อ่านสิ่งที่เปลี่ยนแปลง แล้วจึง commit ไฟล์ lockfile npm เวอร์ชันใหม่ยังรองรับ min-release-age ซึ่งเป็นช่วงเวลาแบบ rolling window ในหน่วยวัน (min-release-age=7 ใน .npmrc) ซึ่งทำหน้าที่เดียวกันโดยไม่ต้องระบุวันที่เจาะจง สัญชาตญาณเดียวกันนี้ควรนำไปใช้กับเครื่องมือ command line ที่คุณติดตั้งจาก npm แทนการระบุเป็น dependency เพราะการเรียกใช้ npx โดยไม่ตรึงเวอร์ชันจะดึงเวอร์ชันล่าสุดที่เพิ่งปล่อยออกมาในเช้าวันนั้น และการ ตรึงเวอร์ชัน dsh ให้แน่นอน คือสิ่งที่ทำให้เครื่องสองเครื่องรันโค้ดชุดเดียวกันได้

ฉันจะทราบได้อย่างไรว่าเวอร์ชันที่ติดตั้งจริงคือเวอร์ชันใด

ไฟล์ lockfile ใน git ระบุสิ่งที่ควรจะถูกติดตั้ง แต่สิ่งที่อยู่ในดิสก์คือสิ่งที่ถูกติดตั้งจริง หลักฐานที่เชื่อถือได้มีเพียงอย่างหลังเท่านั้น

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 ป้องกันการ import subpath และจะแสดงผลลัพธ์เป็นเวอร์ชันเดียวโดยไม่มีการวาดโครงสร้างต้นไม้

สำหรับการเปรียบเทียบอีกส่วนหนึ่ง ให้ตรวจสอบจาก git:

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

สร้างความเชื่อมโยงระหว่างทั้งสองส่วนให้ถาวรโดยการนำ commit ไปไว้ใน deploy layout ทำการ release ลงใน /srv/nodeapp/releases/<short commit sha> แล้วชี้ /srv/nodeapp/current ไปยังตำแหน่งนั้นด้วย symlink คำตอบสำหรับคำถามที่ว่า "ขณะนี้กำลังรันเวอร์ชันใดอยู่" จะกลายเป็น readlink /srv/nodeapp/current ซึ่งบุคคลอื่นที่ไม่ใช่ผู้ deploy ก็สามารถตรวจสอบได้ในเวลา 03:00 น.

สุดท้าย ให้ตรวจสอบสิ่งที่ registry ยืนยัน:

npm audit signatures

คำสั่งนี้จะตรวจสอบลายเซ็นของ registry บนแพ็กเกจใน tree ที่ติดตั้งไว้ และตรวจสอบการรับรองแหล่งที่มา (provenance attestations) สำหรับแพ็กเกจที่มีข้อมูลดังกล่าว Provenance จะเชื่อมโยง tarball ที่เผยแพร่เข้ากับ build จากระบบ continuous integration (CI) ที่สร้างมันขึ้นมา ดังนั้นการรับรองที่ผ่านการตรวจสอบหมายความว่าคุณสามารถสืบย้อนโค้ดกลับไปยัง commit ได้ แทนที่จะเป็นแล็ปท็อปที่ไม่ทราบที่มา เนื่องจากข้อมูลนี้ไม่ได้ครอบคลุมทุกแพ็กเกจ หากพบว่าไม่มีการรับรอง ให้ถือว่า "ไม่มีข้อมูล" ไม่ใช่ "แพ็กเกจไม่ปลอดภัย"

สิ่งที่ควรทำเมื่อ release ที่มีปัญหาเข้าถึงเซิร์ฟเวอร์ของคุณได้

ให้เริ่มตรวจสอบจากสิ่งที่ทำงานอยู่และตรวจสอบว่าทำงานภายใต้ผู้ใช้ใด

หากโค้ดทำงานระหว่างการติดตั้ง ให้สันนิษฐานว่าทุกสิ่งที่ผู้ใช้ที่ทำหน้าที่ build สามารถอ่านได้นั้นถูกเข้าถึงแล้ว ให้ทำการหมุนเวียน (rotate) registry token, SSH keys ใน home directory นั้น, cloud credentials และความลับ (secret) ใดๆ ที่ถูก export ไว้ใน shell นั้น การหมุนเวียนข้อมูลเป็นวิธีเดียวที่แสดงความรับผิดชอบ เพราะคุณไม่สามารถพิสูจน์ได้ว่าไฟล์เหล่านั้นไม่ได้ถูกอ่านไป

หากโค้ดทำงานในขณะรันไทม์ภายใต้ service account ที่มีการจำกัดสิทธิ์ ขอบเขตที่เข้าถึงได้จะเล็กลงมาก นั่นคือ environment variables ของแอปพลิเคชันเองและทุกสิ่งที่การเข้าถึงเครือข่ายของแอปสามารถไปถึงได้ นี่คือเหตุผลทั้งหมดของการ รันบริการในฐานะผู้ใช้ที่ไม่มีสิทธิ์พิเศษบน VPS ซึ่งไม่ได้เป็นการป้องกันการถูกบุกรุก แต่เป็นการกำหนดว่าการบุกรุกนั้นจะส่งผลกระทบต่อเครื่องได้มากน้อยเพียงใด และจะยังคงอยู่หลังจากรีสตาร์ทหรือไม่

จากนั้นให้สร้างใหม่ (rebuild) แทนการทำความสะอาดไฟล์เดิม ให้ลบ node_modules, กำหนดเวอร์ชันของแพ็กเกจที่ได้รับผลกระทบให้ต่ำกว่าเวอร์ชันที่มีปัญหาใน package.json, รัน npm install หนึ่งครั้งเพื่ออัปเดต lockfile, ทำการ commit และ deploy ด้วย npm ci อย่าพยายามซ่อมแซมโครงสร้างไฟล์ในที่เดิม เพราะคุณไม่สามารถระบุได้ว่าสคริปต์การติดตั้งได้เข้าไปแก้ไขส่วนใดบ้าง

จดบันทึกช่วงเวลาที่เกิดเหตุการณ์ไว้ด้วย ได้แก่ การ deploy ครั้งแรกที่อาจดึงเวอร์ชันนั้นมา และการ deploy ครั้งที่นำเวอร์ชันนั้นออก ช่วงเวลาดังกล่าวจะบอกคุณว่าต้องอ่าน log ส่วนใดของคุณ และจะสามารถระบุได้ก็ต่อเมื่อคุณตั้งชื่อ release ตาม commit เท่านั้น

สิ่งที่วิธีเหล่านี้แก้ไขไม่ได้

Lockfile ไม่ได้ทำให้ dependency ปลอดภัยขึ้น แต่มันเปลี่ยนช่วงเวลาที่คุณยอมรับ dependency นั้นให้กลายเป็นการตัดสินใจที่มีการตรวจสอบและระบุวันที่ไว้ แทนที่จะเป็นผลข้างเคียงจากการ deploy ทุกแนวทางที่กล่าวมาข้างต้นทำหน้าที่เปลี่ยนสิ่งเดียวกัน คือเปลี่ยนจากความผิดพลาดให้กลายเป็นการเลือกโดยเจตนา

npm audit ไม่ใช่การป้องกันในกรณีนี้ เพราะมันทำหน้าที่เปรียบเทียบ dependency tree ของคุณกับฐานข้อมูลของช่องโหว่ที่ถูกรายงานไว้แล้ว จึงตรวจพบเฉพาะปัญหาที่ถูกเผยแพร่และระบุชื่อไว้แล้วเท่านั้น แต่การโจมตีผ่าน supply-chain จะไม่มีชื่อเรียกตลอดช่วงเวลาที่มันยังใช้งานได้ผล ให้รัน npm audit เพื่อหาบั๊กเก่าที่ทราบกันดี แต่ไม่ต้องคาดหวังว่ามันจะช่วยตรวจพบการโจมตีใน release ที่เพิ่งปล่อยออกมาเมื่อสี่ชั่วโมงที่แล้ว

การลดจำนวน dependency ลงช่วยได้มากกว่าเครื่องมือใดๆ ในคู่มือนี้ และเป็นคำแนะนำที่ได้รับความนิยมน้อยที่สุด แพ็กเกจทุกตัวที่คุณไม่ได้เพิ่มเข้าไป หมายถึงผู้เผยแพร่หนึ่งรายที่ไม่สามารถถูกหลอก (phished) เพื่อโจมตีในนามของคุณ และเป็นสคริปต์ติดตั้งอีกหนึ่งตัวที่จะไม่ถูกรันในฐานะผู้ใช้ที่ทำหน้าที่ deploy ของคุณ

เรื่องทั้งหมดนี้ไม่ได้จำกัดอยู่แค่ npm รูปแบบการโจมตีทั้งสี่แบบนี้ใช้ได้กับทั้ง PyPI, RubyGems, container images และ package manager ของ distribution ที่คุณใช้งาน npm เป็นที่ที่เห็นปัญหาชัดเจนที่สุดเพราะ dependency tree มีความลึกมาก และ npm เวอร์ชันที่เซิร์ฟเวอร์ส่วนใหญ่ใช้งานยังคงรันสคริปต์ติดตั้งโดยค่าเริ่มต้น สิ่งใดก็ตามที่ขยายขีดความสามารถของเครื่องมือที่คุณใช้งานอยู่ย่อมได้รับปัญหาเดียวกัน นี่คือเหตุผลว่าทำไม การวิเคราะห์ว่า dsh plugin สามารถเข้าถึงอะไรได้บ้างก่อนที่คุณจะติดตั้ง จึงเป็นกระบวนการเดียวกับการอ่านสคริปต์ postinstall โดยใช้สิทธิ์ของ agent แทนสิทธิ์ของผู้ใช้ที่ทำหน้าที่ deploy ของคุณ ส่วนของเครื่องที่อยู่รอบข้างที่คุณต้องรับผิดชอบป้องกันนั้นขึ้นอยู่กับว่ามันรันอยู่ที่ไหน ซึ่งเป็นส่วนหนึ่งของ คำถามที่กว้างกว่าว่า VPS hosting ปลอดภัยหรือไม่

FAQ

npm ci ช่วยป้องกันผมจาก npm package ที่ถูกบุกรุกหรือไม่?

มันช่วยป้องกันไม่ให้เวอร์ชันเปลี่ยนไปโดยที่คุณไม่ทราบ npm ci จะติดตั้งสิ่งที่ package-lock.json บันทึกไว้เท่านั้น โดยตรวจสอบ tarball แต่ละไฟล์เทียบกับค่า sha512 integrity hash และจะหยุดทำงานพร้อมแสดงข้อผิดพลาดหาก package.json และ lockfile ไม่ตรงกัน แทนที่จะพยายามแก้ไขความแตกต่างนั้น อย่างไรก็ตาม มันไม่ได้ระบุว่าเวอร์ชันที่ล็อกไว้นั้นปลอดภัยหรือไม่ หากคุณ commit lockfile ที่ล็อกเวอร์ชันอันตรายไว้ npm ci ก็จะติดตั้งเวอร์ชันนั้นลงบนทุกเซิร์ฟเวอร์ที่คุณมีอย่างซื่อตรงในทุกครั้ง

ผมควรตั้งค่า ignore-scripts=true สำหรับทุกอย่างหรือไม่?

ควรตั้งค่าไว้ แล้วค่อยใช้การอนุญาตเฉพาะรายการ (allowlist) การตั้งค่า ignore-scripts=true ใน .npmrc ของโปรเจกต์จะหยุดการทำงานของสคริปต์ติดตั้ง dependency ซึ่งเป็นการตัดช่องทางที่ตรงที่สุดที่แพ็กเกจอันตรายจะเข้าถึงข้อมูลประจำตัวของผู้ใช้ที่ทำหน้าที่ deploy แพ็กเกจที่ต้องคอมไพล์ native addon หรือดึงไฟล์ binary ที่สร้างไว้ล่วงหน้าจำเป็นต้องใช้สคริปต์เหล่านี้จริง ซึ่งเมื่อปิดสคริปต์ไปแล้ว แพ็กเกจเหล่านั้นจะล้มเหลวในภายหลังที่ runtime ด้วยข้อผิดพลาดไฟล์ binding หาย แทนที่จะล้มเหลวตอนติดตั้ง ให้รัน npm ci --ignore-scripts แล้วตามด้วย npm rebuild <package> --ignore-scripts=false สำหรับแพ็กเกจไม่กี่ตัวที่คุณตัดสินใจเชื่อถือ เพราะหากไม่ทำเช่นนั้น npm rebuild จะเคารพการตั้งค่า .npmrc และไม่รันอะไรเลย npm query ":attr(scripts, [postinstall])" จะแสดงให้เห็นว่ามีแพ็กเกจที่ต้องใช้สคริปต์อยู่จริงกี่ตัว

ผมจะตรวจสอบได้อย่างไรว่าเซิร์ฟเวอร์ติดตั้งแพ็กเกจเวอร์ชันไหนอยู่จริง?

ให้อ่านจากดิสก์ ไม่ใช่อ่านจาก lockfile npm ls <package> จะรายงานสิ่งที่อยู่ใน node_modules และ node -e "console.log(require('./node_modules/<package>/package.json').version)" จะแสดงเฉพาะสตริงเวอร์ชันออกมา lockfile ใน git ตอบคำถามที่ต่างออกไป คือสิ่งที่ควรจะถูกติดตั้ง และการเปรียบเทียบทั้งสองอย่างนี้คือประเด็นสำคัญ การ deploy ลงในไดเรกทอรีที่ตั้งชื่อตาม git commit จะช่วยให้คุณเก็บคำตอบทั้งสองแบบไว้ได้แม้เวลาผ่านไปหลายเดือนเมื่อคุณต้องการตรวจสอบ

npm audit สามารถตรวจพบการโจมตีแบบ supply-chain ได้หรือไม่?

ไม่ได้ npm audit จะเปรียบเทียบโครงสร้างแพ็กเกจของคุณกับฐานข้อมูลช่องโหว่ที่ได้รับรายงานมา ดังนั้นมันจะพบเฉพาะปัญหาที่ถูกเผยแพร่และมีหมายเลขระบุไว้แล้วเท่านั้น การปล่อยแพ็กเกจอันตรายมักไม่มีการรายงานในช่วงเวลาหลายชั่วโมงหรือหลายวันที่สำคัญต่อการติดตั้ง npm audit signatures เป็นคำสั่งที่มีประโยชน์มากกว่า โดยจะตรวจสอบลายเซ็นของ registry ในโครงสร้างแพ็กเกจที่ติดตั้งไว้และตรวจสอบ provenance attestation ในกรณีที่ผู้เผยแพร่ได้สร้างไว้ ซึ่งจะบอกคุณได้ว่า tarball นั้นมาจากกระบวนการ build สาธารณะ ไม่ใช่มาจากเครื่องที่ไม่รู้จัก

ทำไมการรันแอปด้วยผู้ใช้ที่ไม่มีสิทธิ์ (unprivileged user) จึงสำคัญหากการโจมตีเกิดขึ้นตอนติดตั้ง?

เพราะความล้มเหลวทั้งสองแบบมีขอบเขตผลกระทบต่างกัน และคุณกำลังป้องกันทั้งสองกรณี โค้ดที่รันตอนติดตั้งจะทำงานในฐานะผู้ใช้ที่ทำหน้าที่ deploy และสามารถอ่าน SSH keys, registry tokens และ cloud credentials ของผู้ใช้นั้นได้ ส่วนโค้ดที่รันตอน runtime จะทำงานในฐานะ service account และหากมีการใช้ User=nodeapp, ProtectSystem=strict และไม่มีข้อมูลประจำตัวทิ้งไว้บนดิสก์ให้เข้าถึง ขอบเขตของมันก็จะจำกัดอยู่แค่สภาพแวดล้อมของแอปพลิเคชันและฐานข้อมูลของมันเท่านั้น การแยกบัญชีผู้ใช้ยังหมายความว่ากระบวนการที่ให้บริการ traffic ไม่สามารถเขียนทับ node_modules ได้ ดังนั้นการบุกรุกที่เกิดขึ้นตอน runtime จะหายไปเมื่อมีการรีสตาร์ทครั้งถัดไป แทนที่จะกลายเป็นการฝังตัวอย่างถาวร

บทความนี้มีประโยชน์หรือไม่