การเขียนโค้ดแบบตายตัว, Hashicorp Vault, การจัดการความลับ

วิธีป้องกันการใส่รหัสลับแบบตายตัวใน HashiCorp Vault

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

ผลกระทบในโลกแห่งความเป็นจริงแสดงให้เห็นถึงสิ่งที่กำลังตกอยู่ในความเสี่ยง ในปี 2022 ผู้โจมตีพบรหัส AWS ของ Uber ที่ถูกเขียนไว้ในโค้ดของ GitHub repository และใช้รหัสเหล่านั้นในการเจาะระบบที่สำคัญ โตโยต้าเปิดเผยโครงสร้างพื้นฐานของลูกค้าที่เป็นส่วนตัวหลังจากที่นักพัฒนาได้เผยแพร่ข้อมูลลับไปยัง GitHub repository สาธารณะ ในทั้งสองกรณี ทีมงานได้ทิ้งข้อมูลลับไว้ในโค้ด และผู้โจมตีได้ใช้ประโยชน์จากช่องโหว่นี้อย่างเต็มที่ ซึ่งทั้งหมดนี้สามารถป้องกันได้

ในคู่มือนี้ คุณจะได้เรียนรู้วิธีการรักษาความปลอดภัยให้กับแอปของคุณโดยใช้ ห้องนิรภัย HashiCorp สำหรับการจัดการความลับแบบรวมศูนย์ ควบคู่ไปกับ ระบบตรวจจับและแก้ไขอัตโนมัติของ Xygeni คุณสมบัติต่างๆ เมื่อใช้ร่วมกัน เครื่องมือเหล่านี้จะช่วยคุณได้ดังนี้:

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

เรามาเริ่มตั้งค่ากันทีละขั้นตอนเลยดีกว่า

2. อะไรคือสิ่งที่ถือว่าเป็นความลับ (และความลับรั่วไหลได้อย่างไร)

ก่อนอื่นก ลับ ไม่ใช่แค่รหัสผ่านเท่านั้น แต่ยังรวมถึงโทเค็น API, ข้อมูลรับรอง OAuth, สตริงการเชื่อมต่อฐานข้อมูล, คีย์ SSH, คีย์การเข้ารหัส และแม้แต่ JWT ด้วย อะไรก็ตามที่ให้สิทธิ์ในการเข้าถึงระบบ ทรัพยากร หรือตัวตน ล้วนถือเป็นความลับ

เพราะ การเขียนโค้ดแบบตายตัว การใส่ข้อมูลประจำตัวเหล่านี้ลงในซอร์สโค้ดยังคงเป็นเรื่องปกติ ทีมพัฒนาหลายทีมอาจเผลอสร้างช่องโหว่โดยไม่รู้ตัว ในระหว่างการพัฒนาในเครื่อง การใส่คีย์ API อย่างรวดเร็วลงไปนั้นทำได้ง่าย .env ไฟล์—หรือแย่กว่านั้นคือเขียนลงในโค้ดโดยตรง หลังจากนั้น เพียงครั้งเดียว git commit สามารถเปิดเผยความลับนั้นได้อย่างถาวร

แม้ว่าความลับจะถูกเปิดเผยในภายหลังก็ตาม commitพวกเขามักจะยังคงอยู่ในนั้น ประวัติ Gitเลเยอร์ของ Docker หรืออาร์ติแฟกต์ที่คอมไพล์แล้ว ตัวอย่างเช่น การรั่วไหลจำนวนมากมักไม่ถูกตรวจพบจนกว่าจะมีคนเรียกใช้ git log หรือดึงข้อมูลเมตาจากอิมเมจคอนเทนเนอร์

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

นอกจากนี้ อย่าลืมว่าความลับไม่ได้รั่วไหลจากนักพัฒนาซอฟต์แวร์เท่านั้น CI/CD pipelineไฟล์ต่างๆ เช่น สคริปต์ทดสอบ และแม้แต่ไฟล์การกำหนดค่าในสภาพแวดล้อมการผลิต ล้วนอาจเป็นแหล่งที่มาของความเสี่ยงได้

ดังนั้น การรักษาความลับจึงไม่ใช่แค่เรื่องของเครื่องมือ แต่ยังเกี่ยวกับนิสัย การมองเห็น และระบบอัตโนมัติด้วย

ต้องการเจาะลึกเข้าไปในเรื่องการรั่วไหลของข้อมูลลับหรือไม่?

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

