การเข้ารหัสที่ปลอดภัย

การเขียนโค้ดที่ปลอดภัยคือการปฏิบัติในการพัฒนาซอฟต์แวร์ คอมพิวเตอร์ ในลักษณะที่ป้องกันการเกิดช่องโหว่ด้านความปลอดภัย โดยไม่ได้ตั้งใจ ข้อบกพร่องบั๊กและข้อผิดพลาดทางตรรกะเป็นสาเหตุหลักของช่องโหว่ซอฟต์แวร์ที่ถูกโจมตีบ่อยที่สุด^{[ 1 ]}จากการวิเคราะห์ช่องโหว่ที่รายงานหลายพันรายการ ผู้เชี่ยวชาญด้านความปลอดภัยได้ค้นพบว่าช่องโหว่ส่วนใหญ่เกิดจากข้อผิดพลาดในการเขียนโปรแกรมซอฟต์แวร์ทั่วไปจำนวนไม่มากนัก การระบุแนวทางการเขียนโค้ดที่ไม่ปลอดภัยซึ่งนำไปสู่ข้อผิดพลาดเหล่านี้ และการให้ความรู้แก่นักพัฒนาเกี่ยวกับทางเลือกที่ปลอดภัย องค์กรต่างๆ สามารถดำเนินการเชิงรุกเพื่อช่วยลดหรือกำจัดช่องโหว่ในซอฟต์แวร์ได้อย่างมีนัยสำคัญก่อนการใช้งาน^{[ 2 ]}

นักวิชาการบางคนเสนอแนะว่า เพื่อรับมือกับภัยคุกคามที่เกี่ยวข้องกับความปลอดภัยทางไซเบอร์ ได้อย่างมีประสิทธิภาพ ควรเขียนโค้ดหรือ "ฝัง" ระบบรักษาความปลอดภัยที่เหมาะสมลงในระบบ เมื่อมีการออกแบบระบบรักษาความปลอดภัยไว้ในซอฟต์แวร์แล้ว จะทำให้มั่นใจได้ว่าจะมีการป้องกันการโจมตีจากภายในและลดภัยคุกคามต่อความปลอดภัยของแอปพลิเคชัน^{[ 3 ]}การนำแนวทางการเขียนโค้ดที่ปลอดภัยมาใช้เป็นส่วนหนึ่งของแนวทางการออกแบบที่ปลอดภัยในด้านวิศวกรรม ความปลอดภัย

บัฟเฟอร์โอเวอร์โฟลว์ซึ่งเป็นช่องโหว่ด้านความปลอดภัยของซอฟต์แวร์ทั่วไป เกิดขึ้นเมื่อกระบวนการพยายามจัดเก็บข้อมูลเกินบัฟเฟอร์ที่มีความยาวคงที่ ตัวอย่างเช่น หากมีช่องสำหรับจัดเก็บรายการ 8 ช่อง จะเกิดปัญหาหากพยายามจัดเก็บ 9 รายการ ในหน่วยความจำคอมพิวเตอร์ ข้อมูลที่ล้นอาจเขียนทับข้อมูลในตำแหน่งถัดไป ซึ่งอาจส่งผลให้เกิดช่องโหว่ด้านความปลอดภัย ( stack smashing ) หรือการยุติโปรแกรม (segmentation fault) ^{[ 1 ]}

ตัวอย่างหนึ่งของ โปรแกรม ภาษาซีที่เสี่ยงต่อการเกิดบัฟเฟอร์โอเวอร์โฟลว์คือ

#include <string.h>#define SMALL 50void vulnerable_function ( char * large_user_input ) { char dst [ SMALL ]; strcpy ( dst , large_user_input ); }

หากข้อมูลที่ผู้ใช้ป้อนมีขนาดใหญ่กว่าบัฟเฟอร์ปลายทาง จะเกิดข้อผิดพลาดบัฟเฟอร์ล้น (buffer overflow)

เพื่อแก้ไขโปรแกรมที่ไม่ปลอดภัยนี้ ให้ใช้ strncpy เพื่อป้องกันปัญหาบัฟเฟอร์โอเวอร์โฟลว์ที่อาจเกิดขึ้น

#include <string.h>#define BUF_SIZE 100void secure_function ( char * user_input ) { char dst [ BUF_SIZE ]; // คัดลอกข้อมูลขนาดสูงสุด BUF_SIZE ไบต์strncpy ( dst , user_input , BUF_SIZE ); // ตั้งค่าอักขระตัวสุดท้ายในบัฟเฟอร์เป็น NUL dst [ BUF_SIZE - 1 ] = '\0' ; }

อีกทางเลือกที่ปลอดภัยกว่าคือการจัดสรรหน่วยความจำแบบไดนามิกบนฮีปโดยใช้ malloc

#include <stdlib.h> #include <string.h>char * secure_copy ( char * src ) { size_t len ​​= strlen ( src ); char * dst = ( char * ) malloc ( len + 1 ); if ( dst ) { strncpy ( dst , src , len ); // เพิ่มตัวจบสตริง null dst [ len ] = '\0' ; } return dst ; }

ในโค้ดตัวอย่างข้างต้น โปรแกรมพยายามคัดลอกเนื้อหาของsrcไปdstยัง ในขณะเดียวกันก็ตรวจสอบค่าส่งคืนของmalloc()เพื่อให้แน่ใจว่ามีการจัดสรรหน่วยความจำเพียงพอสำหรับบัฟเฟอร์ปลายทาง

การโจมตีด้วยสตริงรูปแบบ (Format String Attack)คือการที่ผู้ใช้ที่เป็นอันตรายป้อนข้อมูลเฉพาะที่จะถูกส่งเป็นอาร์กิวเมนต์ไปยังฟังก์ชันที่ทำการจัดรูปแบบ เช่นprintf()การโจมตีนี้เกี่ยวข้องกับการที่ผู้โจมตีอ่านหรือเขียนข้อมูลลงในสแต็ก

