ป้องกันปัญหาโดยใช้ GitHub Copilot

6 นาที

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

กรอบความคิดด้านความปลอดภัยเชิงรุก

ข้อบกพร่องที่คุ้มค่าที่สุดคือข้อบกพร่องที่คุณไม่เคยแนะนํา แม้ว่าการเรียนรู้ที่จะแก้ไขปัญหาด้านความปลอดภัยอย่างรวดเร็วนั้นมีค่า แต่การป้องกันไม่ให้เกิดขึ้นตั้งแต่แรกนั้นเหนือกว่ามาก การเปลี่ยนจากการรักษาความปลอดภัยเชิงรับเป็นการรักษาความปลอดภัยเชิงรุกนี้จําเป็นต้องรวมแนวทางปฏิบัติและเครื่องมือการเขียนโค้ดที่ปลอดภัย เช่น GitHub Copilot เข้ากับเวิร์กโฟลว์การพัฒนาประจําวันของคุณ

พิจารณาต้นทุนสัมพัทธ์:

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

การสร้างความปลอดภัยตั้งแต่เริ่มต้นจะช่วยลดต้นทุนและความเสี่ยงได้อย่างมาก

GitHub Copilot เป็นพันธมิตรด้านการเขียนโค้ดที่เน้นความปลอดภัย

GitHub Copilot สามารถช่วยคุณเขียนโค้ดที่ปลอดภัยตั้งแต่เริ่มต้นการพัฒนา ไม่ใช่แค่เมื่อแก้ไขปัญหาเท่านั้น

การเขียนโค้ดที่ปลอดภัยตั้งแต่เริ่มต้น

เมื่อเริ่มฟังก์ชันหรือคุณสมบัติใหม่ ให้สื่อสารเจตนารมณ์ด้านความปลอดภัยผ่านความคิดเห็นและข้อความแจ้ง GitHub Copilot ใช้บริบทนี้เพื่อแนะนําการใช้งานที่ปลอดภัย

พิจารณาข้อคิดเห็นของโค้ดต่อไปนี้:

// Query database for user by name using parameterized query to prevent SQL injection

GitHub Copilot ประเมินเจตนาที่อธิบายไว้ในความคิดเห็น ตรวจสอบบริบทที่จัดทําโดยโค้ดที่เปิดในตัวแก้ไข จากนั้นสร้างโค้ดที่แนะนําโดยใช้รูปแบบการเข้ารหัสที่ปลอดภัย ในกรณีนี้ แทนที่จะแนะนําการต่อสตริงสําหรับคิวรี SQL GitHub Copilot มีแนวโน้มที่จะแนะนําสิ่งที่คล้ายกับโค้ดต่อไปนี้:

string query = "SELECT * FROM Users WHERE Name = @name";
using (SqlCommand command = new SqlCommand(query, connection))
{
    command.Parameters.AddWithValue("@name", userName);
    using (SqlDataReader reader = command.ExecuteReader())
    {
        // Process results
    }
}

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

คุณยังสามารถใช้มุมมองแชทของ GitHub Copilot เพื่อสํารวจแนวทางปฏิบัติในการเขียนโค้ดที่ปลอดภัย ตัวอย่างเช่น หากต้องการความช่วยเหลือในการใช้การแฮชรหัสผ่าน คุณอาจป้อนข้อความแจ้งต่อไปนี้ในมุมมองแชท

How do I hash a password using a secure, industry-standard algorithm with automatic salting?

GitHub Copilot จะประเมินพรอมต์ของคุณ ใช้โค้ดที่เปิดอยู่ในตัวแก้ไขสําหรับบริบท จากนั้นแนะนําโค้ดที่ใช้ไลบรารีที่ได้รับการยอมรับและแนวทางปฏิบัติที่ปลอดภัย ตัวอย่างเช่น อาจแนะนํารหัสต่อไปนี้:

string hashedPassword = BCrypt.Net.BCrypt.HashPassword(password);

การใช้ GitHub Copilot สามารถช่วยคุณใช้รูปแบบที่ปลอดภัยตั้งแต่เริ่มต้น ซึ่งช่วยลดโอกาสในการเกิดช่องโหว่

การตรวจสอบความถูกต้องอย่างต่อเนื่องระหว่างการพัฒนา

GitHub Copilot สามารถทําหน้าที่เป็นที่ปรึกษาด้านความปลอดภัยแบบเรียลไทม์ในขณะที่คุณเขียนโค้ด คุณสามารถถามคําถาม GitHub Copilot เพื่อตรวจสอบแนวทางของคุณในขณะที่คุณเขียนโค้ด

ต่อไปนี้คือตัวอย่างข้อความแจ้งที่สามารถใช้สําหรับการตรวจสอบความปลอดภัย:

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

การตรวจสอบความถูกต้องแบบเรียลไทม์นี้ทําหน้าที่เหมือนกับการมีผู้ตรวจสอบโค้ดที่คํานึงถึงความปลอดภัยพร้อมใช้งานทันที

