EST. 2026 — บันทึกงานเซิร์ฟเวอร์จริง SYSADMIN · SECURITY · AI · DIRECTADMIN เล่มที่ 01
THE SYSADMIN ALMANAC
หน้าหลัก / AI / บอท AI ที่มี root: ให้สิทธิ์ตามคนสั่งด้วย hook ไม่ใช่ deny list
AI

บอท AI ที่มี root: ให้สิทธิ์ตามคนสั่งด้วย hook ไม่ใช่ deny list

โดย Ton-Or ·18 พ.ย. 2026·อ่าน 11 นาที
บอท AI ที่มี root: ให้สิทธิ์ตามคนสั่งด้วย hook ไม่ใช่ deny list

สิทธิ์ที่ควรให้ขึ้นกับว่าใครเป็นคนสั่ง ไม่ใช่ขึ้นกับว่าเครื่องมือตัวไหน deny list แบบคงที่ตอบเรื่องแรกไม่ได้ ผมเลยย้ายการตัดสินไปอยู่ในโค้ดที่เทสต์ได้

สรุปใน 1 นาที

อาการ/ปัญหา
บอทเลขาที่รัน Claude CLI มีสิทธิ์สูง แต่คนสั่งมีหลายระดับ deny list แบบคงที่ใช้กับทุกคนเหมือนกัน
ใครควรอ่าน
คนที่ทำบอท AI บนเครื่องจริงและมีคนสั่งหลายระดับสิทธิ์
ทางแก้แบบสั้น
ทำ PreToolUse hook ตัวเดียวที่ดูระดับผู้สั่งจากตัวแปรแวดล้อมและไฟล์ที่โมเดลเขียนไม่ได้ แยกสามระดับ และมีชุดทดสอบกันถดถอยทั้งสองทิศ
ข้ามไปขั้นตอน

พอดีบอทเลขาที่ผมทำให้เว็บลูกค้ารายหนึ่งขับ Claude CLI อยู่บนเครื่องเดียวกับตัวเว็บ มันต้องทำงานที่ต้องการสิทธิ์สูงบนเครื่องนั้นหลายอย่าง ทั้ง sudo, systemctl, artisan และล้างแคช ปัญหาคือคนที่สั่งบอทไม่ใช่คนเดียวกัน มีนักพัฒนาที่สั่งผ่าน Telegram เจ้าของธุรกิจที่สั่งผ่านหน้าแอดมิน และลูกค้าที่คุยผ่านแชท ผมนั่งลองตั้ง deny list ใน settings ของ Claude ดูก่อน แล้วเห็นว่ามันใช้ได้แค่แบบเดียวคือเหมือนกันหมดทุกคน ถ้าตั้งเข้มจนปลอดภัยสำหรับลูกค้า นักพัฒนาก็ทำงานไม่ได้ ถ้าตั้งหลวมพอให้นักพัฒนาทำงาน ลูกค้าก็ได้สิทธิ์เกินตัว บทความนี้เล่าว่าผมแก้ยังไง

บทความนี้เล่าหลักการ ไม่ใช่รายการกฎของจริง

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

ทำไม deny list แบบคงที่ไม่พอ

deny list ใน settings คือรายการคำสั่งหรือ path ที่ห้ามใช้ มันตัดสินจากหน้าตาของคำสั่งอย่างเดียว ไม่รู้ว่าคนที่สั่งอยู่ปลายทางคือใคร และเขียนเงื่อนไขซับซ้อนอย่าง "ห้ามอ่านไฟล์ลับ แม้จะแอบผ่านเครื่องหมาย wildcard" ได้ยากมาก

deny list ใน settings

ชุดเดียวใช้กับทุกคน

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

PreToolUse hook

โค้ดที่ตัดสินตามระดับ

เป็นโปรแกรมที่ Claude เรียกก่อนทุกครั้งที่จะใช้เครื่องมือ อ่านระดับสิทธิ์ของเทิร์นนี้ แล้วเลือกกฎได้ เขียนเป็นฟังก์ชันล้วน ๆ เลยเทสต์ได้ทุกกรณี

