วิธีสร้าง Local AI Firewall: ตั้งกฎควบคุมข้อมูลขาออกก่อนส่งถึง Cloud AI ด้วย Proxy + Ollama แบบออฟไลน์ 100%

คุณเคยสงสัยไหมว่า แอปพลิเคชันที่คุณใช้งานอยู่ทุกวัน — ไม่ว่าจะเป็น IDE, เครื่องมือจดโน้ต หรือแม้แต่เบราว์เซอร์ Extension — แอบส่งข้อมูลอะไรของคุณไปยังเซิร์ฟเวอร์ AI บ้าง?

ปัจจุบันเครื่องมือจำนวนมากฝัง AI Feature เข้ามาในตัว โดยที่ผู้ใช้อาจไม่รู้ตัวด้วยซ้ำว่าข้อมูลถูกส่งออก ไม่ว่าจะเป็นโค้ดใน Editor, ข้อความที่พิมพ์, หรือแม้แต่ Metadata ของไฟล์ที่คุณเปิดอยู่ นี่คือเหตุผลที่คุณต้องมี AI Firewall ของตัวเอง

AI Firewall คืออะไร และต่างจาก PII Scrubber อย่างไร?

หากคุณอ่านบทความเรื่อง PII Scrubber ไปแล้ว จะรู้ว่ามันทำหน้าที่ "ฟอก" ข้อมูลส่วนตัวออกก่อนส่ง — เป็นการทำงานแบบ ตั้งรับ (Reactive) ที่ต้องเรียกใช้ทีละครั้ง

แต่ AI Firewall ทำงานต่างออกไป — มันเป็นด่านตรวจที่ทำงาน อัตโนมัติตลอดเวลา (Always-on) คอยสกัดกั้นข้อมูลที่กำลังจะออกจากเครือข่ายของคุณ โดยคุณไม่ต้องทำอะไรเพิ่มเลย

สถาปัตยกรรม: Proxy + Ollama Classifier

แนวคิดหลักคือการวาง mitmproxy (Transparent Proxy) ไว้เป็นด่านหน้าที่ดักจับทุก HTTP/HTTPS Request ที่ออกจากเครื่อง แล้วใช้ Ollama เป็น Classifier ตรวจสอบเนื้อหาว่ามีข้อมูลละเอียดอ่อนหรือไม่

แอปพลิเคชันต่าง ๆ
       │
       ▼
┌─────────────────┐
│   mitmproxy     │  ← ดักจับ Request ขาออก
│   (Port 8080)   │
└────────┬────────┘
         │
         ▼
┌─────────────────┐
│  Ollama         │  ← วิเคราะห์เนื้อหา
│  (Classifier)   │     "มีข้อมูลละเอียดอ่อนไหม?"
└────────┬────────┘
         │
    ┌────┴────┐
    │         │
  ปลอดภัย   อันตราย
    │         │
    ▼         ▼
  ส่งต่อ    บล็อก + บันทึก Log

ขั้นตอนที่ 1: ติดตั้งเครื่องมือ

ก่อนอื่นให้ติดตั้ง mitmproxy และตรวจสอบว่า Ollama พร้อมใช้งาน:

# ติดตั้ง mitmproxy
pip install mitmproxy

# ตรวจสอบ Ollama
ollama list
# ควรเห็นโมเดลอย่างน้อย 1 ตัว เช่น llama3.2, qwen2.5 เป็นต้น

ขั้นตอนที่ 2: เขียน Addon Script สำหรับ mitmproxy

สร้างไฟล์ ai_firewall.py ที่ทำหน้าที่วิเคราะห์ทุก Request ขาออก:

import json
import subprocess
from mitmproxy import http

# โดเมน AI ที่ต้องตรวจสอบ
AI_DOMAINS = [
    "api.openai.com",
    "api.anthropic.com",
    "generativelanguage.googleapis.com",
    "api.mistral.ai",
    "api.cohere.ai",
]

BLOCK_LOG = "blocked_requests.jsonl"

def classify_content(text: str) -> bool:
    """ใช้ Ollama ตรวจว่าข้อความมีข้อมูลละเอียดอ่อนหรือไม่"""
    prompt = f"""Classify if the following text contains sensitive data
(passwords, API keys, personal addresses, financial info, medical records).
Reply ONLY "SAFE" or "SENSITIVE".

Text: {text[:2000]}"""

    result = subprocess.run(
        ["ollama", "run", "llama3.2", "--nowordwrap"],
        input=prompt,
        capture_output=True,
        text=True,
        timeout=10,
    )
    return "SENSITIVE" in result.stdout.upper()

