การพัฒนา AI ที่ปลอดภัย
Complete developer guide to building secure AI applications - from input validation to deployment
Updated: August 2026
หลักการด้านความปลอดภัย
1. การป้องกันเชิงลึก
Implement multiple layers of security controls. No single control should be relied upon exclusively.
2. สิทธิ์ขั้นต่ำ
ให้สิทธิ์ขั้นต่ำที่จำเป็นแก่ผู้ใช้, API และส่วนประกอบ AI
3. การรักษาความปลอดภัยล้มเหลว
เมื่อเกิดข้อผิดพลาด ให้ตั้งค่าเริ่มต้นเป็นสถานะการรักษาความปลอดภัยมากกว่าที่จะอนุญาต
4. Zero Trust
Never trust, always verify. Validate at every boundary, including internal systems.
การตรวจสอบอินพุต
All user input must be validated and sanitized before processing. This is your first line of defense against prompt injection and other attacks.
คลาสการตรวจสอบอินพุต
```python
import re
from typing import Optional, List
class InputValidator:
# Known injection patterns
INJECTION_PATTERNS = [
r"ignore\s+(previous|prior|all)\s+(instructions|rules)",
r"(forget|disregard)\s+(your|all)\s+(instructions|rules)",
r"you\s+are\s+(now|still)\s+(dan|do\s+anything)",
r"system\s+prompt:",
r"{{.*}}",
r"\[INST\]|\[/INST\]|<\|end\|>",
]
# Encoding patterns
ENCODING_PATTERNS = [
r"base64:", # Base64 prefix
r"\\x[0-9a-fA-F]{2}", # Hex encoding
r"%[0-9a-fA-F]{2}", # URL encoding
]
def validate(self, user_input: str) -> dict:
"""Validate user input for potential attacks."""
issues = []
# Length check
if len(user_input) > 10000:
issues.append("Input exceeds maximum length")
# Check for injection patterns
for pattern in self.INJECTION_PATTERNS:
if re.search(pattern, user_input, re.IGNORECASE):
issues.append(f"Suspicious pattern detected: {pattern}")
# Check for encoding attempts
for pattern in self.ENCODED_PATTERNS:
if re.search(pattern, user_input):
issues.append(f"Encoded content detected")
# Check for high entropy (possible encoding)
unique_chars = len(set(user_input))
if len(user_input) > 50 and unique_chars / len(user_input) < 0.3:
issues.append("High entropy detected - possible encoding")
return {
"valid": len(issues) == 0,
"issues": issues,
"sanitized": self._sanitize(user_input)
}
def _sanitize(self, user_input: str) -> str:
"""Basic sanitization."""
# Remove control characters
sanitized = re.sub(r'[\x00-\x1F\x7F]', '', user_input)
return sanitized.strip()
```
รายการตรวจสอบความถูกต้อง
- ตรวจสอบความถูกต้องที่ขอบเขตของแอปพลิเคชัน
- สร้างกฎการจัดการข้อมูลแล้ว
- การจับคู่รูปแบบสำหรับการฉีด
- ตรวจจับความพยายามในการเข้ารหัส
- การตรวจสอบประเภท
- ฆ่าเชื้อก่อนการประมวลผล
- ความล้มเหลวในการตรวจสอบบันทึก
- การจำกัดอัตรา
การจัดการเอาต์พุต
LLM outputs must be validated and sanitized before being presented to users or passed to other systems.
การกรองเนื้อหา
- ตรวจสอบการเปิดเผยข้อมูลที่ละเอียดอ่อน
- ตรวจสอบว่าไม่มีการแจ้งเตือนของระบบรั่วไหล
- ตรวจสอบรูปแบบเอาต์พุต
- ตรวจสอบเนื้อหาที่แทรก
การตรวจจับ PII
- สแกนหาข้อมูลส่วนบุคคล
- ปิดบังหรือแก้ไขข้อมูลที่ละเอียดอ่อน
- ความพยายามในการเปิดเผยบันทึก PII
- การแจ้งเตือนผู้ใช้เมื่อตรวจพบ
การตรวจสอบความถูกต้องของรูปแบบ
- ตรวจสอบความถูกต้องของเอาต์พุต JSON
- ตรวจสอบโครงสร้างที่คาดไว้
- ตรวจสอบค่าที่อนุญาต
- ฆ่าเชื้อ HTML หากมี
ตัวอย่างตัวจัดการเอาท์พุต
```python
import re
import json
class OutputHandler:
PII_PATTERNS = {
"ssn": r"\b\d{3}-\d{2}-\d{4}\b",
"email": r"\b[\w.-]+@[\w.-]+\.\w+\b",
"phone": r"\b\d{3}[-.]?\d{3}[-.]?\d{4}\b",
}
def process_output(self, raw_output: str) -> dict:
"""Process and validate LLM output."""
result = {
"original": raw_output,
"cleaned": raw_output,
"warnings": [],
"blocked": False
}
# Check for system prompt leakage
if "system prompt" in raw_output.lower():
result["warnings"].append("System prompt reference detected")
# Scan for PII
for pii_type, pattern in self.PII_PATTERNS.items():
matches = re.findall(pattern, raw_output)
if matches:
result["warnings"].append(f"{pii_type} detected in output")
# Optionally mask
result["cleaned"] = re.sub(pattern, "[REDACTED]", result["cleaned"])
return result
```
การรักษาความปลอดภัย API
การตรวจสอบสิทธิ์
- ใช้การจัดการคีย์ API ที่แข็งแกร่ง
- ใช้ OAuth 2.0 หากเป็นไปได้
- การตรวจสอบโทเค็น JWT
- การหมุนเวียนคีย์ API
การให้สิทธิ์
- การควบคุมการเข้าถึงตามบทบาท (RBAC)
- การกำหนดขอบเขตคีย์ API
- ขีดจำกัดอัตราต่อผู้ใช้
- การแยกผู้เช่า
การจำกัดอัตรา
- ขีดจำกัดตามโทเค็น
- ขีดจำกัดตามคำขอ
- การควบคุมต้นทุน
- การควบคุมแบบเป็นชั้น
รายการตรวจสอบความปลอดภัยของ API
- ใช้ HTTPS เท่านั้น
- การจำกัดอัตราการใช้งาน
- ตรวจสอบอินพุตทั้งหมด
- ฆ่าเชื้อเอาต์พุตทั้งหมด
- ใช้คีย์ API ที่ไม่ฝังตัว
- ใช้การลงนามคำขอ||ใช้รายการตรวจสอบเหล่านี้เพื่อให้แน่ใจว่ามีการทดสอบความปลอดภัยอย่างละเอียดและถูกกฎหมาย
- การเข้าถึง API ของบันทึก
- ใช้ CORS อย่างถูกต้อง
การตรวจสอบสิทธิ์และการอนุญาต
การตรวจสอบสิทธิ์ผู้ใช้
- นโยบายรหัสผ่านที่แข็งแกร่ง
- การสนับสนุน MFA
- การจัดการเซสชัน
- การหมดอายุของโทเค็น
การตรวจสอบสิทธิ์ API
- การจัดการคีย์ API
- ขอบเขต OAuth
- การตรวจสอบ JWT
- การหมุนเวียนคีย์
การให้สิทธิ์
- การใช้งาน RBAC
- การตรวจสอบสิทธิ์
- การเข้าถึงระดับทรัพยากร
- การบันทึกการตรวจสอบ
ความปลอดภัยของข้อมูล
การจำแนกประเภทข้อมูล
- ระบุข้อมูลที่ละเอียดอ่อน
- จัดหมวดหมู่ตามความไว
- ใช้การควบคุมตามหมวดหมู่
- การตรวจสอบปกติ
การเข้ารหัส
- TLS ระหว่างทาง
- AES ที่เหลือ
- การจัดการคีย์
- การหมุนเวียนคีย์
การจัดการ PII
- การตรวจจับ
- การย่อขนาด
- การจัดการความยินยอม
- สิทธิ์ในการลบ
การบันทึกและการตรวจสอบ
สิ่งที่ต้องบันทึก
เหตุการณ์ด้านความปลอดภัย
- ความพยายามในการตรวจสอบสิทธิ์
- ความล้มเหลวในการอนุญาต
- เกินขีดจำกัดอัตรา
- รูปแบบที่น่าสงสัย
เหตุการณ์เฉพาะของ AI
- ความพยายามในการแทรกทันที
- การเข้าถึงพร้อมท์ของระบบ
- การเรียกใช้เครื่องมือ
- การเข้าถึงข้อมูลผ่าน AI
เหตุการณ์การปฏิบัติงาน
- การเรียก API
- ข้อผิดพลาดและข้อยกเว้น
- ตัววัดประสิทธิภาพ
- การติดตามต้นทุน
การตรวจสอบแนวทางปฏิบัติที่ดีที่สุด
- การแจ้งเตือนแบบเรียลไทม์สำหรับเหตุการณ์ด้านความปลอดภัย
- แดชบอร์ดสำหรับการวัดความปลอดภัย
- การตรวจจับความผิดปกติอัตโนมัติ
- การบูรณาการกับ SIEM
- การตรวจสอบบันทึกปกติ
- นโยบายการเก็บรักษา
ช่องโหว่ทั่วไป
1. IDOR ในคุณสมบัติ AI
การอ้างอิงวัตถุโดยตรงที่ไม่ปลอดภัยเมื่อ AI เข้าถึงทรัพยากร
ตัวอย่าง
User asks AI to "read file X" and AI has access without proper authorization checks.
2. SSRF ผ่าน LLM
การปลอมแปลงคำขอฝั่งเซิร์ฟเวอร์ผ่านการเรียกเครื่องมือ AI
ตัวอย่าง
พร้อมท์หลอก AI ให้ส่งคำขอไปยังบริการภายใน
3. บายพาสการตรวจสอบสิทธิ์
การรับรองความถูกต้องที่อ่อนแอหรือขาดหายไปสำหรับตำแหน่งข้อมูล AI
ตัวอย่าง
จุดสิ้นสุด AI API โดยไม่มีการตรวจสอบสิทธิ์ที่เหมาะสม
4. Vector DB Exposure
ฐานข้อมูลเวกเตอร์ที่ไม่มีการป้องกันด้วยการฝังที่ละเอียดอ่อน
ตัวอย่าง
ฐานข้อมูลเวกเตอร์ที่เข้าถึงได้แบบสาธารณะพร้อมข้อมูลที่ละเอียดอ่อนฝังอยู่
การปฏิบัติตามข้อกำหนด
GDPR (EU)
- พื้นฐานทางกฎหมายสำหรับการประมวลผล
- การลดขนาดข้อมูล
- ขวา เพื่อเข้าถึง/ลบ
- การเคลื่อนย้ายข้อมูล
CCPA (California)
- สิทธิ์ที่จะรู้
- สิทธิ์ในการลบ
- สิทธิ์ในการเลือกไม่รับ
- การไม่เลือกปฏิบัติ
เฉพาะ AI
- ข้อกำหนดของพระราชบัญญัติ AI ของสหภาพยุโรป
- การประเมินความเสี่ยงของ AI
- ภาระหน้าที่ด้านความโปร่งใส
- การควบคุมดูแลโดยมนุษย์