เลยย้ายการตัดสินทั้งหมดไปอยู่ใน hook ตัวเดียว เขียนด้วยไลบรารีมาตรฐานของ Python ล้วน รันด้วย python3 ของระบบ ไม่ต้องติดตั้งอะไรเพิ่ม hook อ่าน JSON จาก stdin ถ้าชนกฎก็พิมพ์ deny พร้อมเหตุผล ถ้าผ่านก็ไม่พิมพ์อะไรและออกด้วย 0 ส่วนตรรกะจริงผมแยกเป็นฟังก์ชัน check(tool_name, tool_input, cwd, home) ที่คืนเหตุผลที่ปฏิเสธหรือ None เพื่อให้เทสต์เรียกตรง ๆ ได้โดยไม่ต้องสร้าง process

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash|Edit|Write|Read|Grep|Glob",
        "hooks": [
          { "type": "command",
            "command": "python3 -I \"$CLAUDE_PROJECT_DIR/.claude/hooks/guard.py\"" }
        ]
      }
    ]
  }
}

สามระดับ

ผมแบ่งระดับสิทธิ์เป็นสามระดับ ตั้งโดยตัวบอทก่อนทุกเทิร์น

devไม่มี guard
ownerค่าปริยาย
strictกฎเข้มสุด
3ระดับทั้งหมด

ระดับ dev ไม่มี guard เลย ไว้ให้นักพัฒนาที่ผมเชื่อใจทำงานของตัวเอง ระดับ owner เป็นค่าปริยายเมื่อไม่มีไฟล์ระดับ จัดการเว็บและทั้งเครื่องได้ รวมถึง sudo, systemctl, apt, curl, git แต่ไม่แตะเครื่องอื่นในเครือข่ายภายใน ไม่แตะความลับ ไม่แก้ตัว guard และ state ของบอทเอง และห้ามหยุดหรือ kill ตัวบอท ส่วนระดับ strict คือกฎเดิมที่เข้มสุด

อาคารที่มีบัตรผ่านสามสีเปิดประตูต่างกัน และมีแผงควบคุมหลักอยู่ในห้องล็อกที่ผู้ถือบัตรเข้าไม่ถึง
บัตรแต่ละสีเปิดประตูได้ไม่เท่ากัน แต่ไม่มีสีไหนเปิดห้องที่เก็บแผงควบคุมของตัวระบบกั้นเองได้ ตรงนี้คือหัวใจของการป้องกัน guard
devไม่มี guardนักพัฒนาowner ค่าปริยายจัดการเว็บ และเครื่องห้ามแตะ: เครื่อง LAN อื่นความลับ ตัว guardstate ของบอทห้ามหยุดหรือ kill บอทstrictกฎเดิมเข้มสุด1 env ของ process2 ไฟล์ระดับของบอท3 ไม่มีไฟล์ = ownerลำดับตัดสิน: ข้อ 1 ชนะข้อ 2 ข้อ 2 ชนะค่าปริยาย
สามระดับสิทธิ์ และลำดับที่ hook ใช้หาระดับ ตัวแปรแวดล้อมที่ตั้งตอนสร้าง process ชนะไฟล์ระดับเสมอ

ระดับมาจากไหน ต้องเป็นสิ่งที่เซสชันเปลี่ยนเองไม่ได้

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

import os

LEVELS = ("dev", "owner", "strict")

def get_level(env: dict, state_file: str) -> str:
    lv = env.get("PERM_LEVEL")
    if lv in LEVELS:                    # 1 ตัวแปรแวดล้อมของ process ชนะทุกอย่าง
        return lv
    try:
        with open(state_file, encoding="utf-8") as f:
            lv = f.read().strip()
    except OSError:
        return "owner"                  # 3 ไม่มีไฟล์ = ค่าปริยาย owner
    return lv if lv in LEVELS else "strict"   # ค่าแปลก ๆ ให้เข้มสุด (ตัวอย่างของผม)

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

สิ่งที่ hook บล็อก แยกตามเครื่องมือ

ผมแยกกฎตามชนิดเครื่องมือ เพราะอันตรายของแต่ละตัวไม่เหมือนกัน

เครื่องมือ สิ่งที่ตรวจ
Bash โปรแกรมต้องห้ามที่ปรากฏที่ใดก็ได้ในข้อความคำสั่ง (ต่อท้าย pipe ใน $(...) หรือ bash -c '...'), ที่อยู่ภายใน/เครื่องอื่นของระบบ, /dev/tcp, การอ่านไฟล์ลับ, การเขียน state ของบอท, rm แบบ recursive บนโฟลเดอร์สำคัญ
Edit / Write โค้ดและ state ของบอท, โฟลเดอร์กุญแจ, ไฟล์ .env ทุกไฟล์, /etc ; สคริปต์ที่เขียนลงดิสก์ถูกตรวจเหมือน Bash
Read / Grep / Glob ห้ามไฟล์ลับ, โฟลเดอร์กุญแจ, ไฟล์ล็อกอินของ CLI

