กฎ 24 ข้อในการเขียนซีจีไอสคริปต์ให้มีความปลอดภัย

[bigaun]

ชื่อเรื่อง : กฎ 24 ข้อในการเขียนซีจีไอสคริปต์ให้มีความปลอดภัย
เรียบเรียงโดย : ดร. บรรจง หะรังษี
เผยแพร่เมื่อ : 8 กันยายน 2547

ซีจีไอสคริปต์ (CGI scripts) คือโปรแกรมที่ผู้พัฒนาพัฒนาขึ้นมาเพื่อให้สามารถทำงานตามความต้องการทางธุรกิจ เช่น โปรแกรมสำหรับขายสินค้าบนเว็บ โปรแกรมสำหรับสนทนาบนเว็บ โปรแกรมเว็บบอร์ด โปรแกรมเล่นเกมบนเว็บ หรืออื่นๆ อีกมากมายที่ผู้ใช้ได้พบเห็นและอาจใช้งานกันอยู่ในขณะที่ทำการท่องเว็บไปบนอินเทอร์เน็ต โปรแกรมเหล่านี้จะทำงานอยู่บนเว็บเซิร์ฟเวอร์โดยทั่วไปเพื่อคอยให้บริการแก่ผู้ที่เข้าไปใช้งาน ซึ่งอาจพัฒนาขึ้นมาด้วยภาษาโปรแกรมมิ่งต่างๆ อาทิ Perl PHP ASP Python หรืออื่นๆ อีกมากมาย

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

1. กำหนดความต้องการใช้งาน (System requirement) ให้ชัดเจน

ให้กำหนดความต้องการใช้งานให้ชัดเจนโดยเฉพาะอย่างยิ่งความต้องการทางด้านความปลอดภัย (Security requirement) เช่น

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

2. ออกแบบโปรแกรมอย่างระมัดระวังก่อนที่จะลงมือพัฒนา

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

3. ให้ผู้พัฒนาอื่นๆ ช่วยตรวจสอบสเป็คโปรแกรมให้

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

4. เลือกใช้ภาษาโปรแกรมมิ่งที่ดีสำหรับการพัฒนาโปรแกรม

ภาษาโปรแกรมมิ่งที่ดี ได้แก่ Perl PHP Python เป็นต้น ภาษาเหล่านี้เป็นภาษาที่ผู้พัฒนาบนอินเทอร์เน็ตได้ใช้งานมาเป็นเวลาหลายปีแล้ว และเป็นที่ยอมรับกันอย่างแพร่หลายและกว้างขวาง รวมทั้งให้เลือกภาษาที่สามารถช่วยแก้ปัญหาหน่วยความจำล้น (Buffer overflow) ภาษาทั้งสามสามารถช่วยป้องกันปัญหานี้ได้ นอกจากนั้นแล้วภาษาเหล่านี้ยังมีซอฟต์แวร์ไลบรารีเพื่อช่วยในการพัฒนาโปรแกรมเป็นจำนวนมาก

5. ใช้ซอฟต์แวร์ไลบรารีหรือโปรแกรมที่มีผู้พัฒนาเอาไว้แล้ว

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

6. พัฒนาและทดสอบโปรแกรมทีละส่วน ส่วนละสั้นๆ

การพัฒนาและทดสอบโปรแกรมที่ดีควรทำทีละส่วน ส่วนละสั้นๆ เช่น ฟังก์ชันที่มีขนาดไม่เกิน 50 บรรทัด เมื่อทดสอบเรียบร้อยแล้ว จึงก้าวไปสู่ส่วนถัดไป การทดสอบส่วนสั้นๆ ควรจะได้ทดสอบกับข้อมูลที่คาดว่าน่าจะเกิดขึ้นจริง และข้อมูลที่ไม่น่าจะเกิดขึ้นจริง เพื่อดูว่าโปรแกรมสามารถจัดการได้ในทั้งสองกรณี

7. ตรวจสอบค่าทุกค่าที่โปรแกรมรับเข้ามา

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