การผสานรวมเครื่องมือและแนวทางปฏิบัติด้านความปลอดภัย

GitHub Copilot ช่วยเสริมเครื่องมือและแนวทางปฏิบัติด้านความปลอดภัยอื่นๆ ในเวิร์กโฟลว์การพัฒนาของคุณ

การวิเคราะห์แบบคงที่และตัวเจาะ

เครื่องมือวิเคราะห์โค้ดอัตโนมัติทํางานร่วมกับ GitHub Copilot เพื่อให้ครอบคลุมความปลอดภัยที่ครอบคลุมตลอดกระบวนการพัฒนา

รวม Copilot เข้ากับเครื่องมือวิเคราะห์โค้ดอัตโนมัติ:

เครื่องวิเคราะห์ .NET: บังคับใช้มาตรฐานการเข้ารหัสและตรวจจับปัญหาทั่วไป
GitHub CodeQL: สแกนหาช่องโหว่ด้านความปลอดภัยในคําขอดึงข้อมูล
ตัวระบุความปลอดภัย: เครื่องมือเฉพาะภาษาที่ตั้งค่าสถานะรูปแบบที่เป็นอันตราย

GitHub Copilot ช่วยให้คุณเขียนโค้ดที่มีโอกาสน้อยที่จะทริกเกอร์คําเตือนของเครื่องมือเหล่านี้ เมื่อคุณบอกให้ GitHub Copilot ใช้การสืบค้นที่มีพารามิเตอร์ โค้ดที่แนะนําควรผ่านการตรวจสอบการแทรก SQL โดยไม่ต้องมีการเปลี่ยนแปลง

พิจารณาการรวมเวิร์กโฟลว์ต่อไปนี้:

เขียนโค้ดด้วยความช่วยเหลือของ Copilot โดยใช้ข้อความแจ้งที่คํานึงถึงความปลอดภัย
เรียกใช้ linters และตัววิเคราะห์ในเครื่องในระหว่างการพัฒนา
แก้ไขปัญหาใด ๆ ก่อนดําเนินการ
ไปป์ไลน์ CI/CD อัตโนมัติจะทําการสแกนความปลอดภัยที่ครอบคลุม
การตรวจสอบโค้ดรวมถึงการตรวจสอบความปลอดภัยโดยมนุษย์และอัตโนมัติ

วิธีการแบบเลเยอร์นี้จับปัญหาได้หลายจุด การใช้ GitHub Copilot ช่วยคุณป้องกันปัญหาได้ตั้งแต่เนิ่นๆ

มาตรฐานการเข้ารหัสและแนวทางปฏิบัติของทีม

มาตรฐานความปลอดภัยที่สอดคล้องกันในทีมพัฒนาของคุณช่วยให้มั่นใจได้ว่าทุกคนใช้มาตรการรักษาความปลอดภัยอย่างสม่ําเสมอและมีประสิทธิภาพ

สร้างและบังคับใช้มาตรฐานการเข้ารหัสที่ปลอดภัย:

กําหนดแนวทางของทีมสําหรับแนวทางปฏิบัติด้านความปลอดภัยทั่วไป
ใช้ไลบรารีการเข้ารหัสที่ได้รับอนุมัติเท่านั้น (ระบุว่า)
อย่าเชื่อมต่อการป้อนข้อมูลของผู้ใช้ลงในแบบสอบถาม SQL
ตรวจสอบเส้นทางไฟล์จากการป้อนข้อมูลของผู้ใช้เสมอ
บันทึกเหตุการณ์ ไม่ใช่ข้อมูลที่ละเอียดอ่อน
ใช้รูปแบบการรับรองความถูกต้อง/การอนุญาตที่ได้รับอนุมัติ

เมื่อสมาชิกในทีมทํางานกับโค้ด พวกเขาสามารถอ้างอิงมาตรฐานเหล่านี้ได้ในข้อความแจ้ง GitHub Copilot GitHub Copilot สามารถช่วยให้มั่นใจได้ถึงความสอดคล้องโดยการสร้างโค้ดที่ตรงกับรูปแบบที่กําหนดไว้

มาตรการรักษาความปลอดภัยเชิงป้องกัน

ใช้แนวทางปฏิบัติเหล่านี้อย่างสม่ําเสมอเพื่อลดช่องโหว่ด้านความปลอดภัย

การตรวจสอบอินพุตและการฆ่าเชื้อ

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

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

คุณสามารถแจ้งให้ GitHub Copilot สร้างรหัสการตรวจสอบได้ ตัวอย่างเช่น ในการตรวจสอบที่อยู่อีเมล:

// Validate email address format and length before processing

GitHub Copilot อาจแนะนําโค้ดที่ตรวจสอบค่า null / ว่างเปล่าตรวจสอบขีด จํากัด ความยาวและใช้นิพจน์ทั่วไปเพื่อตรวจสอบรูปแบบ

หลักการของสิทธิ์การใช้งานน้อยที่สุด