ข้อที่ผมเน้นคือ "ปรากฏที่ใดก็ได้ในข้อความคำสั่ง" เพราะถ้าตรวจแค่คำแรก ก็หลบง่ายด้วยการต่อคำสั่ง ใส่ใน $(...) หรือห่อด้วย bash -c และสคริปต์ที่โมเดลเขียนลงดิสก์แล้วสั่งรัน ก็ต้องถูกตรวจเนื้อหาเหมือนคำสั่งที่พิมพ์ตรง ๆ

ช่อง wildcard ที่เจอแล้วอุด

ช่องหนึ่งที่ผมเคยเจอแล้วอุดไปแล้ว คือคำสั่ง cat .en? อ่านไฟล์ลับได้ เพราะ guard รุ่นแรกเทียบชื่อแบบตัวอักษร ".en?" ไม่เหมือนชื่อไฟล์ลับตัวไหนตรง ๆ แต่พอเชลล์ขยาย ? เป็นตัวอักษรหนึ่งตัวมันกลายเป็นไฟล์ลับพอดี guard เห็นข้อความหนึ่ง เชลล์รันอีกอย่าง

ผมแก้ด้วยการให้ guard ขยาย wildcard ด้วย glob เองก่อนตัดสิน (แบบ recursive เอาแค่ 200 รายการแรกกันค้าง) และปฏิเสธถ้ารายการที่ขยายได้มีชื่อลับ หรือถ้า pattern อาจชนชื่อลับ ส่วน wildcard ธรรมดาอย่าง *.php ยังอนุญาตตามเดิม ไม่งั้นงานปกติทำไม่ได้เลย

import fnmatch, glob, os

SECRET_NAMES = [".env", ".env.*", "id_rsa", "id_ed25519", "authorized_keys"]   # ตัวอย่าง

def is_secret(name: str) -> bool:
    base = os.path.basename(name)
    return any(fnmatch.fnmatch(base, s) for s in SECRET_NAMES)

def wildcard_hits_secret(token: str, cwd: str) -> bool:
    if not any(c in token for c in "*?["):
        return is_secret(token)                          # ไม่มี wildcard เทียบชื่อตรง ๆ
    hits = glob.glob(os.path.join(cwd, token), recursive=True)[:200]
    if any(is_secret(h) for h in hits):
        return True                                      # ขยายแล้วได้ไฟล์ลับ
    pat = os.path.basename(token)
    return any(fnmatch.fnmatch(s, pat) for s in SECRET_NAMES)   # pattern อาจชนชื่อลับ
cat .en?ขยาย glob200 รายการแรกเทียบชื่อลับชนไฟล์ลับปฏิเสธ (deny)ก่อนแก้: เทียบตัวอักษร .en? ไม่ตรงชื่อลับเลยหลุดcat *.phpขยาย glob200 รายการแรกเทียบชื่อลับไม่ชนอนุญาต (allow)wildcard ธรรมดายังใช้ได้ ไม่งั้นงานปกติทำไม่ได้
guard ขยาย wildcard เองก่อนตัดสิน แทนที่จะเทียบข้อความที่เห็น เพราะเชลล์จะขยายมันอยู่ดี
ยามที่ตรวจบัตรผ่านและมองด้วยว่าตราประทับแบบ wildcard จะขยายไปเป็นอะไรได้บ้าง
ตรวจแค่ชื่อบนบัตรไม่พอ ต้องคิดด้วยว่าตราประทับพิเศษจะขยายไปเป็นอะไรตอนผ่านประตู

เรื่องนี้สอนผมว่าการตรวจข้อความคำสั่งกับการตรวจสิ่งที่คำสั่งจะทำจริงเป็นคนละเรื่อง ยังมีช่องอื่นของแนวเดียวกัน ทุกครั้งที่เจอวิธีหลบใหม่ ผมเขียนเป็นเทสต์ก่อนแล้วค่อยแก้ guard

ชุดทดสอบ ใช้กันถดถอยทั้งสองทิศ