8. ตรวจสอบค่าที่ส่งผ่านเข้าไปในฟังก์ชันซึ่งอยู่ในไลบรารีของระบบ

กฎข้อนี้เสริมกฎข้อ 7 เพียงแต่เน้นว่า แม้ว่าค่าที่รับเข้ามานั้นจะถูกส่งผ่านเข้าไปในฟังก์ชันของไลบรารีของระบบ เช่น ไลบรารีของระบบปฏิบัติการ ซึ่งควรจะได้ตรวจสอบค่าที่ส่งเข้าไปให้นั้น ผู้พัฒนาก็ไม่อาจจะวางใจได้ 100 เปอร์เซ็นต์ว่าจะมีการตรวจสอบให้ ดังนั้นผู้พัฒนาควรจะได้ทำการตรวจสอบค่าทุกค่าก่อนที่จะส่งผ่านเข้าไปในฟังก์ชันของไลบรารี
ตัวอย่างเช่น สมมติว่าโปรแกรมต้องการเปิดไฟล์ขึ้นมาใช้งานจากไดเรกทอรีปัจจุบัน เมื่อโปรแกรมรับค่าซึ่งเป็นชื่อของไฟล์เข้ามาแล้ว ให้ทำการตรวจสอบว่าชื่อไฟล์มีเครื่องหมาย "/" ปรากฎร่วมอยู่ด้วยหรือไม่ (อาจใช้ฟังก์ชัน index() เพื่อช่วยตรวจสอบ) ในความเป็นจริงแล้วชื่อไฟล์ไม่ควรมีเครื่องหมายดังกล่าวร่วมอยู่ด้วย หากมี แสดงว่าค่าที่รับเข้ามาอาจประกอบไปด้วยทั้งชื่อไดเรกทอรีและชื่อไฟล์ร่วมกัน โดยที่ผู้พัฒนาต้องการเฉพาะชื่อไฟล์เท่านั้น โปรแกรมจึงควรแจ้งข้อผิดพลาดนี้ให้ผู้ใช้ได้รับทราบต่อไป

9. ตรวจสอบค่าให้ตรงกับที่โปรแกรมต้องการ

กฎข้อนี้เสริมกฎข้อ 7 เพียงแต่เน้นว่า ค่าที่โปรแกรมรับเข้ามาจะต้องตรงกับที่โปรแกรมต้องการ เช่น โปรแกรมต้องการค่าที่เป็น 1, 2 หรือ 3 เท่านั้น เมื่อรับค่าเข้ามาแล้ว โปรแกรมต้องตรวจสอบว่ามีค่าเป็น 1, 2 หรือ 3 หรือไม่ หากไม่เป็น จะต้องแจ้งข้อผิดพลาดที่เกิดขึ้นนี้ให้ผู้ใช้ได้รับทราบต่อไป (ในภาษา C มี มาโคร assert ซึ่งสามารถช่วยตรวจสอบในลักษณะนี้ได้)

10. ตรวจสอบโค้ดแสดงสถานภาพทำงาน

ให้ตรวจสอบโค้ดที่ใช้แสดงสถานภาพทำงาน เช่น โค้ดที่เกิดจากการเรียกใช้งานฟังก์ชันในไลบรารีของระบบปฏิบัติการ ตัวอย่างเช่น ฟังก์ชัน open(), chdir(), chown() เป็นต้น POSIX ซึ่งกำหนดมาตรฐานของภาษาโปรแกรมมิ่ง (ภาษา C และ Perl ใช้มาตรฐานนี้) ได้กำหนดไว้ว่าทุกฟังก์ชันในไลบรารีของระบบจะต้องมีโค้ดแสดงสถานภาพทำงานเพื่อส่งกลับไปให้ผู้ที่เรียกใช้งานเพื่อให้สามารถตรวจสอบผลการทำงานได้ ดังนั้นเมื่อโปรแกรมตรวจสอบจากโค้ดดังกล่าวแล้วและพบว่ามีความผิดพลาดเกิดขึ้น ก็อาจจะยุติการทำงานลงทันที

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