อ่านที่เกี่ยวข้อง:

3. เหตุใดการใส่รหัสลับแบบตายตัวจึงเป็นความเสี่ยง แม้แต่ในที่เก็บข้อมูลส่วนตัว

การเขียนโค้ดแบบตายตัวสำหรับรหัสลับ เช่น คีย์ API ข้อมูลประจำตัว และโทเค็น อาจดูสะดวกในระหว่างการพัฒนา อย่างไรก็ตาม การกระทำนี้ก่อให้เกิดความเสี่ยงร้ายแรง โดยเฉพาะอย่างยิ่งเมื่อรหัสลับเหล่านั้นรั่วไหล commitเชื่อมโยงกับระบบควบคุมเวอร์ชัน

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

เนื่องจากรหัสลับที่ถูกกำหนดไว้ตายตัวมักจะอยู่ใน... .env ไฟล์ สคริปต์ หรือคอมเมนต์ในซอร์สโค้ด มักถูกมองข้ามไปได้ง่าย แม้แต่ในที่เก็บข้อมูลส่วนตัว บอทและคนวงในก็ยังสามารถเข้าถึงได้ ที่แย่กว่านั้นคือ ประวัติของ Git จะเก็บรักษาข้อมูลการรั่วไหลทุกอย่างไว้ แม้หลังจากที่คุณ "ลบ" มันไปแล้วก็ตาม

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

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

ดังนั้น การแทนที่การเขียนโค้ดแบบตายตัวด้วยวิธีการที่เหมาะสมจึงเป็นสิ่งสำคัญ การจัดการความลับ ไม่ใช่สิ่งที่ไม่จำเป็น แต่เป็นพื้นฐานสำคัญสำหรับการพัฒนาที่มั่นคง

4. HashiCorp Vault รักษาความปลอดภัยของข้อมูลลับได้อย่างไร (และทำไมจึงดีกว่าการเขียนโค้ดแบบตายตัว)

การใส่รหัสลับ เช่น คีย์ API หรือข้อมูลประจำตัวฐานข้อมูล ลงในซอร์สโค้ดโดยตรง ก่อให้เกิดความเสี่ยงด้านความปลอดภัยอย่างร้ายแรง HashiCorp Vault ช่วยขจัดความเสี่ยงนี้ด้วยการให้บริการจัดเก็บข้อมูลลับแบบรวมศูนย์ เข้ารหัส และควบคุมการเข้าถึง

แทนที่จะฝังความลับไว้ในตัวแปรสภาพแวดล้อมหรือ ไฟล์ .envแอปพลิเคชันต่างๆ สามารถเรียกดูข้อมูลลับเหล่านั้นได้อย่างปลอดภัยตามต้องการผ่าน API ของ Vault แนวทางนี้แทนที่การจัดการข้อมูลลับแบบคงที่ด้วยการเข้าถึงแบบไดนามิกที่ขับเคลื่อนด้วยนโยบาย

การจัดการความลับด้วย HashiCorp Vault มีข้อดีหลายประการเหนือกว่าการเขียนโค้ดแบบตายตัว:

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

นอกจากนี้ Vault ยังผสานรวมเข้ากับระบบต่างๆ ได้อย่างราบรื่น CI/CD pipelineด้วยการผสานรวมสภาพแวดล้อมแบบคอนเทนเนอร์ โครงสร้างพื้นฐานบนคลาวด์ และเซอร์วิสเมช ทำให้เป็นโซลูชันที่ปรับขนาดได้และพร้อมใช้งานจริงสำหรับทีม DevSecOps ยุคใหม่

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

ถึงตอนนี้ น่าจะชัดเจนแล้วว่า: การเปลี่ยนจากการเขียนโค้ดแบบตายตัวไปสู่การใช้ระบบรักษาความปลอดภัยนั้นสำคัญ การจัดการความลับ เครื่องมือเช่น ห้องนิรภัย HashiCorp ไม่ใช่แค่เป็นแนวทางปฏิบัติที่ดีที่สุด แต่เป็นสิ่งจำเป็นอย่างยิ่ง

5. วิธีการผสานรวม Git, HashiCorp Vault และ Xygeni เพื่อการจัดการความลับที่ปลอดภัย