เพราะ check เป็นฟังก์ชันล้วน เทสต์เลยเขียนง่าย ผมมีเทสต์ตรวจ guard ชุดหลักและเทสต์ allowlist แยกอีกชุด ชุดหลังมีหน้าที่เฉพาะคือรับรองว่าคำสั่งที่งานปกติต้องใช้ยังผ่าน ไม่งั้นพอเข้มขึ้นเรื่อย ๆ บอทจะใช้งานไม่ได้โดยไม่มีใครรู้ตัว และเทสต์ของ claim hook อีกตัวที่ใช้ร่วมกัน (เรื่องนั้นอยู่ใน ตอน AI หลายตัวแก้เว็บพร้อมกัน)

import pytest, guard

CWD, HOME = "/srv/app", "/home/webuser"

@pytest.fixture(autouse=True)
def strict(monkeypatch):
    monkeypatch.setenv("PERM_LEVEL", "strict")

@pytest.mark.parametrize("cmd", [
    "cat .env",
    "cat .en?",                     # ช่อง wildcard
    "cat .e*",
    "bash -c 'cat ~/.ssh/id_ed25519'",
    "ls && cat $(echo .env)",
])
def test_denied(cmd):
    assert guard.check("Bash", {"command": cmd}, CWD, HOME) is not None

@pytest.mark.parametrize("cmd", [
    "ls -la",
    "cat *.php",                    # wildcard ธรรมดาต้องยังผ่าน
    "git status",
    "php artisan cache:clear",
])
def test_allowed(cmd):
    assert guard.check("Bash", {"command": cmd}, CWD, HOME) is None
  1. รันชุด denied ให้เห็นว่าทุกกรณีถูกปฏิเสธ
  2. รันชุด allowed ให้เห็นว่างานปกติยังผ่าน
  3. ทุกครั้งที่เจอวิธีหลบใหม่ เพิ่มเทสต์ที่ล้มก่อน แล้วค่อยแก้ guard ให้ผ่าน
  4. เปลี่ยนระดับเป็น owner กับ dev แล้วรันซ้ำ ดูว่าผลต่างตรงกับที่ตั้งใจ

ในทางปฏิบัติ owner กับ dev ต่างกันตรงไหน

เพื่อให้เห็นภาพ ผมยกคำสั่งสมมติที่เจอบ่อยมาเทียบกัน ตารางนี้เป็นตัวอย่างของแนวคิด ไม่ใช่รายการกฎจริง ส่วน strict เข้มกว่า owner เสมอ

คำสั่งสมมติ dev owner
php artisan cache:clear ผ่าน ผ่าน
sudo systemctl reload php-fpm ผ่าน ผ่าน
อ่านไฟล์ .env ผ่าน ปฏิเสธ
เข้า SSH ไปเครื่องอื่นในเครือข่ายภายใน ผ่าน ปฏิเสธ
แก้ไฟล์ guard หรือ state ของบอท ผ่าน ปฏิเสธ
หยุดหรือ kill ตัวบอท ผ่าน ปฏิเสธ

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

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

บทเรียนที่เอาไปใช้ต่อ

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

guard ไม่ใช่ที่เดียวที่ควรป้องกัน

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

ส่วนเรื่องแยกบริบทและความจำของเครื่องพัฒนาออกจากแชทลูกค้า ผมเขียนไว้แยกแล้วใน ตอนแยกบริบทของแชทลูกค้า และหลักความปลอดภัยกว้าง ๆ ตอนให้ AI ทำงานผ่าน SSH อยู่ใน ตอน claude-ssh-safe ตรงนี้เลยไม่เล่าซ้ำ ใครจะปรับระดับให้ละเอียดกว่านี้ก็ตามสะดวกเลย แต่ขอย้ำข้อเดียวว่าอย่าให้ระดับมาจากที่ที่โมเดลเขียนได้ ตรงไหนที่ผมอธิบายยังตกหรือมีวิธีหลบที่ผมยังไม่เจอ เดี๋ยวกลับมาแก้เพิ่มให้ภายหลังครับ

อยากให้เราทำให้ไหม?

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

คุยเรื่องงานกับเรา

เคยเจองานแบบนี้ไหม? ติดตรงไหน?

มาแลกวิธีกันต่อในบอร์ด LinuxThai

→ คุยต่อในบอร์ด

ความคิดเห็น 0

ยังไม่มีความคิดเห็น — เป็นคนแรกเลย