Giới hạn quyền khi cho AI tự chạy lệnh

Bài này dựa trên tài liệu Claude Code về quyền và sandbox, đọc ngày 11/11/2026. Tên chế độ, cú pháp luật và hành vi có thể thay đổi giữa các phiên bản; hãy đối chiếu tài liệu khi cấu hình. Các công cụ agent khác có cơ chế tương tự với tên gọi khác, và nguyên tắc trong bài vẫn áp dụng.

Vì sao phải giới hạn quyền?

Agent lập trình dùng được mọi lệnh bạn chạy được trong terminal: công cụ build, git, trình quản lý gói, script. Tài liệu Claude Code nói thẳng: nếu bạn làm được từ dòng lệnh thì agent cũng làm được. Điều đó tạo ra ba loại rủi ro:

• Sai mà không quay lại được. Theo tài liệu, chức năng quay lại của Claude Code chỉ áp dụng cho thay đổi tệp; hành động ảnh hưởng hệ thống bên ngoài như cơ sở dữ liệu, API hay triển khai thì không thể khôi phục, và bạn kiểm soát chúng bằng chế độ quyền và luật quyền.
• Lộ dữ liệu. Agent đọc được tệp .env, khóa SSH, cấu hình đám mây nếu không bị chặn.
• Bị lôi kéo. Nội dung agent đọc được (trang web, tệp lạ, kết quả công cụ) có thể chứa chỉ dẫn độc hại tìm cách khiến nó chạy lệnh bạn không muốn.

Nguyên tắc chung là quyền tối thiểu: chỉ cho agent đúng những quyền việc đang làm cần, bắt đầu chặt rồi nới dần khi bạn đã hiểu nó làm gì.

Mặc định, agent được làm gì mà không hỏi?

Theo tài liệu, ở chế độ mặc định (hỏi trước), Claude Code chia công cụ theo mức:

Khi bạn chọn "đồng ý và không hỏi lại", hiệu lực khác nhau: với sửa tệp là tới hết phiên; với lệnh shell là vĩnh viễn cho kho đó và lệnh đó. Hãy cẩn thận với lựa chọn này cho lệnh shell.

Chế độ quyền: chọn mức tự do

Tài liệu liệt kê các chế độ sau (trong phiên có thể chuyển qua lại bằng Shift+Tab):

Tài liệu cảnh báo riêng về bypassPermissions: ở chế độ này Claude Code bỏ qua lời hỏi, kể cả khi ghi vào các đường dẫn được bảo vệ như .git và .claude. Tổ chức có thể tắt hẳn chế độ này (và chế độ tự động) bằng cài đặt permissions.disableBypassPermissionsMode hoặc permissions.disableAutoMode. Với người học, quy tắc đơn giản: không dùng chế độ bỏ qua quyền trên máy thật chứa dữ liệu của bạn.

Gợi ý chọn chế độ: dùng lập kế hoạch khi mới làm quen với một kho mã hay việc phức tạp; hỏi trước khi chưa tin quy trình; chấp nhận sửa khi đã có test và git để quay lại; chế độ tự động khi đã hiểu nó chặn gì và không chặn gì.

Luật quyền: cho phép, hỏi, cấm

Luật được viết trong tệp cài đặt (như .claude/settings.json của dự án) hoặc quản lý bằng lệnh /permissions, lệnh này liệt kê mọi luật và tệp chứa chúng. Ví dụ một cấu hình cho dự án học tập:

{
  "permissions": {
    "allow": ["Bash(npm run *)", "Bash(git commit *)", "Bash(git status)"],
    "ask":   ["Bash(git push *)"],
    "deny":  ["Bash(rm *)", "Bash(curl *)", "Read(./.env)", "Read(./secrets/**)"]
  }
}

Bốn quy tắc từ tài liệu cần nắm:

1. Thứ tự xét là deny, rồi ask, rồi allow. Khớp đầu tiên theo thứ tự đó quyết định, và độ cụ thể của luật không đổi thứ tự. Một luật cấm rộng như Bash(aws *) chặn mọi lệnh khớp, kể cả khi có luật cho phép hẹp hơn như Bash(aws s3 ls): luật cho phép không tạo được ngoại lệ cho luật cấm.
2. Dấu * khớp mọi đoạn chữ, luật không có * khớp đúng một lệnh. Tài liệu khuyên đặt * sau lệnh con: trong git log --oneline, git là chương trình, log là lệnh con quyết định việc nó làm.
3. Lệnh ghép được tách ra. Claude Code nhận ra các toán tử &&, ||, ;, |, &; luật cho phép Bash(safe-cmd *) không cho chạy safe-cmd && other-cmd. Luật cấm và hỏi áp dụng nếu bất kỳ lệnh con nào khớp.
4. Luật do Claude Code thực thi, không do mô hình. Tài liệu nhấn mạnh chỉ dẫn trong yêu cầu hay CLAUDE.md định hướng việc Claude cố làm, nhưng không đổi được điều Claude Code cho phép. Một luật cấm chỉ ghi tên công cụ (như Bash) còn gỡ hẳn công cụ đó khỏi ngữ cảnh của Claude.