เพื่อหลีกเลี่ยงอย่างสมบูรณ์ การเขียนโค้ดแบบตายตัว ในส่วนของความลับนั้น นักพัฒนาต้องดำเนินการเชิงรุกในระหว่างการพัฒนาในระดับท้องถิ่นและใน CI/CD. ข่าวดีก็คือ ห้องนิรภัย HashiCorp และ ไซเกนี ร่วมมือกันเพื่อบังคับใช้มาตรการรักษาความปลอดภัย การจัดการความลับ เวิร์กโฟลว์

ขั้นตอนที่ 1: ใช้ Vault เพื่อดึงข้อมูลลับอย่างปลอดภัย

ขั้นแรก กำหนดค่าแอปของคุณให้โหลดข้อมูลลับจาก ห้องนิรภัย HashiCorp ในระหว่างการทำงาน ตัวอย่างเช่น ใน Node.js:

				
					const vault = require("node-vault")({
  endpoint: process.env.VAULT_URL,
  token: process.env.VAULT_TOKEN,
});

const secret = await vault.read("secret/production/db-password");
console.log("DB password:", secret.data.data.value);
				
			

วิธีนี้ช่วยให้มั่นใจได้ว่าข้อมูลลับจะไม่ถูกจัดเก็บไว้ในโค้ดหรือไฟล์การตั้งค่า

ขั้นตอนที่ 2: ป้องกันการเขียนโค้ดแบบตายตัวด้วย Git Hook และ Xygeni

เพื่อป้องกันการรั่วไหลโดยไม่ตั้งใจ คุณสามารถเพิ่ม... pre-commit เบ็ด โดยใช้ CLI ของ Xygeni:

				
					#!/bin/sh
# .git/hooks/pre-commit
xygeni secrets --staged-files --no-upload
if [ $? -ne 0 ]; then
  echo "❌ Commit blocked due to hardcoded secret. Fix and try again."
  exit 1
fi
				
			

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

ขั้นตอนที่ 3: ผสานรวม Vault และ Xygeni เข้าด้วยกัน CI/CD

ใน CI pipelineดังนั้น คุณสามารถทำได้ดังนี้:

  • ดึงข้อมูลลับขณะรันไทม์จาก หกคะเมน
  • วิ่ง xygeni scan --run="secrets" เพื่อตรวจสอบว่าไม่มีการเปิดเผยความลับใดๆ
  • Xygeni จะทำการแก้ไขปัญหาโดยอัตโนมัติหากเกิดการรั่วไหล

นักพัฒนาซอฟต์แวร์บังคับใช้การรักษาความลับในทุกขั้นตอน ตั้งแต่ระดับท้องถิ่น commitขอบคุณฝ่ายบริหารที่ให้ความสำคัญกับวงจรการตอบรับที่รวดเร็วและมีประสิทธิภาพนี้ สำหรับการนำไปใช้งานจริง

6. จากการเขียนโค้ดแบบตายตัวสู่การจัดการความลับอย่างปลอดภัยด้วย Vault + Xygeni

การใส่รหัสลับโดยตรงยังคงเป็นหนึ่งในวิธีที่นักพัฒนาซอฟต์แวร์มักเปิดเผยข้อมูลสำคัญโดยไม่ตั้งใจ นั่นเป็นเหตุผลว่าทำไมการจับคู่จึงสำคัญ ห้องนิรภัย HashiCorp ด้วยการสแกนแบบเรียลไทม์จาก Xygeni ทำให้ได้ผลลัพธ์ที่สมบูรณ์แบบ การจัดการความลับ สถาปัตยกรรม: การตรวจจับ การป้องกัน และการแก้ไขอัตโนมัติ ที่ผสานรวมเข้ากับขั้นตอนการทำงานของคุณโดยตรง

