EST. 2026 — บันทึกงานเซิร์ฟเวอร์จริง SYSADMIN · SECURITY · AI · DIRECTADMIN เล่มที่ 01
THE SYSADMIN ALMANAC
หน้าหลัก / Security / ให้ AI อ่านไฟล์แนบเมลคนอื่น: ClamAV fail-closed, bwrap และ hook กั้น
Security

ให้ AI อ่านไฟล์แนบเมลคนอื่น: ClamAV fail-closed, bwrap และ hook กั้น

โดย Ton-Or ·15 พ.ย. 2026·อ่าน 11 นาที
ให้ AI อ่านไฟล์แนบเมลคนอื่น: ClamAV fail-closed, bwrap และ hook กั้น

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

สรุปใน 1 นาที

อาการ/ปัญหา
ต้องให้ AI สกัดข้อมูลจากไฟล์แนบเมลของคนนอก ซึ่งอาจเป็นมัลแวร์หรือมีข้อความสั่งโมเดล
ใครควรอ่าน
คนที่ให้ LLM อ่านไฟล์แนบจากภายนอก
ทางแก้แบบสั้น
ให้ไฟล์ผ่านจุดเดียว สแกน ClamAV แบบ fail-closed รัน parser ใน bubblewrap ไร้เครือข่าย และใช้ PreToolUse hook กันโมเดลเปิดไฟล์ดิบ
ข้ามไปขั้นตอน

พอดีลูกค้ารายหนึ่งรับเมลจากคนนอกเป็นประจำ แนบมาทั้ง PDF ไฟล์ออฟฟิศ และรูป แล้วอยากให้ AI ช่วยสกัดข้อมูลเข้าฐานข้อมูล ตอนแรกผมคิดแค่ว่าจะโยนไฟล์ให้ Claude อ่านตรง ๆ แต่เจ้าของงานพูดประโยคหนึ่งที่ทำให้ผมหยุด เขาบอกว่า "คนเปิดอ่านคือคุณ ต้องหาทางป้องกันวิธีที่คุณอ่าน" ผมนั่งนิ่งไปพักหนึ่งเพราะมันจริง ไฟล์ที่ผ่านเข้ามาไม่ได้อันตรายเฉพาะตอนมนุษย์ดับเบิลคลิก ตอน AI เปิดมันด้วยสิทธิ์ของเครื่องก็อันตรายเหมือนกัน บางทีมากกว่าด้วยซ้ำ เลยเอาเรื่องนี้มาเล่าว่าผมวางชั้นกันไว้ยังไง

บทความนี้เล่าหลักการ ไม่ใช่คู่มือให้ลอกไปใช้ทั้งดุ้น

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

ความเสี่ยงสองแบบที่ต้องกันคนละวิธี

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

ไฟล์เป็นมัลแวร์

กันด้วยสแกนและกรง

สแกนด้วยแอนตี้ไวรัสก่อนแตะ และให้ parser รันในกรงที่ไม่มีเครือข่าย ไม่เห็นไฟล์อื่น และมีเพดาน memory กับ CPU ถ้าโดนก็เสียแค่ตัวกรอง

ข้อความสั่งโมเดล

กันด้วยสิทธิ์น้อยที่สุด

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

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

ติดเชื้อ: ลง log ไม่บันทึกไฟล์clamd ล่ม: หยุด ไม่ parse อะไรIMAPBODY.PEEKไฟล์ดิบยังไม่มีใครเปิดClamAV scan1 MiB ต่อชิ้นbwrap + prlimitไร้เครือข่ายข้อความสกัดลงฐานข้อมูลโมเดลอ่านจาก DB เท่านั้นไฟล์ดิบไม่เคยถึงโมเดลโดยตรง
ไฟล์ผ่านท่อเดียว เส้นแดงคือทางที่ไฟล์ถูกหยุดและไม่ถูกบันทึก ส่วนตัวโมเดลอ่านได้แต่ข้อความที่สกัดแล้ว

ดึงเมลแบบอ่านอย่างเดียว

