Mengamankan Akses Alat Agen
Terapkan prinsip hak akses minimum pada izin alat agen, implementasikan langkah konfirmasi sebelum tindakan yang merusak, dan audit log tindakan agen untuk mendeteksi perilaku yang tidak wajar.
Mengamankan Akses Alat Agen adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 3 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Engineering Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Engineering Academy mencakup 4 pelajaran total.
Masalah Keamanan Akses Alat
Ketika Anda memberikan alat kepada agen AI, Anda memberinya kemampuan untuk melakukan tindakan di dunia nyata. Alat yang mengirim email, menjalankan kueri SQL, memanggil API pembayaran, atau mengubah file dapat menyebabkan kerugian besar jika agen disusupi oleh injeksi prompt atau sekadar melakukan kesalahan. Mengamankan akses alat oleh agen berarti merancang lapisan alat Anda agar dampak dari setiap penggunaan alat dibatasi, dapat diaudit, dan dapat dibatalkan jika memungkinkan.
Prinsip Hak Akses Paling Sedikit
Terapkan prinsip hak akses paling sedikit pada setiap alat: berikan kepada agen akses minimum yang diperlukan untuk menyelesaikan tugas yang diberikan, dan tidak lebih. Jika agen perlu membaca catatan pelanggan, berikan koneksi basis data hanya-baca — bukan koneksi admin penuh yang Anda gunakan untuk pemeliharaan. Jika agen mengirim notifikasi, batasi kunci API-nya hanya ke titik akhir notifikasi. Hak akses paling sedikit membatasi dampak dari setiap insiden keamanan.
from enum import Enum
from dataclasses import dataclass
class Permission(Enum):
READ_CUSTOMER_PROFILE = 'read_customer_profile'
SEND_NOTIFICATION = 'send_notification'
READ_ORDER_HISTORY = 'read_order_history'
WRITE_CUSTOMER_PROFILE = 'write_customer_profile' # higher privilege
PROCESS_REFUND = 'process_refund' # highest risk
@dataclass
class AgentIdentity:
agent_id: str
allowed_permissions: set[Permission]
# Support chat agent: read-only + send notification only
SUPPORT_AGENT = AgentIdentity(
agent_id='support-agent-v1',
allowed_permissions={
Permission.READ_CUSTOMER_PROFILE,
Permission.READ_ORDER_HISTORY,
Permission.SEND_NOTIFICATION # can notify, but NOT write or refund
}
)
# NOT: give every agent all permissions for convenienceEksekusi Alat dengan Pemeriksaan Izin
Terapkan hak akses paling sedikit pada lapisan eksekusi, bukan hanya pada lapisan perancangan. Setiap pemanggilan alat harus melewati pemeriksaan izin yang memverifikasi bahwa agen pemanggil memiliki izin yang diperlukan untuk tindakan tertentu tersebut. Hal ini tidak dapat dilewati oleh agen atau injeksi prompt karena diterapkan dalam kode, bukan dalam prompt LLM.
class ToolGateway:
def __init__(self, agent: AgentIdentity):
self.agent = agent
self.audit_log = []
def execute_tool(self, tool_name: str, required_permission: Permission, tool_fn, **kwargs) -> dict:
# Permission check - enforced in code, not in the LLM prompt
if required_permission not in self.agent.allowed_permissions:
self.log_denied(tool_name, required_permission, kwargs)
raise PermissionError(
f'Agent {self.agent.agent_id} does not have permission: {required_permission.value}'
)
# Execute tool
result = tool_fn(**kwargs)
self.log_allowed(tool_name, kwargs, result)
return result
def log_denied(self, tool: str, permission: Permission, args: dict):
entry = {'type': 'DENIED', 'agent': self.agent.agent_id, 'tool': tool, 'permission': permission.value, 'args': args}
self.audit_log.append(entry)
print(f'SECURITY: Permission denied - {entry}')
def log_allowed(self, tool: str, args: dict, result):
entry = {'type': 'ALLOWED', 'agent': self.agent.agent_id, 'tool': tool, 'args': args}
self.audit_log.append(entry)
gateway = ToolGateway(SUPPORT_AGENT)
# This will succeed (agent has READ permission)
gateway.execute_tool('read_profile', Permission.READ_CUSTOMER_PROFILE, read_customer_profile, user_id='123')
# This will raise PermissionError (agent lacks PROCESS_REFUND permission)
gateway.execute_tool('process_refund', Permission.PROCESS_REFUND, process_refund, order_id='456', amount=50.00)Langkah Konfirmasi untuk Tindakan yang Merusak
Beberapa tindakan tidak dapat dibatalkan atau berdampak besar: menghapus catatan, mengirim email massal, dan memproses transaksi keuangan. Wajibkan konfirmasi eksplisit dari manusia sebelum agen menjalankan tindakan semacam itu. Agen mengusulkan tindakan tersebut (apa yang ingin dilakukannya dan alasannya), manusia menyetujui atau menolaknya, lalu eksekusi baru dilanjutkan. Gerbang konfirmasi ini merupakan pertahanan tunggal yang paling efektif terhadap kesalahan agen dan penyalahgunaan yang dipicu injeksi.
HIGH_RISK_ACTIONS = {
'delete_customer_record',
'send_bulk_email',
'process_refund_over_100',
'deploy_code',
'revoke_user_access'
}
def execute_with_confirmation(tool_name: str, tool_args: dict, agent_reasoning: str) -> dict:
if tool_name in HIGH_RISK_ACTIONS:
# Pause and request human approval
approval_request = {
'action': tool_name,
'arguments': tool_args,
'agent_reasoning': agent_reasoning,
'risk_level': 'HIGH'
}
approval = request_human_approval(approval_request) # blocks until human responds
if not approval.approved:
return {'status': 'rejected', 'reason': approval.rejection_reason}
# Log the approval for audit trail
log_approval(tool_name, tool_args, approved_by=approval.approver_id)
# Execute only after confirmation
return execute_tool(tool_name, **tool_args)Pembatasan Alat: Batas Waktu, Pengguna, dan Data
Selain jenis izin, batasi akses alat berdasarkan tiga dimensi. Batas waktu: kunci API atau token yang kedaluwarsa setelah sesi agen berakhir. Batas pengguna: agen yang membantu pengguna A tidak boleh mengakses data pengguna B, meskipun agen diperintahkan untuk melakukannya. Batas data: agen dukungan pelanggan hanya boleh mengakses data pelanggan yang sedang dibantunya, bukan semua pelanggan. Terapkan batasan ini dalam implementasi alat Anda, bukan dalam prompt agen.
class ScopedCustomerTool:
def __init__(self, current_user_id: str, session_token: str):
self.user_id = current_user_id # agent can only access THIS user's data
self.token = session_token # expires at end of session
def get_customer_profile(self) -> dict:
# Hardcoded to current user - agent cannot change this via prompt
return db.query(
'SELECT * FROM customers WHERE id = %s',
(self.user_id,) # parameterized, always this user's ID only
)
def get_order_history(self, limit: int = 10) -> list:
# Even if the agent says 'get orders for user 999', it gets self.user_id
return db.query(
'SELECT * FROM orders WHERE customer_id = %s ORDER BY date DESC LIMIT %s',
(self.user_id, min(limit, 50)) # cap limit too
)
# Inject scoped tool into agent - cannot be overridden by prompt
def create_support_agent(user_id: str, session_token: str):
scoped_tools = ScopedCustomerTool(user_id, session_token)
return AgentExecutor(llm=llm, tools=[scoped_tools.get_customer_profile, scoped_tools.get_order_history])Validasi Masukan pada Argumen Alat
Agen menghasilkan argumen alat sebagai teks. Sebelum menjalankan alat apa pun, validasikan semua argumen terhadap skema yang ketat. Hal ini mencegah: injeksi SQL melalui parameter alat, serangan traversal jalur (agen memberikan '../../../etc/passwd' sebagai jalur file), serangan SSRF (agen memberikan URL layanan internal sebagai parameter 'URL jarak jauh'), serta luapan bilangan bulat atau nilai di luar rentang yang dapat menyebabkan perilaku tak terduga.
from pydantic import BaseModel, validator, constr, confloat
import re
class SendEmailArgs(BaseModel):
to: str
subject: constr(max_length=200)
body: constr(max_length=10000)
@validator('to')
def must_be_company_email(cls, v):
if not re.match(r'^[^@]+@(?:yourcorp\.com|partner\.com)$', v):
raise ValueError('Email must be sent to yourcorp.com or partner.com domains only')
return v
class ReadFileArgs(BaseModel):
filename: constr(pattern=r'^[a-zA-Z0-9_\-\.]+$') # alphanumeric only, no path traversal
@validator('filename')
def no_parent_directory(cls, v):
if '..' in v or '/' in v or '\\' in v:
raise ValueError('Path traversal detected')
return v
# Validate before execution
def validated_send_email(args_dict: dict) -> dict:
args = SendEmailArgs(**args_dict) # raises ValueError on invalid input
return send_email(args.to, args.subject, args.body)Pencatatan Audit yang Tidak Dapat Diubah
Setiap pemanggilan alat yang dilakukan agen harus dicatat dalam catatan audit yang tidak dapat diubah. Entri catatan harus mencakup: ID agen dan ID sesi, nama alat dan semua argumen, nilai yang dikembalikan, stempel waktu, serta alasan yang dinyatakan agen untuk melakukan pemanggilan tersebut. Tidak dapat diubah berarti agen (atau penyerang) tidak dapat menghapus atau mengubah entri catatan. Gunakan penyimpanan yang hanya dapat ditambahkan (layanan pencatatan awan, basis data sekali-tulis, atau penyimpanan WORM).
import hashlib
import json
import time
class ImmutableAuditLog:
def __init__(self, log_backend):
self.backend = log_backend # e.g., CloudWatch, BigQuery, or append-only file
self.previous_hash = '0' * 64 # genesis hash
def record(self, agent_id: str, tool_name: str, args: dict, result, reasoning: str):
entry = {
'agent_id': agent_id,
'tool': tool_name,
'args': args,
'result_summary': str(result)[:500], # truncate large results
'reasoning': reasoning[:1000],
'timestamp': time.time(),
'previous_hash': self.previous_hash # chain entries like a blockchain
}
entry_json = json.dumps(entry, sort_keys=True)
entry['hash'] = hashlib.sha256(entry_json.encode()).hexdigest()
self.backend.append(entry) # append-only, never update
self.previous_hash = entry['hash']
return entry['hash']Mendeteksi Perilaku Agen yang Tidak Wajar
Bahkan dengan gerbang izin dan catatan audit, pantau pola perilaku yang tidak wajar yang menunjukkan bahwa agen telah disusupi atau berperilaku secara tak terduga. Sinyal anomali meliputi: agen dukungan yang tiba-tiba memanggil alat yang belum pernah dipanggilnya, lonjakan frekuensi pemanggilan alat yang tidak biasa dari satu agen, argumen yang menyimpang dari kebiasaan dengan cara mencurigakan (string yang sangat panjang atau rangkaian karakter aneh), atau pemanggilan yang terjadi pada jam tidak biasa.
from collections import Counter
class AgentBehaviorMonitor:
def __init__(self):
self.tool_call_counts = Counter() # tracks historical tool usage
self.arg_length_history = {} # tracks typical argument lengths
def record_and_check(self, agent_id: str, tool_name: str, args: dict) -> list[str]:
key = f'{agent_id}:{tool_name}'
anomalies = []
self.tool_call_counts[key] += 1
# Flag tools never called before by this agent
if self.tool_call_counts[key] == 1 and tool_name not in COMMON_TOOLS:
anomalies.append(f'First time agent {agent_id} called unusual tool: {tool_name}')
# Flag unusually long arguments (potential injection payload)
total_arg_length = sum(len(str(v)) for v in args.values())
if tool_name not in self.arg_length_history:
self.arg_length_history[tool_name] = []
self.arg_length_history[tool_name].append(total_arg_length)
if len(self.arg_length_history[tool_name]) > 10:
avg = sum(self.arg_length_history[tool_name]) / len(self.arg_length_history[tool_name])
if total_arg_length > avg * 5:
anomalies.append(f'Unusually long arguments for {tool_name}: {total_arg_length} chars (avg: {avg:.0f})')
return anomaliesKedaluwarsa Token dan Pembatasan Sesi
Sesi agen harus memiliki masa berlaku yang ditetapkan. Terbitkan token atau kredensial berumur pendek kepada agen saat sesi dimulai, lalu cabut saat sesi berakhir. Jika sesi agen disusupi saat eksekusi berlangsung, kemampuan penyerang untuk mengeksploitasi sesi yang disusupi dibatasi oleh waktu kedaluwarsa token. Pembatasan sesi juga memastikan bahwa satu agen yang disusupi tidak dapat digunakan untuk serangan lanjutan beberapa hari kemudian.
import secrets
import time
class SessionTokenManager:
def __init__(self, ttl_seconds=3600):
self.tokens = {} # token -> (agent_id, user_id, expires_at)
self.ttl = ttl_seconds
def issue_token(self, agent_id: str, user_id: str) -> str:
token = secrets.token_urlsafe(32)
expires_at = time.time() + self.ttl
self.tokens[token] = (agent_id, user_id, expires_at)
return token
def validate_token(self, token: str) -> dict | None:
if token not in self.tokens:
return None
agent_id, user_id, expires_at = self.tokens[token]
if time.time() > expires_at:
del self.tokens[token] # clean up expired token
return None
return {'agent_id': agent_id, 'user_id': user_id}
def revoke_token(self, token: str):
self.tokens.pop(token, None)
token_manager = SessionTokenManager(ttl_seconds=1800) # 30-minute sessionsMenguji Keamanan Alat
Uji lapisan keamanan alat Anda dengan menyimulasikan serangan: coba panggil alat terbatas dengan agen yang tidak berwenang, berikan argumen traversal jalur, sisipkan string instruksi ke dalam parameter alat, dan coba panggil alat dengan token yang telah kedaluwarsa. Rangkaian pengujian keamanan alat yang menyeluruh harus mencakup semua batas izin, semua aturan validasi, dan semua pemicu deteksi anomali.
Merancang Kemampuan untuk Dibalik
Jika memungkinkan, rancang alat agar dapat dibalik atau dilakukan secara bertahap. Alih-alih langsung menghapus catatan, tandai catatan sebagai terhapus dengan penanda penghapusan agar dapat dipulihkan. Alih-alih langsung mengirim email, masukkan email ke antrean 'pengiriman tertunda' yang dieksekusi setelah jendela peninjauan selama 5 menit. Lakukan transaksi keuangan secara bertahap dengan menahannya sebelum penyelesaian. Kemampuan untuk membalikkan tindakan tidak menghilangkan risiko keamanan, tetapi secara drastis mengurangi dampak serangan yang berhasil.
Pemeriksaan Singkat
Uji pemahaman Anda tentang cara mengamankan akses alat oleh agen berdasarkan pelajaran ini.
Ringkasan Pelajaran
Dalam pelajaran ini Anda telah mempelajari bahwa prinsip hak akses paling sedikit membatasi izin alat pada hal-hal yang benar-benar diperlukan setiap peran agen, gerbang izin tingkat kode menerapkan izin ini dengan cara yang tidak dapat dilewati oleh injeksi prompt, dan langkah konfirmasi manusia untuk tindakan berisiko tinggi memberikan lapisan perlindungan terakhir sebelum operasi yang tidak dapat dibatalkan dijalankan. Selanjutnya, kita akan menjalankan latihan red team terstruktur pada aplikasi LLM.
Pertanyaan yang Sering Diajukan
Apakah pelajaran “Mengamankan Akses Alat Agen” gratis?
Ya — teks lengkap “Mengamankan Akses Alat Agen” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Engineering Academy, upgrade ke CoddyKit PRO. Kursus AI Engineering Academy mencakup 4 pelajaran total.
Apa yang akan aku pelajari di “Mengamankan Akses Alat Agen”?
Terapkan prinsip hak akses minimum pada izin alat agen, implementasikan langkah konfirmasi sebelum tindakan yang merusak, dan audit log tindakan agen untuk mendeteksi perilaku yang tidak wajar. Kamu berlatih AI Engineering Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.
Apakah aku perlu pengalaman untuk memulai AI Engineering Academy?
Tidak diperlukan pengalaman sebelumnya. AI Engineering Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 3 dari 4.
Berapa lama pelajaran “Mengamankan Akses Alat Agen” memakan waktu?
Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.
Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Engineering Academy ini?
Ya. Setiap pelajaran AI Engineering Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.
Semua pelajaran dalam kursus ini
- Taksonomi Serangan Injeksi Perintah
- Melindungi Sistem RAG dari Injeksi
- Mengamankan Akses Alat Agen
- Melakukan Red Team pada Aplikasi LLM Anda