class AIFirewall:
    def request(self, flow: http.HTTPFlow) -> None:
        host = flow.request.pretty_host
        if not any(domain in host for domain in AI_DOMAINS):
            return

        body = flow.request.get_text()
        if not body:
            return

        if classify_content(body):
            # บล็อก Request และบันทึก Log
            flow.response = http.Response.make(
                403,
                b"Blocked by AI Firewall: sensitive data detected",
                {"Content-Type": "text/plain"},
            )
            log_entry = {
                "timestamp": flow.request.timestamp_start,
                "host": host,
                "path": flow.request.path,
                "reason": "sensitive_data_detected",
            }
            with open(BLOCK_LOG, "a") as f:
                f.write(json.dumps(log_entry) + "\n")

addons = [AIFirewall()]

ขั้นตอนที่ 3: เปิดใช้งาน AI Firewall

# รัน mitmproxy พร้อม addon
mitmproxy -s ai_firewall.py --listen-port 8080

# ตั้ง proxy ของระบบ (Linux)
export http_proxy=http://127.0.0.1:8080
export https_proxy=http://127.0.0.1:8080

เมื่อเปิดใช้งาน ทุก Request ที่มุ่งหน้าไปยัง API ของ AI Provider จะถูกสกัดกั้นและวิเคราะห์โดย Ollama ก่อนเสมอ หากพบข้อมูลละเอียดอ่อน Request จะถูก บล็อกทันที พร้อมบันทึก Log ไว้ให้ตรวจสอบ

ขั้นตอนที่ 4: ตรวจสอบ Log ข้อมูลที่ถูกบล็อก

# ดู Request ที่ถูกบล็อก
cat blocked_requests.jsonl | python3 -m json.tool

# นับจำนวน Request ที่ถูกบล็อกตามโดเมน
cat blocked_requests.jsonl | jq -r '.host' | sort | uniq -c | sort -rn

ปรับแต่งเพิ่มเติมสำหรับการใช้งานจริง

1. Whitelist แอปที่เชื่อถือ: เพิ่มรายชื่อแอปหรือ Process ที่อนุญาตให้ส่งข้อมูลได้โดยไม่ต้องตรวจ เช่น แอปที่คุณจ่ายเงินและยอมรับ Privacy Policy แล้ว

2. เพิ่ม Rule-based Filter: ก่อนเรียก Ollama (ซึ่งค่อนข้างช้า) ให้ตรวจด้วย Regex ก่อน — ถ้าพบ Pattern ชัดเจนอย่าง API Key, หมายเลขบัตรเครดิต หรือเลขบัตรประชาชน ก็บล็อกได้ทันทีโดยไม่ต้องรอ LLM วิเคราะห์

3. แยกโมเดลเล็กสำหรับ Classification: ใช้โมเดลขนาดเล็กอย่าง qwen2.5:0.5b หรือ phi3:mini เพื่อให้การจำแนกทำได้เร็วขึ้น — ไม่จำเป็นต้องใช้โมเดลใหญ่สำหรับงาน Binary Classification แบบนี้

4. Mode เฝ้าดู (Monitor-only): ในช่วงแรกอาจตั้งเป็น Monitor-only คือไม่บล็อกแต่บันทึก Log ไว้ก่อน เพื่อดูว่าแอปไหนส่งข้อมูลอะไรออกไปบ้าง ก่อนจะเปิด Block Mode จริง

บทสรุป

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

เมื่อรวมกับ PII Scrubber (กรองก่อนส่ง) และ Local AI (ไม่ต้องส่งเลย) คุณจะได้ระบบป้องกันข้อมูลแบบ 3 ชั้น ที่ทำงานสอดประสานกันอย่างสมบูรณ์:

1. ชั้นที่ 1 — Local AI: ประมวลผลในเครื่อง ไม่ส่งอะไรออกเลย
2. ชั้นที่ 2 — PII Scrubber: ฟอกข้อมูลก่อนส่ง
3. ชั้นที่ 3 — AI Firewall: ด่านสกัดสุดท้ายที่ระดับเครือข่าย

นี่คือหลักการ Defense in Depth ที่ใช้ในระบบรักษาความปลอดภัยระดับองค์กร — แต่ตอนนี้คุณสามารถสร้างมันได้เองในเครื่องตัวเอง ฟรี และออฟไลน์ 100%