เวลาที่โปรแกรมทำงาน
หมายเลขโปรเซส (Process ID)
ค่าที่โปรแกรมรับเข้ามาเป็นอินพุท
ค่าที่โปรแกรมเขียนออกไปเป็นเอาท์พุท
IP Address ของเครื่องลูกข่ายที่เข้ามาใช้งานโปรแกรม เป็นต้น
อีกวิธีหนึ่งในการเก็บข้อมูลล็อกสำหรับบนระบบปฏิบัติการยูนิกส์/ลินุกซ์ คือใช้ฟังก์ชัน syslog() เพื่อช่วยในการบันทึกล็อก ข้อดีของวิธีการนี้คือข้อมูลล็อกที่บันทึกไว้สามารถบันทึกลงไฟล์ ส่งต่อไปให้อีกโปรแกรมหนึ่ง หรือแม้กระทั่งส่งไปยังอีกเครื่องคอมพิวเตอร์หนึ่ง ต้องไม่ลืมที่จะตรวจสอบค่าที่ส่งผ่านเข้าไปที่ฟังก์ชัน syslog เพื่อป้องกันปัญหาข้างเคียง เช่น ปัญหาหน่วยความจำล้น

12. พัฒนาโปรแกรมส่วนที่สำคัญมากๆ ให้มีขนาดเล็กและเรียบง่ายที่สุด

กฎข้อนี้มีทิศทางเดียวกับข้อ 6 ที่ให้พัฒนาฟังก์ชันมีขนาดไม่เกิน 50 บรรทัด ทั้งนี้เนื่องจากโปรแกรมในส่วนที่สำคัญมากๆ นี้ควรจะสามารถอ่านและทำความเข้าใจได้อย่างง่ายและรวดเร็วที่สุด เพื่อให้ลดความผิดพลาดในการเขียนโปรแกรมนั่นเอง

13. ใช้ชื่อไดเรกทอรีแบบเต็ม (full path names) เมื่อจำเป็นต้องอ้างถึงชื่อไฟล์

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

14. ให้ระวังปัญหาการแย่งชิงทรัพยากรในระบบกันระหว่างโปรแกรมตั้งแต่สองโปรแกรมขึ้นไป

ปัญหาการแย่งชิงทรัพยากรในระบบเป็นที่รู้จักหรือเรียกกันว่าปัญหา race conditions ทรัพยากรในระบบ ได้แก่ ไฟล์ต่างๆ ที่มีการใช้งานร่วมกัน การอธิบายในหัวข้อนี้จะใช้ตัวอย่างของโปรแกรมสองโปรแกรมแย่งชิงทรัพยากรกัน

ตัวอย่างของปัญหาการแย่งชิงทรัพยากรที่อาจเกิดขึ้นได้

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

15. ตรวจสอบสิทธิของไฟล์ของโปรแกรมให้เหมาะสม

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

16. ไม่สร้างไฟล์ไว้ในไดเรกทอรีที่ผู้อื่นสามารถบันทึกแทนที่ได้

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

17. ระมัดระวังการปลอมแปลง IP Address ของเครื่องลูกข่ายที่เข้ามาใช้บริการจากโปรแกรม

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

18. จำกัดปริมาณโหลดจากเครื่องลูกข่ายที่ขอใช้บริการ

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

19. กำหนดระยะเวลาที่โปรแกรมจะตัดการทำงานของเครื่องลูกข่าย

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

20. จัดเก็บโปรแกรมทั้งหมดไว้ในที่เดียวกัน

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

21. ไม่ส่งชื่อบัญชีผู้ใช้และรหัสผ่านจากเครื่องลูกข่ายมายังเว็บเซิร์ฟเวอร์