ด่านแรกคือการดึง ผมเปิดกล่องเมลแบบ readonly และดึงด้วย BODY.PEEK ไม่ลบ ไม่ติดธงอ่านแล้ว ไม่ย้ายโฟลเดอร์ ระบบเมลของลูกค้าเลยเหมือนไม่มีใครมาแตะ และรันซ้ำต่อรอบได้เพราะข้ามไฟล์ที่เก็บแล้ว เรื่องการดึงแบบไม่รบกวนกล่องเมลผมเขียนแยกไว้แล้วใน ตอนดึงเมลโดยไม่แตะกล่อง ตรงนี้เลยย่อให้เห็นแค่แกน

import imaplib, os

M = imaplib.IMAP4_SSL(os.environ["MAIL_HOST"])
M.login(os.environ["MAIL_USER"], os.environ["MAIL_PASS"])
M.select("INBOX", readonly=True)            # readonly: ไม่มีอะไรในกล่องเปลี่ยน

typ, ids = M.search(None, "ALL")
for num in ids[0].split():
    typ, data = M.fetch(num, "(BODY.PEEK[])")   # PEEK: ไม่ติดธง \Seen
    raw = data[0][1]
    # ส่ง raw ไปแยกไฟล์แนบ แล้วเข้า scan() เป็นด่านถัดไป ห้ามเปิดก่อน

สแกน ClamAV ทาง socket และต้อง fail-closed

ผมคุยกับ clamd ผ่าน unix socket ด้วยคำสั่ง zINSTREAM ส่งข้อมูลทีละชิ้นขนาด 1 MiB นำหน้าด้วยความยาว 4 ไบต์แบบ big-endian ปิดท้ายด้วยความยาว 0 ผลที่ได้มีสามแบบคือ สะอาด (None) ชื่อ signature หรือ "TooBig" ถ้าไฟล์เกินเพดานของ clamd ซึ่งผมตั้ง 100 MB และถือว่าไม่สะอาดเหมือนกัน

หัวใจคือถ้า clamd ไม่ตอบหรือตอบแปลก ๆ ต้องโยน exception ให้ทั้งกระบวนการหยุด ไม่ใช่เดินต่อโดยถือว่าสะอาด นี่คือความหมายของ fail-closed สคริปต์ที่เขียนว่า "ถ้าสแกนล้ม ก็ข้ามไปก่อน" ซึ่งแปลว่าวันที่ตัวสแกนล่มคือวันที่ทุกไฟล์ผ่านฟรี

import socket, struct

CHUNK = 1 << 20          # 1 MiB
class ScanUnavailable(Exception):
    pass

def scan(data: bytes, sock_path="/run/clamav/clamd.ctl"):
    """คืน None = สะอาด / ชื่อ signature / 'TooBig' ; ติดต่อ clamd ไม่ได้ = raise"""
    if len(data) > 100 * 2**20:
        return "TooBig"
    try:
        s = socket.socket(socket.AF_UNIX)
        s.settimeout(60)
        s.connect(sock_path)
        s.sendall(b"zINSTREAM\0")
        for i in range(0, len(data), CHUNK):
            c = data[i:i + CHUNK]
            s.sendall(struct.pack(">I", len(c)) + c)
        s.sendall(struct.pack(">I", 0))
        reply = s.recv(4096).decode(errors="replace").strip("\0\n ")
    except OSError as e:
        raise ScanUnavailable(str(e))           # fail closed
    if reply.endswith(" OK"):
        return None
    if reply.endswith(" FOUND"):
        return reply.split(": ", 1)[-1].rsplit(" FOUND", 1)[0]
    raise ScanUnavailable(reply)                # ตอบแปลก = ถือว่าใช้ไม่ได้

ไฟล์ที่ติดเชื้อผมไม่เก็บลงดิสก์เลย บันทึกเฉพาะรหัสเมล ชื่อไฟล์ และชื่อ signature ลงไฟล์ quarantine เผื่อเจ้าของงานอยากรู้ว่ามีอะไรเข้ามา

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

Parser รันในกรง bubblewrap พร้อมเพดานทรัพยากร