ขั้นตอนวิธีการทำงานของระบบจัดการความลับร่วมกับ HashiCorp Vault และ Xygeni
ขั้นตอนที่ 1: กำหนดความลับใน Vaultจัดเก็บข้อมูลลับ เช่น คีย์ API ข้อมูลประจำตัว หรือโทเค็น อย่างปลอดภัยใน HashiCorp Vault ภายใต้การควบคุมการเข้าถึงที่เข้มงวดและการเข้ารหัสขณะจัดเก็บ
ขั้นตอนที่ 2: แทรกข้อมูลลับผ่านทาง CI/CDใช้ตัวแปรสภาพแวดล้อมหรือการแทรกแบบไดนามิกเพื่อส่งรหัสลับไปยังกระบวนการสร้างของคุณ pipelineหรือแอปพลิเคชัน โดยหลีกเลี่ยงการเขียนโค้ดแบบตายตัวในซอร์สโค้ด
ขั้นตอนที่ 3: สแกนหาโค้ดลับที่ถูกกำหนดไว้ตายตัวXygeni สแกนทุกอย่าง pull requestใช้ภาพ Docker และประวัติ Git เพื่อตรวจจับและตรวจสอบความถูกต้องของข้อมูลลับที่รั่วไหลแบบเรียลไทม์
ขั้นตอนที่ 4: ตรวจสอบความถูกต้องของข้อมูลลับXygeni ตรวจสอบว่ารหัสลับนั้นใช้งานได้หรือไม่ รหัสลับที่ได้รับการตรวจสอบแล้วจะถูกทำเครื่องหมายเพื่อดำเนินการทันทีโดยใช้กลไกการตรวจสอบของ Xygeni
ขั้นตอนที่ 5: เรียกใช้การแก้ไขอัตโนมัติหากตรวจพบรหัสลับที่ได้รับการตรวจสอบแล้ว Xygeni สามารถเพิกถอนหรือเปลี่ยนรหัสลับนั้นได้ โพสต์ไปยังคำขอแก้ไข/คำขอรวมโค้ดพร้อมบริบท และแนะนำขั้นตอนการแก้ไขปัญหา

7. หยุดการเขียนโค้ดลับแบบตายตัวตลอดไป ด้วยการแก้ไขอัตโนมัติและการจัดการความลับ

ถึงแม้จะมี HashiCorp Vault อยู่แล้ว ความผิดพลาดก็ยังคงเกิดขึ้นได้ นักพัฒนาอาจใส่ค่าโทเค็นแบบตายตัวระหว่างการทดสอบในเครื่อง หรือลืมตั้งค่าบางอย่าง .gitignore อย่างถูกต้อง นั่นคือเหตุผลที่การผสานรวมการจัดการความลับเข้ากับการสแกนอย่างต่อเนื่องและการแก้ไขปัญหาอัตโนมัติจึงเป็นสิ่งสำคัญ

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

นี่คือวิธีการทำงานของ Xygeni AutoFix สำหรับการค้นหาความลับ:

  • Xygeni สแกนทุกอย่าง pull request ทันทีที่เปิดใช้งาน ระบบจะค้นหาความลับที่ถูกกำหนดไว้ในโค้ด การตั้งค่า ประวัติ Git และเลเยอร์ของ Docker
  • มันตรวจสอบความถูกต้องของความลับที่พบทั้งหมด โดยมุ่งเป้าไปที่บริการเป้าหมายและบิดเบือนค่าในบันทึกข้อมูล
  • Xygeni เปิดเผยความลับนี้โดยตรงในข่าวประชาสัมพันธ์พร้อมทั้งเพิ่มคำอธิบายประกอบเกี่ยวกับระดับความรุนแรงและประเภท
  • AutoFix สร้างแพทช์ที่ปลอดภัยซึ่งอาจ:
    • ลบคอมเมนต์ส่วนที่เป็นความลับที่ถูกเปิดเผยออกไป
    • แทนที่ด้วยการอ้างอิง Vault หรือตัวแปรสภาพแวดล้อม
    • เสนอคำแนะนำการแก้ไขปัญหาทีละขั้นตอน
  • หากราวกั้นทำงานอยู่Xygeni จะบล็อก Pull Request (PR) โดยอัตโนมัติจนกว่าปัญหาจะได้รับการแก้ไข

นอกจากนี้ ไซเกนี รองรับการบังคับใช้ผ่าน GitHub Actions, GitLab, Jenkins และ Bitbucket ดังนั้น ข้อมูลลับจะไม่รั่วไหลไปยังระบบใช้งานจริง แม้ว่าคุณจะมองข้ามไปในระหว่างการตรวจสอบก็ตาม

นี่ไม่ใช่แค่การตรวจจับความลับ แต่เป็นการปกป้องความลับที่สามารถปรับขนาดได้

sca-tools-software-composition-analysis-tools
จัดลำดับความสำคัญ แก้ไข และรักษาความปลอดภัยความเสี่ยงด้านซอฟต์แวร์ของคุณ
สมัครบัญชีฟรีได้เลย
ไม่ต้องใช้บัตรเครดิต

รักษาความปลอดภัยในการพัฒนาและส่งมอบซอฟต์แวร์ของคุณ

ด้วยชุดผลิตภัณฑ์ Xygeni