ข้อบกพร่องอย่างหนึ่งของโปรโตคอล TCP/IP คือข้อมูลที่มีการส่งไปมาบนเครือข่ายสามารถถูกดักดูข้อมูลได้ ข้อมูล เช่น ชื่อบัญชีผู้ใช้และรหัสผ่าน หากมิได้มีการเข้ารหัสก่อนที่จะส่งไป ก็อาจถูกดักดูได้โดยผู้บุกรุกเช่นกัน ดังนั้นในการพัฒนาโปรแกรมในส่วนของการพิสูจน์ตัวตน ให้ใช้วิธีอื่นในการส่งชื่อบัญชีผู้ใช้และรหัสผ่าน เช่น เข้ารหัสข้อมูลก่อนส่งไป อาทิ ด้วยกลไกของ SSL (Secure Socket Layer) ใช้ใบรับรองอิเล็กทรอนิกส์ในส่วนของผู้ใช้ เป็นต้น

22. ทดสอบโปรแกรมโดยละเอียดโดยเฉพาะอย่างยิ่งในส่วนของความต้องการทางด้านความปลอดภัย

ความต้องการทางด้านความปลอดภัย (Security requirement) เช่นที่กำหนดไว้เป็นตัวอย่างในกฎข้อ 1 ผู้พัฒนาจะต้องทำการทดสอบว่าโปรแกรมทำงานตามที่ต้องการหรือไม่ และมีความปลอดภัยอยู่ในระดับใด

23. ติดตามโปรแกรมอุดช่องโหว่อย่างสม่ำเสมอสำหรับภาษาโปรแกรมมิ่งที่ใช้ในการพัฒนาซีจีไอสคริปต์

ติดตามโปรแกรมอุดช่องโหว่ได้จากเว็บไซต์หลักของภาษาโปรแกรมมิ่งนั้น เช่น

สำหรับภาษา Perl เว็บไซต์คือ http://www.perl.com
สำหรับภาษา PHP เว็บไซต์คือ http://www.php.net เป็นต้น
24. ตรวจสอบช่องโหว่บนเว็บเซิร์ฟเวอร์ด้วยซอฟต์แวร์ทูลประเภทสแกนเนอร์

ตรวจสอบช่องโหว่บนเว็บเซิร์ฟเวอร์ ซึ่งรวมถึงซีจีไอสคริปต์ต่างๆ ที่ทำงานอยู่บนเซิร์ฟเวอร์ ด้วยทูลประเภทสแกนเนอร์ เช่น

Nikto สามารถดูข้อมูลเพิ่มเติมได้ที่เว็บ http://www.cirt.net/code/nikto.shtml
N-Stalker สามารถดูข้อมูลเพิ่มเติมได้ที่เว็บ http://www.nstalker.com/eng/products/products.php
Nessus สามารถดูข้อมูลเพิ่มเติมได้ที่เว็บ http://www.nessus.org
บทส่งท้าย

ยังมีแหล่งข้อมูลที่ดีๆ และน่าสนใจที่มีข้อมูลเกี่ยวกับการเขียนซีจีไอสคริปต์ให้มีความปลอดภัยอยู่อีกเป็นจำนวนมาก อาทิ

The World Wide Web Security FAQ - http://www.w3.org/Security/faq/www-security-faq.html
Writing Secure ASP Scripts - http://www.nextgenss.com/papers/asp.pdf
Writing Secure Scripts - http://manual.intl.indoglobal.com/ch07s03.html
ซึ่งผู้อ่านที่สนใจสามารถทำการสืบค้นเพิ่มเติมได้ บทความนี้จะได้ทำการปรับปรุงเนื้อหาตามระยะเวลาที่เหมาะสมอย่างสม่ำเสมอ ทั้งนี้เพื่อให้มีความทันสมัยและมีความครบถ้วนมากขึ้น

บรรณานุกรม

1. 21 Rules for Writing Secure CGI Programs By Simson Garfinkel - http://thinkunix.net/web/cgi-rules.txt

[bigaun]

เอาไปใช้กะ topic ได้นะจ๊ะ หนูๆ

[Inception]

พอเจออารัยมีความรู้ แล้วเริ่มเกิดอาการมึนๆ