ไฟล์ที่สะอาดตามลายเซ็นไม่ได้แปลว่าปลอดภัย ลายเซ็นจับได้แค่ของที่ถูกรู้จัก ผมเลยให้ตัวแปลงไฟล์ทุกตัว (อย่าง pdftotext กับ pdfimages) รันใน bubblewrap เสมอ กรงนี้ไม่มีเครือข่าย ไม่เห็นโฮมของระบบ มี /usr แบบอ่านอย่างเดียว มี /tmp เป็น tmpfs ของมันเอง bind เข้าไปเฉพาะไฟล์ที่ต้องอ่าน และห่อด้วย prlimit กำหนดเพดาน memory เวลา CPU ขนาดไฟล์ที่เขียนได้ และปิด core dump

# ตัวอย่างค่า: IN คือไฟล์ที่ผ่านสแกนแล้ว
prlimit --as=1073741824 --cpu=30 --fsize=524288000 --core=0 -- \
bwrap --unshare-all --die-with-parent --new-session --clearenv \
      --ro-bind /usr /usr \
      --symlink usr/bin /bin --symlink usr/lib /lib --symlink usr/lib64 /lib64 \
      --proc /proc --dev /dev --tmpfs /tmp \
      --ro-bind "$IN" /work/in.pdf \
      --setenv PATH /usr/bin \
      pdftotext -layout /work/in.pdf -

--unshare-all ตัดทั้งเครือข่าย PID และ mount ที่มองเห็น --die-with-parent กันกระบวนการลูกค้างเมื่อตัวแม่ตาย --clearenv ล้างตัวแปรแวดล้อมที่อาจมี token หลุดเข้าไป ผลคือไฟล์ไหนที่ไม่ได้ bind เข้าไป ในสายตาของโปรแกรมข้างในก็เหมือนไม่มีอยู่

ไฟล์ออฟฟิศ เปิดเฉพาะ XML ที่ต้องการ

docx xlsx pptx คือ zip ที่มี XML ข้างใน ผมไม่ให้โปรแกรมออฟฟิศเปิดเลย อ่านด้วยโค้ดของผมเองแค่สมาชิก XML ที่ต้องใช้ และมีเพดานกัน zip bomb ต่อสมาชิก 20 MB รวมทั้งไฟล์ 60 MB และอัตราส่วนขนาดหลังแตกต่อขนาดบีบอัดไม่เกิน 200 จุดที่ต้องระวังคือไม่เชื่อขนาดที่ไฟล์ประกาศไว้ใน header อย่างเดียว ผมอ่านจริงโดยจำกัดจำนวนไบต์ที่อ่านด้วย

import zipfile

MAX_MEMBER, MAX_TOTAL, MAX_RATIO = 20 * 2**20, 60 * 2**20, 200

def office_xml(path: str, wanted: set[str]) -> dict[str, bytes]:
    out, total = {}, 0
    with zipfile.ZipFile(path) as z:
        for info in z.infolist():
            if info.filename not in wanted:
                continue
            if info.file_size > MAX_MEMBER:
                raise ValueError("member too big")
            if info.compress_size and info.file_size / info.compress_size > MAX_RATIO:
                raise ValueError("compression ratio too high")
            with z.open(info) as f:
                data = f.read(MAX_MEMBER + 1)     # อ่านจริงแบบมีเพดาน ไม่เชื่อ header
            if len(data) > MAX_MEMBER:
                raise ValueError("member too big (actual)")
            total += len(data)
            if total > MAX_TOTAL:
                raise ValueError("total too big")
            out[info.filename] = data
    return out
  1. ไฟล์ออฟฟิศถูกเปิดเป็น zip ด้วยโค้ดข้างบน ไม่ผ่านโปรแกรมออฟฟิศ
  2. เลือกอ่านเฉพาะ XML ที่เป็นเนื้อหา เช่นตัวเอกสารและ sharedStrings
  3. ตัดแท็กเหลือข้อความล้วน แล้วเก็บลงฐานข้อมูล
  4. เกินเพดานข้อใดข้อหนึ่งให้ทิ้งทั้งไฟล์พร้อมบันทึกเหตุผล

hook ที่กั้นไม่ให้โมเดลเปิดไฟล์ดิบเอง

