การเขียนโค้ดให้ปลอดภัย: เทคนิคการป้องกันการโจมตีในเว็บแอป

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

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

1. การป้องกัน SQL Injection

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

วิธีป้องกัน SQL Injection

1. ใช้ Prepared Statements หรือ Parameterized Queries

การใช้วิธีนี้เป็นวิธีที่ปลอดภัยที่สุดในการป้องกัน SQL Injection เพราะจะทำให้คำสั่ง SQL และข้อมูลที่ผู้ใช้กรอกถูกแยกออกจากกันอย่างชัดเจน

• ในการใช้ Prepared Statements ข้อมูลที่ผู้ใช้กรอกจะไม่สามารถแทรกคำสั่ง SQL ได้
• ระบบจะสร้างคำสั่ง SQL ที่มีตัวแปรที่รอการแทนที่ โดยไม่สามารถแทรกคำสั่ง SQL ที่เป็นอันตรายเข้าไปได้

2. ใช้ ORM (Object-Relational Mapping)

เครื่องมือ ORM อย่าง Django ORM หรือ SQLAlchemy จะช่วยให้การเชื่อมต่อกับฐานข้อมูลปลอดภัยยิ่งขึ้น เพราะมันสร้างคำสั่ง SQL โดยอัตโนมัติและป้องกันการโจมตี SQL Injection

3. หลีกเลี่ยงการใช้คำสั่ง SQL ที่ไม่ปลอดภัย

หลีกเลี่ยงการใช้คำสั่ง SQL ที่รวมข้อมูลจากผู้ใช้โดยตรง เช่น การใช้ CONCAT() หรือ EXECUTE() กับข้อมูลที่ผู้ใช้กรอก เพราะสิ่งนี้อาจเปิดช่องทางให้แฮกเกอร์สามารถโจมตีได้

ตัวอย่างการป้องกัน SQL Injection ด้วย Parameterized Queries (ในภาษา Python)

python

# ใช้ parameterized query กับ SQL
cursor.execute("SELECT * FROM users WHERE username = %s AND password = %s", (username, password))

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

2. การเข้ารหัสข้อมูล (Encryption)

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

วิธีป้องกันการดักจับข้อมูล

1. ใช้ HTTPS (SSL/TLS)

การใช้โปรโตคอล HTTPS สำหรับการส่งข้อมูลระหว่างผู้ใช้และเซิร์ฟเวอร์จะช่วยเข้ารหัสข้อมูลที่ส่งผ่านอินเทอร์เน็ต ทำให้ข้อมูลที่ส่งผ่านไม่สามารถถูกดักจับหรือถูกแก้ไขได้ระหว่างทาง ด้วยการใช้ SSL/TLS (Secure Sockets Layer/Transport Layer Security) ซึ่งจะช่วยให้การสื่อสารเป็นแบบเข้ารหัสและปลอดภัย

การใช้ HTTPS จะช่วยให้ผู้ใช้มั่นใจได้ว่า ข้อมูลของเขาจะถูกส่งในรูปแบบที่ปลอดภัย ซึ่งลดโอกาสที่จะเกิดการโจมตีจากแฮกเกอร์ที่ต้องการดักจับข้อมูล

2. เข้ารหัสข้อมูลในฐานข้อมูล

แม้ว่าจะมีการเข้ารหัสข้อมูลระหว่างการส่งข้อมูล แต่ข้อมูลที่เก็บอยู่ในฐานข้อมูลก็ยังคงต้องการการป้องกันเช่นกัน การใช้เทคนิคการเข้ารหัสข้อมูลในฐานข้อมูล เช่น การใช้ bcrypt , argon2 หรือ AES (Advanced Encryption Standard) ช่วยให้ข้อมูลในฐานข้อมูลได้รับการปกป้องจากการถูกดักจับหรือเข้าถึงโดยบุคคลที่ไม่ได้รับอนุญาต

3. การใช้ Hashing สำหรับรหัสผ่าน

รหัสผ่านไม่ควรเก็บในฐานข้อมูลในรูปแบบที่สามารถอ่านได้ แต่ควรใช้ Hashing เพื่อให้ข้อมูลรหัสผ่านถูกแปลงเป็นข้อความที่ไม่สามารถย้อนกลับได้ นอกจากนี้การใช้ Salts (การเพิ่มค่าเฉพาะตัวเข้าไปในรหัสผ่านก่อนการแฮช) จะช่วยเพิ่มความปลอดภัยได้อีกชั้น

ตัวอย่างการเข้ารหัสรหัสผ่านด้วย bcrypt

python

from bcrypt import hashpw, gensalt

# เข้ารหัสรหัสผ่าน
hashed_password = hashpw(password.encode('utf-8'), gensalt())

ในตัวอย่างนี้ เรากำลังใช้ bcrypt เพื่อทำการแฮชรหัสผ่านของผู้ใช้ ด้วยการใช้ gensalt() เพื่อเพิ่มค่า Salt ที่จะทำให้รหัสผ่านที่ถูกแฮชไม่สามารถเดาได้ง่าย โดยจะช่วยป้องกันการโจมตีประเภท Rainbow Table Attacks ที่สามารถทำให้แฮกเกอร์เดารหัสผ่านได้จากข้อมูลที่ถูกแฮช

3. การป้องกัน Cross-Site Scripting (XSS)

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

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

วิธีการป้องกัน XSS

1. ใช้ Content Security Policy (CSP)

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

2. การกรองข้อมูลที่ผู้ใช้ป้อน (Sanitization)

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

3. การเอสเคป (Escaping) ข้อมูลที่แสดงผล