ฟังก์ชัน printf ในภาษา C จะเขียนผลลัพธ์ไปยัง stdout หากพารามิเตอร์ของฟังก์ชัน printf ไม่ได้รับการจัดรูปแบบอย่างถูกต้อง อาจทำให้เกิดช่องโหว่ด้านความปลอดภัยหลายประการ โปรแกรมด้านล่างนี้เป็นตัวอย่างของโปรแกรมที่เสี่ยงต่อการโจมตีด้วยสตริงรูปแบบ

#include <stdio.h>void vulnerable_print ( char * malicious_input ) { printf ( malicious_input ); }

อาร์กิวเมนต์ที่เป็นอันตรายที่ส่งไปยังโปรแกรมอาจเป็น "%s%s%s%s%s%s%s" ซึ่งอาจทำให้โปรแกรมหยุดทำงานเนื่องจากการอ่านหน่วยความจำที่ไม่ถูกต้อง

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

ด้านล่างนี้คือฟังก์ชันในภาษา C++ที่พยายามตรวจสอบว่าผลรวมของ x และ y น้อยกว่าหรือเท่ากับค่า MAX ที่กำหนดไว้หรือไม่:

#define MAX 5000bool sum_is_valid_flawed ( unsigned int x , unsigned int y ) { unsigned int sum = x + y ; return sum <= MAX ; }

ปัญหาของโค้ดนี้คือ มันไม่ได้ตรวจสอบการโอเวอร์โฟลว์ของจำนวนเต็มในการดำเนินการบวก หากผลรวมของ x และ y มากกว่าค่าสูงสุดที่เป็นไปได้ของจำนวนเต็มunsigned intการดำเนินการบวกจะเกิดการโอเวอร์โฟลว์และอาจส่งผลให้ได้ค่าที่น้อยกว่าหรือเท่ากับค่าสูงสุด แม้ว่าผลรวมของ x และ y จะมากกว่าค่าสูงสุดก็ตาม

ด้านล่างนี้คือฟังก์ชันที่ตรวจสอบการโอเวอร์โฟลว์โดยการยืนยันว่าผลรวมมากกว่าหรือเท่ากับทั้ง x และ y หากผลรวมเกิดการโอเวอร์โฟลว์ ผลรวมจะน้อยกว่า x หรือน้อยกว่า y

#define MAX 5000bool sum_is_valid_secure ( unsigned int x , unsigned int y ) { unsigned int sum = x + y ; return sum >= x && sum >= y && sum <= MAX ; }

ช่องโหว่การเข้าถึงไฟล์โดยไม่ได้รับอนุญาต (Path traversal) คือช่องโหว่ที่เส้นทางไฟล์ที่ได้รับจากแหล่งที่ไม่น่าเชื่อถือจะถูกตีความในลักษณะที่สามารถเข้าถึงไฟล์โดยไม่ได้รับอนุญาตได้

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

https://www.example.net/cgi-bin/article.sh?name=dogfood.html 

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

https://www.example.net/cgi-bin/article.sh?name=../../../../../etc/passwd 

ขึ้นอยู่กับสคริปต์ การโจมตีนี้อาจเปิดเผย ไฟล์ /etc/passwdซึ่งใน ระบบ ที่คล้าย Unixจะมีข้อมูล (เช่น) รหัสผู้ใช้ชื่อ ผู้ ใช้ใน การล็อกอิน เส้นทาง ไดเร็กทอรีโฮมและเชลล์ (ดูการโจมตีแบบ SQL injectionสำหรับการโจมตีที่คล้ายกัน)

แนวทางการเขียนโค้ดที่ปลอดภัยได้รับการกำหนดมากขึ้นเรื่อยๆ โดยกรอบการกำกับดูแลที่ควบคุมการพัฒนาและการบำรุงรักษาระบบซอฟต์แวร์ที่ประมวลผลข้อมูลที่ละเอียดอ่อนกฎความปลอดภัยของพระราชบัญญัติการพกพาและการรับผิดชอบด้านการประกันสุขภาพ (HIPAA) กำหนดให้หน่วยงานที่อยู่ภายใต้การคุ้มครองต้องปกป้องความสมบูรณ์ของข้อมูลสุขภาพที่ได้รับการ คุ้มครอง ผ่านการป้องกันทางเทคนิคภายใต้ 45 CFR 164.312(c)(1) และต้องนำกลไกไปใช้เพื่อตรวจสอบความถูกต้องของข้อมูลสุขภาพที่ได้รับการคุ้มครองทางอิเล็กทรอนิกส์ภายใต้ 45 CFR 164.312(c)(2) ^{[ 4 ]} ข้อกำหนด 6.2 ของมาตรฐานความปลอดภัยข้อมูลอุตสาหกรรมบัตรชำระเงิน (PCI DSS) เวอร์ชัน 4.0 กำหนดให้ซอฟต์แวร์ที่กำหนดเองต้องได้รับการพัฒนาอย่างปลอดภัย รวมถึงการฝึกอบรมนักพัฒนาในเทคนิคการเขียนโค้ดที่ปลอดภัย (6.2.2) การตรวจสอบโค้ดที่กำหนดเองเพื่อหาช่องโหว่ก่อนการเผยแพร่ (6.2.3) และการจัดการกับการโจมตีซอฟต์แวร์ทั่วไปในแนวทางการพัฒนา (6.2.4) ^{[ 5 ]}

• ความปลอดภัยของแอปพลิเคชัน
• การเขียนโปรแกรมเชิงป้องกัน
• ช่องโหว่ด้านความปลอดภัย