ทั้งหมดข้างบนเป็นเรื่องของท่อ แต่โมเดลของผมมีเครื่องมืออ่านไฟล์และสั่งคำสั่งเชลล์ได้ เกิดมันอยากเปิดไฟล์ดิบในโฟลเดอร์เมลเองแล้ว unzip หรือ python เข้าไปดูตรง ๆ ท่อทั้งท่อก็ไม่มีความหมาย ผมเลยลง PreToolUse hook ซึ่งเป็นโปรแกรมเล็ก ๆ ที่ Claude Code เรียกก่อนทุกครั้งที่จะใช้เครื่องมือ ถ้า hook ออกด้วย exit code 2 เครื่องมือนั้นจะถูกบล็อกและข้อความที่ hook พิมพ์ออกไปจะถูกส่งกลับให้โมเดลอ่าน

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Read|Bash",
        "hooks": [
          { "type": "command",
            "command": "python3 -I \"$CLAUDE_PROJECT_DIR/tools/mail-guard/read_guard_hook.py\"" }
        ]
      }
    ]
  }
}

กติกาที่ผมใส่ในตัว hook มีสามข้อ ข้อแรก เครื่องมือ Read และเครื่องมืออ่าน pdf ถูกบล็อกกับไฟล์ดิบของกล่องเมลทุกกล่อง ข้อสอง Bash ถูกแยกเป็นส่วน ๆ ตามตัวคั่น ; & | และขึ้นบรรทัดใหม่ แล้วถ้าส่วนไหนมีทั้ง path ของเมลดิบ และคำพวกคลายแพ็ก เปิดเอกสาร ตัวดู หรือ interpreter และไม่ได้รันสคริปต์ในโฟลเดอร์เครื่องมือของเรา ก็บล็อก ข้อสาม รูป png jpg gif webp ยังอ่านได้ เพราะกว่าจะถูกบันทึกก็ผ่านสแกนมาแล้ว

import json, re, sys

RAW     = re.compile(r"mail-store/(mailbox-a|mailbox-b)/raw/")
OPENERS = re.compile(r"\b(unzip|7z|tar|libreoffice|pdftotext|python3?|bash|sh)\b")
OURS    = "tools/mail-guard/"

def check(tool: str, inp: dict):
    if tool == "Read" and RAW.search(inp.get("file_path", "")):
        return "ไฟล์ดิบอ่านตรงไม่ได้ ใช้เครื่องมือหรือข้อความที่สกัดไว้ในฐานข้อมูล"
    if tool == "Bash":
        for seg in re.split(r"[;&|\n]", inp.get("command", "")):
            if RAW.search(seg) and OPENERS.search(seg) and OURS not in seg:
                return "คำสั่งนี้เปิดไฟล์ดิบเอง ให้ใช้สคริปต์ในโฟลเดอร์เครื่องมือแทน"
    return None

ev = json.load(sys.stdin)
why = check(ev.get("tool_name", ""), ev.get("tool_input", {}))
if why:
    print(why, file=sys.stderr)
    sys.exit(2)             # 2 = block และส่งข้อความกลับให้โมเดล
PreToolUseeventRead หรือ pdf บนไฟล์ดิบBash แยกทีละส่วน1 มี path เมลดิบ2 มีคำคลายแพ็ก หรือเปิดเอกสาร3 ไม่ใช่สคริปต์ของเรารูปที่ผ่านสแกนแล้วblock (exit 2)บอกโมเดลให้ใช้ข้อความที่สกัดblock (exit 2)ต่อเมื่อครบทั้งสามข้อผ่านสแกนก่อนบันทึกแล้วhook เป็นแค่ regex ชั้นกันจริงคือ AV + sandbox + สิทธิ์น้อยที่สุด
hook ตัดสินที่ตัวคำสั่งก่อนรัน สองแถวบนคือกรณีที่ถูกบล็อกด้วย exit 2 ส่วนแถวล่างอ่านได้เพราะผ่านสแกนมาก่อนแล้ว

ลำดับของด่านสำคัญกว่าที่คิด

ผมเรียงด่านแบบนี้เพราะแต่ละด่านปกป้องด่านถัดไป สแกนมาก่อน parse เสมอ เพราะ parser คือส่วนที่มีโค้ดซับซ้อนที่สุดและเปิดช่องโหว่ได้มากที่สุด ถ้าปล่อยให้ parser เห็นไฟล์ก่อนสแกน ชั้นสแกนก็ไม่มีความหมาย กรงมาก่อนฐานข้อมูลเสมอ เพราะถ้า parser ถูกยึด สิ่งที่มันเห็นต้องมีแค่ไฟล์ที่ส่งเข้าไปกับ /usr แบบอ่านอย่างเดียว ไม่ใช่ข้อมูลของลูกค้า และโมเดลมาท้ายสุดเสมอ เพราะมันคือชั้นที่คาดเดายากที่สุด ผมเลยป้อนให้มันเฉพาะข้อความธรรมดาที่ผ่านทุกด่านมาแล้ว