เมื่อแสดงผลข้อมูลที่มาจากผู้ใช้ในหน้าเว็บ ควรใช้วิธีการ escaping เพื่อป้องกันไม่ให้ข้อมูลนั้นเป็นสคริปต์ที่สามารถทำงานได้ การเอสเคปคือการเปลี่ยนสัญลักษณ์ที่สำคัญใน HTML (เช่น  <  , > ,  &  ) ให้เป็นตัวอักษรที่ไม่สามารถทำงานได้ในโค้ด HTML หรือ JavaScript

ตัวอย่าง: การกรองข้อมูลที่ผู้ใช้ป้อน

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

python

import bleach

# กรองข้อมูลที่ผู้ใช้ป้อน
sanitized_input = bleach.clean(user_input)

ในตัวอย่างนี้ฟังก์ชัน `bleach.clean()` จะลบหรือทำให้ข้อมูลที่ผู้ใช้ป้อนมาเป็นข้อความที่ปลอดภัยและไม่สามารถทำการโจมตีได้

4. การจัดการ Session ที่ปลอดภัย

การจัดการ Session เป็นเรื่องสำคัญในการรักษาความปลอดภัยของข้อมูลผู้ใช้บนเว็บแอป โดยเฉพาะอย่างยิ่งในกรณีที่เกี่ยวข้องกับการล็อกอินและการรักษาข้อมูลที่สำคัญหลังจากที่ผู้ใช้เข้าสู่ระบบ การโจมตีประเภท Session Hijacking เป็นการขโมยข้อมูล session ของผู้ใช้ที่กำลังล็อกอินอยู่ โดยแฮกเกอร์อาจใช้ข้อมูลนี้ในการเข้าถึงข้อมูลสำคัญ เช่น ข้อมูลบัญชีผู้ใช้ หรือข้อมูลส่วนตัวอื่น ๆ

การป้องกันการโจมตีประเภทนี้จึงเป็นเรื่องสำคัญที่นักพัฒนาต้องคำนึงถึงในกระบวนการพัฒนาเว็บแอป

วิธีการป้องกัน Session Hijacking

1. ใช้ HttpOnly และ Secure flags สำหรับคุกกี้

การใช้ HttpOnly flag กับคุกกี้ช่วยป้องกันไม่ให้ข้อมูลในคุกกี้ถูกเข้าถึงผ่าน JavaScript ซึ่งเป็นการลดความเสี่ยงจากการโจมตีแบบ Cross-Site Scripting (XSS) ที่อาจทำให้แฮกเกอร์สามารถเข้าถึงข้อมูลคุกกี้ได้

ส่วน Secure flag จะทำให้คุกกี้ถูกส่งผ่าน HTTPS เท่านั้น ทำให้ไม่สามารถถูกขโมยข้อมูลระหว่างการส่งข้อมูลที่ไม่ปลอดภัย

2. หมดอายุ Session หลังจากเวลาที่กำหนด (Session Expiration)

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

3. ตรวจสอบ IP Address และ User-Agent

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

ตัวอย่าง: การตั้งคุกกี้ HttpOnly และ Secure

การตั้งค่าคุกกี้ให้มี HttpOnly และ Secure flags ใน Python (Flask) สามารถทำได้ดังนี้

python

# กำหนดคุกกี้ HttpOnly และ Secure
response.set_cookie('session_id', session_id, httponly=True, secure=True)

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

5. การตรวจสอบและการอัปเดตอย่างสม่ำเสมอ

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

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

วิธีการป้องกัน

1. อัปเดตไลบรารีและเครื่องมือที่ใช้

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

2. ใช้เครื่องมือในการตรวจสอบความปลอดภัยของไลบรารี

เช่นการใช้ OWASP Dependency-Check หรือเครื่องมืออื่น ๆ เพื่อตรวจสอบช่องโหว่ที่อาจมีอยู่ในไลบรารีที่เราใช้ในการพัฒนาเว็บแอป

3. ตรวจสอบช่องโหว่ที่มีการรายงานจากชุมชนและผู้พัฒนา

เมื่อมีการค้นพบช่องโหว่ในไลบรารีหรือเครื่องมือที่เราใช้ เราควรรีบอัปเดตให้ทันที หรือหากไม่สามารถอัปเดตได้ทันที ควรหาวิธีการปิดช่องโหว่นั้นอย่างรวดเร็ว

ตัวอย่าง

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

bash

pip install --upgrade <package_name>

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

การตรวจสอบช่องโหว่ในไลบรารีที่ใช้งาน

การใช้เครื่องมือ OWASP Dependency-Check เพื่อตรวจสอบช่องโหว่ในไลบรารีที่ใช้ในโปรเจกต์สามารถช่วยป้องกันการโจมตีจากการใช้ไลบรารีที่มีช่องโหว่ที่รู้จักได้

bash

dependency-check --project <project_name> --scan <directory_to_scan>

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

สรุป

การพัฒนาเว็บแอปที่ปลอดภัยต้องให้ความสำคัญกับหลายด้าน เช่น การป้องกัน SQL Injection, การเข้ารหัสข้อมูล, การป้องกัน XSS, การจัดการ session ที่ปลอดภัย และการอัปเดตซอฟต์แวร์อย่างสม่ำเสมอ การใช้เทคนิคเหล่านี้จะช่วยให้เว็บแอปของคุณปลอดภัยจากการโจมตีและรักษาข้อมูลของผู้ใช้งานได้อย่างมั่นคง

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

🔵 Facebook: Superdev School  (Superdev)

📸 Instagram: superdevschool

🎬 TikTok: superdevschool

🌐 Website: www.superdev.school