การจํากัดสิทธิ์เฉพาะสิ่งที่จําเป็นจะช่วยลดความเสียหายที่อาจเกิดขึ้นหากเกิดการละเมิดความปลอดภัย

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

การใช้ไลบรารีที่ปลอดภัย

การใช้ไลบรารีความปลอดภัยที่จัดตั้งขึ้นอย่างดีช่วยลดความเสี่ยงของข้อผิดพลาดในการใช้งานในฟังก์ชันการรักษาความปลอดภัยที่สําคัญ

ใช้ไลบรารีที่ผ่านการทดสอบและบํารุงรักษามาอย่างดีแทนที่จะใช้ฟังก์ชันการทํางานที่มีความสําคัญต่อความปลอดภัยด้วยตัวเอง เลือกไลบรารีที่จัดตั้งขึ้น เช่น Entity Framework สําหรับคิวรีฐานข้อมูล ASP.NET Identity สําหรับการรับรองความถูกต้อง BCrypt.Net สําหรับการแฮชรหัสผ่าน และ Azure Key Vault SDK สําหรับการจัดการข้อมูลลับ

เขียนข้อความแจ้งที่บอกให้ GitHub Copilot ใช้ไลบรารีที่ได้รับอนุมัติ ตัวอย่างเช่น: "ใช้การแฮชรหัสผ่านโดยใช้ไลบรารี BCrypt.Net"

การทดสอบข้อกําหนดด้านความปลอดภัย

การทดสอบความปลอดภัยจะตรวจสอบว่ามาตรการป้องกันของคุณทํางานได้ตามที่ตั้งใจไว้และตรวจจับช่องโหว่ก่อนปรับใช้

ผสานรวมการทดสอบความปลอดภัยเข้ากับกระบวนการพัฒนาของคุณ ทดสอบกรณีขอบการตรวจสอบอินพุตสถานการณ์การรับรองความถูกต้องและการอนุญาตการดําเนินการเข้ารหัสการจัดการข้อผิดพลาดกับข้อมูลที่ละเอียดอ่อนและขอบเขตการอนุญาต

คุณสามารถแจ้งให้ GitHub Copilot สร้างการทดสอบความปลอดภัยได้ ตัวอย่างเช่น: "เขียนการทดสอบ xUnit สําหรับฟังก์ชัน ValidatePath ที่ตรวจสอบว่าป้องกันการโจมตีการข้ามไดเรกทอรี"

การใช้ GitHub Copilot ในการตรวจสอบโค้ด

การตรวจสอบรหัสเป็นจุดตรวจสอบความปลอดภัยที่สําคัญ GitHub Copilot สําหรับ Pull Requests สามารถตั้งค่าสถานะรูปแบบที่น่าสงสัยโดยอัตโนมัติระบุช่องโหว่ที่อาจเกิดขึ้นและแนะนําการปรับปรุง

คุณยังสามารถใช้ GitHub Copilot Chat ในระหว่างการตรวจสอบด้วยตนเองโดยถามคําถามเช่น "มีข้อกังวลด้านความปลอดภัยกับการเปลี่ยนแปลงเหล่านี้หรือไม่" หรือ "มีช่องโหว่ใดบ้างที่อาจเกิดขึ้นในโค้ดนี้"

การสร้างสมดุลระหว่างความปลอดภัยและประสิทธิภาพการทํางาน

การสร้างความปลอดภัยตั้งแต่เริ่มต้นนั้นเร็วกว่าการติดตั้งเพิ่มเติม การเขียนโค้ดที่ปลอดภัยในตอนแรกจะเพิ่มเวลาในการพัฒนา 5-10% ในขณะที่การแก้ไขปัญหาด้านความปลอดภัยในภายหลังจะเพิ่ม 30-50%และการตอบสนองต่อเหตุการณ์ด้านความปลอดภัยสามารถเพิ่ม 200-500% หรือมากกว่านั้น GitHub Copilot เร่งการพัฒนาที่ปลอดภัยโดยแนะนํารูปแบบที่เหมาะสมอย่างรวดเร็ว

การพัฒนากรอบความคิดด้านความปลอดภัยเป็นอันดับแรก

การปลูกฝังกรอบความคิดที่ให้ความสําคัญกับความปลอดภัยเป็นอันดับแรกเป็นสิ่งสําคัญสําหรับนักพัฒนาทุกคน แนวทางที่เน้นความปลอดภัยเป็นอันดับแรกจะให้ความสําคัญกับการพิจารณาด้านความปลอดภัยตลอดกระบวนการพัฒนา ตั้งแต่การออกแบบไปจนถึงการปรับใช้

คุณสามารถป้องกันปัญหาด้านความปลอดภัยได้โดยใช้หลักการเหล่านี้อย่างสม่ําเสมอ:

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

ใช้ GitHub Copilot เพื่อนําหลักการเหล่านี้ไปใช้อย่างสม่ําเสมอโดยรวมไว้ในข้อความแจ้งและความคิดเห็นของคุณ

Summary

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

คำติชม

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