อีกข้อที่ผมคิดตอนออกแบบคือ ทุกด่านต้องล้มแบบปิด ถ้าสแกนล่มก็หยุด ถ้ากรงสร้างไม่ได้ก็หยุด ความรำคาญของการที่ท่อหยุดแล้วต้องมาไล่ดูเอง ถูกกว่าความเสียหายของการปล่อยผ่านมาก

ข้อจำกัดที่ต้องพูดตรง ๆ

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

อย่าเชื่อว่า hook คือกำแพง

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

ตัวสกัดอีกตัวของผมที่เรียก AI ตัวอื่นผ่าน CLI ก็ถูกห่อกรงทำนองเดียวกัน โฮมเป็น tmpfs ว่าง เห็นเฉพาะโฟลเดอร์ล็อกอินกับ workspace ของมัน และซ่อน socket ของฐานข้อมูล เพราะข้อความในเมลอาจสั่งโมเดลให้ไปอ่านความลับ

ทดสอบให้เห็นกับตา ไม่ใช่เชื่อว่าทำงาน

ชุดทดสอบที่ผมวางไว้ให้ทดสอบแต่ละชั้นแยกกัน มีดังนี้

  1. ใช้ไฟล์ทดสอบ EICAR (สตริงมาตรฐานที่แอนตี้ไวรัสทุกตัวจับ ไม่ใช่มัลแวร์จริง) ต้องถูกจับ และต้องไม่มีไฟล์นั้นหลงเหลือบนดิสก์
  2. หยุด clamd แล้วรันท่อ กระบวนการต้องหยุดพร้อมข้อผิดพลาด ไม่ parse อะไรเลย
  3. เตรียม zip ที่บีบอัดสูงผิดปกติ ต้องถูกปฏิเสธด้วยเพดานอัตราส่วน
  4. สั่งโมเดลให้ลอง unzip ไฟล์ในโฟลเดอร์เมลดิบ ต้องเห็น hook ตอบ exit 2 พร้อมข้อความแนะนำ
  5. ลองให้ parser ในกรงอ่านไฟล์นอกที่ bind ไว้ ต้องไม่เจอ
# ทดสอบข้อ 2: ปิด clamd แล้วดูว่าท่อต้องไม่เดินต่อ
sudo systemctl stop clamav-daemon
python3 run_pipeline.py --once ; echo "exit=$?"     # ต้องไม่ใช่ 0 และไม่มีข้อความที่สกัดถูกเขียน
sudo systemctl start clamav-daemon
ประตูตรวจโลหะหน้าห้องรับจดหมาย มีถังกักกันสำหรับพัสดุที่ถูกตั้งข้อสงสัย
ทุกชิ้นต้องผ่านประตูตรวจก่อน ถ้าประตูเสียก็ปิดห้องรับจดหมายทั้งห้อง ไม่ใช่เปิดผ่านฟรี

สรุป

ลำดับที่ผมใช้กับไฟล์แนบจากคนนอกคือ ดึงแบบอ่านอย่างเดียว สแกนแบบ fail-closed รันตัวแปลงในกรงไร้เครือข่ายมีเพดาน เปิดไฟล์ออฟฟิศด้วยโค้ดที่มีเพดานกัน zip bomb ให้โมเดลอ่านจากฐานข้อมูลเท่านั้น และลง hook ไว้เป็นชั้นเสริมที่ยอมรับว่าหลบได้ ใครจะเอาไปปรับก็ตามสะดวก แต่ขอย้ำข้อเดียวคือ ตอนที่ตัวสแกนล่ม ระบบต้องหยุด ไม่ใช่ปล่อยผ่าน ตรงไหนที่ผมอธิบายตกหรือเจอวิธีกั้นที่ดีกว่านี้ เดี๋ยวกลับมาแก้เพิ่มให้ภายหลังครับ

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

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

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

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

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

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

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

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