Để chặn đọc tệp bí mật, dùng luật cấm Read với đường dẫn, như Read(./.env) hay Read(./secrets/**). Theo tài liệu, Claude Code cố gắng áp dụng luật cấm đọc cho mọi công cụ đọc tệp có sẵn, kể cả công cụ tìm kiếm.

Mô phỏng cách luật được xét

Đoạn Python dưới đây mô phỏng (đơn giản hóa) cách xét luật cho lệnh shell theo bốn quy tắc trên, với đúng cấu hình ví dụ. Bản thật xử lý thêm nhiều trường hợp, nhưng mô phỏng đủ để thấy thứ tự xét và chỗ luật bỏ lọt.

"""Mô phỏng (đơn giản hóa) cách Claude Code xét luật quyền cho lệnh shell, theo tài liệu Permissions đọc ngày 11/11/2026.

- Luật có ba loại, xét theo thứ tự: deny (cấm), rồi ask (hỏi), rồi allow (cho phép). Khớp đầu tiên theo thứ tự đó quyết định.
- Dấu * khớp mọi đoạn chữ; luật không có * chỉ khớp đúng một lệnh.
- Lệnh ghép (&&, ||, ;, |, &) được tách: deny hay ask áp dụng nếu BẤT KỲ lệnh con nào khớp; allow chỉ khi MỌI lệnh con được cho phép.
- Không khớp luật nào thì theo chế độ quyền; ở chế độ mặc định là hỏi bạn.
Bản thật còn xử lý nhiều trường hợp khác (bỏ lớp bọc như timeout, biến môi trường...). Đây chỉ để thấy cơ chế.
"""
import re

TACH = re.compile(r"\s*(?:&&|\|\||;|\||&|\n)\s*")


def khop(luat, lenh):
    """luat dạng Bash(mẫu). Dấu * thành .* , còn lại khớp đúng từng ký tự."""
    mau = luat[len("Bash("):-1]
    bieu_thuc = "^" + ".*".join(re.escape(phan) for phan in mau.split("*")) + "$"
    return re.match(bieu_thuc, lenh) is not None


def quyet_dinh(lenh, cau_hinh):
    con = [c for c in TACH.split(lenh.strip()) if c]
    for loai in ("deny", "ask"):
        if any(khop(l, c) for l in cau_hinh.get(loai, []) for c in con):
            return loai
    if con and all(any(khop(l, c) for l in cau_hinh.get("allow", [])) for c in con):
        return "allow"
    return "mặc định (hỏi)"


CAU_HINH = {
    "allow": ["Bash(npm run *)", "Bash(git commit *)", "Bash(git status)"],
    "ask": ["Bash(git push *)"],
    "deny": ["Bash(rm *)", "Bash(curl *)"],
}

VI_DU = [
    "npm run test",
    "git status && npm run build",
    "git push origin main",
    "npm run build && rm -rf dist",
    "curl https://example.com",
    "/usr/bin/curl https://example.com",
    "python app.py",
]


def chay_thu():
    ket_qua = {}
    for lenh in VI_DU:
        ket_qua[lenh] = quyet_dinh(lenh, CAU_HINH)
        print(f"{lenh:<36} -> {ket_qua[lenh]}")
    return ket_qua


if __name__ == "__main__":
    chay_thu()

npm run test                         -> allow
git status && npm run build          -> allow
git push origin main                 -> ask
npm run build && rm -rf dist         -> deny
curl https://example.com             -> deny
/usr/bin/curl https://example.com    -> mặc định (hỏi)
python app.py                        -> mặc định (hỏi)

Dòng thứ tư cho thấy lệnh ghép bị cấm vì một phần (rm -rf dist) khớp luật cấm, dù phần còn lại được phép. Dòng thứ sáu là điểm quan trọng nhất: cùng chương trình curl nhưng gọi bằng đường dẫn đầy đủ thì không khớp luật cấm curl *, và chỉ còn rơi về chế độ mặc định.

Những gì luật cho lệnh shell không chặn được

Tài liệu nói rõ: luật Bash khớp theo chữ của lệnh agent viết, không khớp cùng chương trình được gọi theo cách khác. Bảng ví dụ trong tài liệu:

Những lệnh ở cột cuối do các luật khác và chế độ quyền quyết định. Ở chế độ hỏi trước, chúng vẫn bị hỏi; nhưng nếu bạn đã cho phép rộng (ví dụ Bash(sh *)), chúng sẽ chạy. Vì vậy tài liệu khuyên: muốn chặn chắc chắn ở mức tệp và mạng mà không phụ thuộc chữ của lệnh, dùng sandbox; muốn tự kiểm toàn bộ nội dung lệnh bằng logic riêng, dùng hook PreToolUse (xem hooks cho AI).

Sandbox: để hệ điều hành chặn

Sandbox của Claude Code là một ranh giới do hệ điều hành thực thi, bao quanh các lệnh shell agent chạy và mọi tiến trình chúng sinh ra. Theo tài liệu:

• Tệp: chỉ được ghi trong thư mục làm việc, một thư mục tạm riêng của người dùng và các thư mục được thêm. Đọc thì được ở phần lớn máy, nên các đường dẫn nhạy cảm như ~/.ssh cần luật chặn đọc riêng.
• Mạng: lệnh không có đường ra trực tiếp; mọi kết nối đi qua một proxy cục bộ kiểm từng tên miền với danh sách được phép, và danh sách này ban đầu trống.
• Nền tảng: trên macOS dùng Seatbelt; trên Linux và WSL2 dùng bubblewrap và socat. Trên Windows chạy trực tiếp, lệnh không được đặt trong sandbox, nên cần WSL2.

Bật bằng lệnh /sandbox trong phiên, hoặc đặt "sandbox": {"enabled": true} trong ~/.claude/settings.json. Lợi ích chính tài liệu nêu: ít lời hỏi quyền hơn, vì hệ điều hành đã giới hạn những gì lệnh chạm tới; và ranh giới giữ nguyên bất kể mô hình chọn chạy lệnh gì, nên thiệt hại được giới hạn nếu một lệnh sai hoặc bị lôi kéo.

Một bộ cấu hình khởi đầu an toàn

Kết hợp ba lớp cho một dự án học tập:

1. Chế độ: bắt đầu bằng hỏi trước; dùng lập kế hoạch cho việc lớn.
2. Luật cho phép đúng các lệnh bạn chạy hằng ngày và vô hại: chạy test, build, xem trạng thái git.
3. Luật hỏi cho thao tác đẩy ra ngoài: git push, cài gói mới.
4. Luật cấm cho thao tác phá hủy và đọc bí mật: rm, các lệnh gọi mạng tùy ý, Read(./.env).
5. Sandbox nếu máy bạn hỗ trợ (macOS, Linux, WSL2), với danh sách tên miền tối thiểu.
6. Git: luôn làm trên nhánh riêng, commit trước khi giao việc lớn. Theo tài liệu, điểm khôi phục làm việc cùng git, không thay git.
7. Không dùng chế độ bỏ qua quyền trên máy có dữ liệu thật.

Commit tệp cấu hình quyền của dự án vào git để cả nhóm dùng chung, và để thay đổi luật cũng được xem lại như thay đổi code. Bí mật như khóa API thì để ngoài git; xem giữ khóa API an toàn.

Câu hỏi thường gặp

Học tiếp

• Muốn tự kiểm nội dung lệnh bằng logic riêng trước khi chạy, đọc hooks cho AI.
• Muốn giữ khóa API ngoài tầm với của agent và ngoài git, đọc giữ khóa API an toàn.
• Muốn kiểm những gì agent đã làm, đọc kiểm chứng việc AI làm.

Nếu bạn muốn học lập trình và AI bài bản cùng giảng viên, tham khảo khóa học AI của Big-O Coding.

Nguồn tham khảo

• Tài liệu Claude Code: Configure permissions
• Tài liệu Claude Code: Sandboxing
• Tài liệu Claude Code: How Claude Code works
• Tài liệu Claude Code: Best practices