# Lagune > Security-Driven Hardening untuk basis kode apa pun Lagune adalah alur kerja Security-Driven Hardening (SDH) yang open source dan khusus pertahanan. Lagune membantu agen AI Anda memperkuat keamanan basis kode apa pun, dalam bahasa apa pun, kapan pun: charter menetapkan aturan keamanan sebelum Anda membangun, perintah universal /lagune memperkuat pekerjaan selagi ditulis, dan alur Blue Team lima fase mendeteksi apa yang sebenarnya dilakukan sistem Anda lalu mengarahkan perbaikan yang penting untuk konteks tersebut. Anda menginstal perintahnya ke agen dengan skills CLI, tanpa perlu kunci API. --- # Instal: hardening keamanan untuk agen AI apa pun > Instal Lagune di proyek apa pun, sebagai plugin jika agen Anda mendukungnya atau dengan skills CLI di agen lainnya, lalu pilih spesialisasi keamanan yang sesuai dengan proyek tersebut. Kanonis: https://lagune.ai/id-ID/docs Bahasa: id-ID Asli: https://lagune.ai/docs Terakhir diperbarui: 2026-11-06 **Lagune** membantu agen AI Anda membuat proyek lebih aman. Anda cukup mengarahkannya ke kode Anda, lalu agen mencari tahu apa yang sebenarnya dilakukan sistem Anda dan memandu Anda menjalankan pekerjaan keamanan yang penting bagi sistem tersebut. **Lagune** adalah proyek pertama dari metodologi [Security-Driven Hardening (SDH)](https://lagune.ai/id-ID/docs/references/paper). **Dukung open source** Suka **Lagune**? [Beri kami ⭐ di **GitHub**](https://github.com/wellwelwel/lagune) ## Pilih agen Anda - [Claude Code](https://lagune.ai/id-ID/docs/install/claude-code): Tool coding agentic dari Anthropic - [Codex](https://lagune.ai/id-ID/docs/install/codex): Agen coding dari OpenAI - [Cursor](https://lagune.ai/id-ID/docs/install/cursor): Editor kode berbasis AI - [GitHub Copilot](https://lagune.ai/id-ID/docs/install/github-copilot-cli): Pair programmer AI dari GitHub - [Gemini CLI](https://lagune.ai/id-ID/docs/install/gemini-cli): Agen terminal open source dari Google - [Antigravity](https://lagune.ai/id-ID/docs/install/antigravity-cli): Platform pengembangan agentic dari Google - [OpenCode](https://lagune.ai/id-ID/docs/install/opencode): Agen coding open source - [Devin for Terminal](https://lagune.ai/id-ID/docs/install/devin-cli): Agen terminal dari Cognition - [Factory Droid](https://lagune.ai/id-ID/docs/install/factory-droid): Agen pengembangan perangkat lunak dari Factory - [Grok Build](https://lagune.ai/id-ID/docs/install/grok-build): Agen coding dari xAI - [Qwen Code](https://lagune.ai/id-ID/docs/install/qwen-code): Agen coding terminal dari Qwen - [Kimi Code](https://lagune.ai/id-ID/docs/install/kimi-code): Agen coding dari Moonshot AI - [Muse Code](https://lagune.ai/id-ID/docs/install/muse-code): Agen coding dari Meta - [Pi](https://lagune.ai/id-ID/docs/install/pi): Agen coding minimalis untuk terminal - [Hermes Agent](https://lagune.ai/id-ID/docs/install/hermes-agent): Agen open source dari Nous Research - [Universal](https://lagune.ai/id-ID/docs/install/universal): Cline, Kiro CLI, Windsurf, Zed dan 66 lainnya **Info** - Di balik layar, **Lagune** berjalan di **Node.js**, tetapi Anda bebas memakai bahasa apa pun. - Untuk menjalankannya sepenuhnya offline, instal **Lagune** di proyek Anda dengan `npm i -D lagune@0.18.1`. ## Kategori Pengetahuan keamanan **Lagune** hadir dalam bentuk [**spesialisasi**](https://lagune.ai/id-ID/docs/catalog), yang dikelompokkan ke dalam [**kategori**](https://lagune.ai/id-ID/docs/categories). - **OWASP** (`owasp`): Memperkuat aplikasi terhadap risiko keamanan yang dipantau OWASP: injection, kontrol akses yang rusak, serta kegagalan autentikasi dan kriptografi - **Infrastruktur** (`infra`): Memperkuat keamanan konfigurasi container, workload, dan serverless: Dockerfile, Compose, keamanan Pod, serta IAM dan trigger FaaS - **AI / LLM** (`ai`): Memperkuat keamanan integrasi AI dan LLM terhadap prompt injection serta sambungan tool, agen, retrieval, dan MCP yang tidak aman - **Lovable** (`lovable`): Memperkuat keamanan aplikasi Supabase buatan AI (Lovable dan sejenisnya): celah RLS, kunci service_role yang bocor, dan default yang tidak aman - **JavaScript** (`javascript`): Memperkuat keamanan JavaScript dan runtime-nya terhadap RCE lewat eval dan child_process, path traversal, serta prototype pollution - **Python** (`python`): Memperkuat keamanan Python terhadap RCE lewat deserialisasi pickle dan YAML, traversal string lewat str.format, serta class pollution - **Rust** (`rust`): Memperkuat keamanan Rust terhadap API unsafe yang tidak sound, penyalahgunaan transmute, integer overflow, dan undefined behavior di batas FFI - **Java** (`java`): Memperkuat keamanan Java terhadap gadget chain deserialisasi ObjectInputStream yang berujung pada eksekusi kode jarak jauh - **Ruby** (`ruby`): Memperkuat keamanan Ruby terhadap gadget chain deserialisasi Marshal.load dan YAML yang berujung pada eksekusi kode jarak jauh - **PHP** (`php`): Memperkuat keamanan PHP terhadap bypass autentikasi lewat type juggling, gadget chain object injection, dan default konfigurasi yang tidak aman - **Go** (`go`): Memperkuat keamanan Go terhadap bug interface typed-nil, data races antar-goroutine, dan konkurensi yang tidak aman di jalur kode yang menyangkut keamanan - **C / C++** (`c-cpp`): Memperkuat keamanan C dan C++ terhadap bug format string, buffer overflow, dan penulisan di luar batas memori yang membuka jalan bagi eksekusi kode - **.NET** (`dotnet`): Memperkuat keamanan .NET dan C# terhadap RCE lewat deserialisasi BinaryFormatter dan bypass encoder yang berujung pada XSS Jalankan `npx lagune write add --categories` dengan kunci kategori yang Anda pilih. **Tips** Setiap proyek dimulai dengan `owasp`, lalu perintah [`/lagune-charter`](https://lagune.ai/id-ID/docs/commands/charter) menambahkan kategori yang didukung oleh hasil pembacaannya atas proyek tersebut. ## Persyaratan [**Node.js (LTS)**](https://nodejs.org/en/download/package-manager) harus sudah terinstal di sistem Anda. ## Gunakan badge ✨ Memakai **Lagune**? Tambahkan salah satunya ke **README** Anda: **Dua warna** ![Secured By Lagune](https://img.shields.io/badge/Lagune-2f7bff?logo=springsecurity&logoColor=white&label=Secured%20By&labelColor=303952) ```md [![Secured By Lagune](https://img.shields.io/badge/Lagune-2f7bff?logo=springsecurity&logoColor=white&label=Secured%20By&labelColor=303952)](https://lagune.ai) ``` ![Security Powered By Lagune](https://img.shields.io/badge/Lagune-2f7bff?logo=springsecurity&logoColor=white&label=Security%20Powered%20By&labelColor=303952) ```md [![Security Powered By Lagune](https://img.shields.io/badge/Lagune-2f7bff?logo=springsecurity&logoColor=white&label=Security%20Powered%20By&labelColor=303952)](https://lagune.ai) ``` ![Security-Driven Hardening with Lagune](https://img.shields.io/badge/Lagune-2f7bff?logo=springsecurity&logoColor=white&label=Security-Driven%20Hardening&labelColor=303952) ```md [![Security-Driven Hardening with Lagune](https://img.shields.io/badge/Lagune-2f7bff?logo=springsecurity&logoColor=white&label=Security-Driven%20Hardening&labelColor=303952)](https://lagune.ai) ``` **Solid** ![Secured By Lagune](https://img.shields.io/badge/Secured%20By%20Lagune-2f7bff?logo=springsecurity&logoColor=white) ```md [![Secured By Lagune](https://img.shields.io/badge/Secured%20By%20Lagune-2f7bff?logo=springsecurity&logoColor=white)](https://lagune.ai) ``` ![Security Powered By Lagune](https://img.shields.io/badge/Security%20Powered%20By%20Lagune-2f7bff?logo=springsecurity&logoColor=white) ```md [![Security Powered By Lagune](https://img.shields.io/badge/Security%20Powered%20By%20Lagune-2f7bff?logo=springsecurity&logoColor=white)](https://lagune.ai) ``` ![Security-Driven Hardening](https://img.shields.io/badge/Security--Driven%20Hardening-2f7bff?logo=springsecurity&logoColor=white) ```md [![Security-Driven Hardening](https://img.shields.io/badge/Security--Driven%20Hardening-2f7bff?logo=springsecurity&logoColor=white)](https://lagune.ai) ``` ## Selanjutnya Lihat apa yang dilakukan setiap [**skill**](https://lagune.ai/id-ID/docs/get-started/commands) milik **Lagune**. ## Pertanyaan yang sering diajukan ### Apa itu Lagune? Lagune adalah alur kerja keamanan open source yang khusus pertahanan, yang membantu agen AI Anda memperkuat keamanan basis kode apa pun. Anda mengarahkannya ke kode Anda, Lagune mendeteksi apa yang sebenarnya dilakukan sistem Anda, lalu memandu perbaikan keamanan yang penting untuk konteks tersebut. ### Bagaimana cara menginstal Lagune? Pilih agen Anda: Claude Code, GitHub Copilot CLI, Muse Code, Antigravity CLI, Cursor, Kimi Code, OpenCode, Codex CLI, Factory Droid, Grok Build, Devin CLI, dan Hermes Agent menginstal Lagune sebagai plugin, Gemini CLI dan Qwen Code sebagai ekstensi, Pi sebagai paket, dan agen lain mana pun dengan npx skills add wellwelwel/lagune. Lagune bekerja di proyek baru maupun lama. ### Apakah Lagune memerlukan kunci API? Tidak. Lagune berjalan melalui agen AI Anda sendiri, jadi tidak perlu kunci API. ### Apa saja persyaratannya? Node.js (LTS) harus sudah terinstal di sistem Anda. ### Bahasa pemrograman apa saja yang didukung Lagune? Semua. Di balik layar, Lagune berjalan di Node.js, tetapi Lagune mengaudit dan memperkuat keamanan proyek yang ditulis dalam bahasa pemrograman apa pun. ### Apa yang ditambahkan Lagune ke proyek saya? Direktori .lagune/ yang berisi status keamanan proyek Anda, dibuat oleh perintah pertama yang menulis sesuatu. Selain itu, skills CLI menginstal perintah slash di proyek, tempat agen Anda membacanya, sedangkan plugin menyimpannya di dalam agen. ### Bagaimana cara memperbarui Lagune? Sama seperti saat Anda menginstalnya. Halaman instalasi setiap agen menunjukkan cara memperbarui Lagune di agen tersebut, dan skills CLI memperbaruinya dengan npx skills update. Charter, artefak fase, dan spesialisasi milik Anda sendiri tetap utuh. ### Spesialisasi apa saja yang dipakai sebuah proyek? Spesialisasi bawaan dari kategorinya, ditambah spesialisasi milik proyek itu sendiri. Charter mencatat kategori yang didukung oleh hasil pembacaannya atas proyek, dan npx lagune write add --categories mengubahnya. ### Apakah saya harus selesai membangun proyek sebelum mengamankannya? Tidak. Perintah /lagune memperkuat keamanan pekerjaan Anda selagi ditulis: perintah ini menerima prompt apa pun, membangun apa yang Anda minta, lalu memperkuatnya dengan default yang aman, dipandu oleh charter. Alur Blue Team lima fase mengaudit apa yang sudah ada. ### Apakah Lagune bisa mengaudit proyek yang sudah ada? Bisa. Alur Blue Team lima fase mengaudit apa yang sudah ada: charter menetapkan aturan keamanan Anda, detect memetakan apa yang dilakukan sistem dan di mana risikonya, plan memberi skor setiap temuan dan memasangkannya dengan perbaikan, harden menerapkan perbaikan, dan verify membuktikan perbaikan tersebut tetap efektif lalu menutupnya. ### Apa bedanya memakai Lagune dengan sekadar meminta agen memetakan kerentanan dan celah keamanan? Agen yang membaca kode sendiri akan menemukan apa yang tampak seperti kerentanan dan melewatkan apa yang tampak seperti kontrol. Daftar alamat yang diblokir terlihat seolah risikonya sudah ditangani, sehingga tidak ada yang memeriksa bahwa daftar itu melewatkan sebagian besar alamat, dan kodenya pun dirilis. Lagune membalik kebiasaan itu: pengaman yang sudah ada di kode dianggap belum terbukti sampai diperiksa, setiap spesialisasi di katalog mendapat putusan yang eksplisit, dan verify menanyakan apakah risikonya sudah hilang, bukan apakah kontrolnya ada. Setiap temuan juga tetap menjadi satu item yang dilacak dari satu eksekusi ke eksekusi berikutnya, sehingga bisa dibuktikan tuntas lalu ditutup, sedangkan permintaan biasa memberi Anda laporan yang berbeda setiap kali tanpa ada yang bisa dibandingkan. ### Apa bedanya mengembangkan dengan Lagune dengan sekadar meminta agen menulis kode yang aman? Meminta kode yang aman berarti menyerahkan arti aman kepada agen, dan mengandaikan Anda tahu apa yang harus diminta. Persyaratannya biasanya sudah ada di dalam permintaan Anda tanpa disadari oleh Anda maupun agen: meminta halaman yang menampilkan kursus yang boleh diakses seorang pengguna sudah menyatakan sebuah aturan otorisasi, dan pemeriksaan yang tidak pernah ditulis tidak meninggalkan apa pun di kode untuk disadari. Perintah /lagune memuat charter Anda dan spesialisasi yang cocok dengan apa yang akan dibangun sebelum baris pertama ditulis, lalu membaca ulang hasilnya berdasarkan pertahanan yang dipakainya. Bentuk yang aman jarang lebih mahal daripada yang tidak aman, jadi yang menentukan hasilnya adalah mengetahui mana yang harus dipilih, dan justru itulah yang tersedia sejak awal. ### Apakah Lagune menjalankan DAST (Dynamic Application Security Testing) atau mengetes aplikasi saya yang sedang berjalan? Tidak. Lagune membaca kode dan tidak pernah menjalankan sistem Anda atau mengirim request yang sengaja dirancang ke sistem tersebut. Verify memastikan sebuah kontrol ada dan benar di kode sumber, dan itu pertanyaan yang berbeda dari apakah kontrol tersebut tahan terhadap serangan pada target yang sedang berjalan, sehingga "cannot tell from the code" adalah putusan yang sah, bukan sekadar diloloskan diam-diam. DAST menjawab pertanyaan saat runtime dan Lagune menjawab pertanyaan di kode sumber, jadi keduanya tidak saling menggantikan. Bahkan perintah prove yang opsional pun memegang batas ini: tesnya memastikan perilaku yang aman, tidak pernah memakai payload serangan. ### Apakah Lagune menggantikan pentest (penetration test)? Tidak, sama sekali tidak! Pentest adalah penugasan resmi yang diizinkan, ketika seorang profesional menggunakan penilaiannya sendiri terhadap sistem Anda yang sedang berjalan, merangkai temuan dan menyelidiki logika bisnis yang tidak dijelaskan oleh aturan per permukaan serangan mana pun. Temuan dari pentest bisa masuk ke alur Blue Team Lagune sebagai kekhawatiran yang Anda serahkan ke detect, sehingga apa yang dilaporkan profesional tersebut direncanakan, diperkuat, dan diverifikasi. ## Kebijakan keamanan Lihat [SECURITY.md](https://github.com/wellwelwel/lagune/blob/main/SECURITY.md). ## Lisensi **Lagune** dirilis di bawah [Apache License 2.0](https://github.com/wellwelwel/lagune/blob/main/LICENSE). Copyright © 2026-sekarang [Weslley Araújo](https://github.com/wellwelwel) dan [kontributor](https://github.com/wellwelwel/lagune/graphs/contributors). --- # Cara menginstal Lagune di Antigravity CLI sebagai plugin > Instal Lagune di Antigravity CLI sebagai plugin, jaga agar tetap terbaru, dan izinkan engine-nya sejak awal. Kanonis: https://lagune.ai/id-ID/docs/install/antigravity-cli Bahasa: id-ID Asli: https://lagune.ai/docs/install/antigravity-cli Terakhir diperbarui: 2026-11-06 Instal plugin dari terminal Anda: ```bash agy plugin install https://github.com/wellwelwel/lagune/tree/plugin-antigravity ``` ## Pembaruan Untuk memperbarui **Lagune**, instal ulang: ```bash agy plugin install https://github.com/wellwelwel/lagune/tree/plugin-antigravity ``` ## Perintah Ketik perintah dengan nama plugin di depannya, misalnya `/lagune:lagune-charter` untuk `/lagune-charter`. --- **Izin** Engine berjalan melalui dua tool: `lagune_read` hanya membaca proyek Anda, dan `lagune_write` hanya menulis ke `.lagune/`. Perintah yang dikirim sebagai pesan pertama sebuah sesi berjalan sebelum kedua tool itu dimuat, sehingga perintah tersebut memakai **npx** sebagai gantinya. Untuk mengizinkan kedua tool itu dan **npx** sejak awal, tambahkan aturan berikut ke `~/.gemini/antigravity-cli/settings.json`: ```json { "permissions": { "allow": [ "mcp(lagune_lagune/lagune_read)", "mcp(lagune_lagune/lagune_write)", "command(regex:npx --yes lagune@[0-9.]+)" ] } } ``` ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di Antigravity CLI? Jalankan agy plugin install https://github.com/wellwelwel/lagune/tree/plugin-antigravity. ### Bagaimana cara memperbarui Lagune di Antigravity CLI? Jalankan lagi agy plugin install https://github.com/wellwelwel/lagune/tree/plugin-antigravity. ### Bagaimana cara menjalankan perintah Lagune di Antigravity CLI? Ketik perintah dengan nama plugin di depannya, misalnya /lagune:lagune-charter. ### Apakah Antigravity CLI bisa menjalankan Lagune tanpa meminta izin? Ya. Izinkan mcp(lagune_lagune/lagune_read), mcp(lagune_lagune/lagune_write), dan command(regex:npx --yes lagune@[0-9.]+) di pengaturan Antigravity CLI. Aturan npx mencakup perintah yang dikirim sebagai pesan pertama sebuah sesi. --- # Cara menginstal Lagune di Claude Code sebagai plugin > Instal Lagune di Claude Code sebagai plugin, di terminal, ekstensi, atau aplikasi desktop, jaga agar tetap terbaru, dan izinkan engine-nya sejak awal. Kanonis: https://lagune.ai/id-ID/docs/install/claude-code Bahasa: id-ID Asli: https://lagune.ai/docs/install/claude-code Terakhir diperbarui: 2026-11-06 **Terminal** Instal plugin dari terminal Anda: ```bash claude plugin install lagune --marketplace wellwelwel/lagune ``` Atau dari sesi **Claude Code**: ```text /plugin marketplace add wellwelwel/lagune /plugin install lagune@lagune ``` **Ekstensi** - Ketik `/plugin` lalu pilih **Manage plugins**. - Tambahkan `wellwelwel/lagune` di tab **Marketplaces**. - Instal `lagune` di tab **Plugins**. **Desktop** - Instal **Lagune** dari terminal atau ekstensi, dengan memilih **Install for you** di ekstensi. - Mulai sesi baru di aplikasi desktop. Aplikasi ini memuat plugin yang Anda instal untuk diri Anda sendiri. ## Pembaruan **Terminal** Untuk memperbarui **Lagune**, jalankan: ```bash claude plugin marketplace update lagune claude plugin update lagune@lagune ``` Agar tetap terbaru, pilih **Enable auto-update** untuk marketplace `lagune` di `/plugin`. **Ekstensi** - Ketik `/plugin` lalu pilih **Manage plugins**. - Buka tab **Marketplaces**. - Pilih ikon muat ulang di `lagune`. **Desktop** - Perbarui **Lagune** dari terminal atau ekstensi. - Mulai sesi baru di aplikasi desktop. ## Perintah Ketik perintah dengan namanya, misalnya `/lagune-charter`, atau dengan nama plugin di depannya, misalnya `/lagune:lagune-charter`. --- **Izin** Engine berjalan melalui dua tool: `lagune_read` hanya membaca proyek Anda, dan `lagune_write` hanya menulis ke `.lagune/`. Untuk mengizinkannya sejak awal, tambahkan aturan berikut ke `.claude/settings.json` untuk satu proyek, atau ke `~/.claude/settings.json` untuk semua proyek: ```json { "permissions": { "allow": [ "mcp__plugin_lagune_lagune__lagune_read", "mcp__plugin_lagune_lagune__lagune_write" ] } } ``` Saat engine berjalan melalui **npx**, seperti pada **skills.sh**, izinkan `Bash(npx --yes lagune@*)`. Jika sandbox aktif, tambahkan juga `registry.npmjs.org` ke `sandbox.network.allowedDomains`. ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di Claude Code? Jalankan claude plugin install lagune --marketplace wellwelwel/lagune. Di sesi atau di ekstensi, tambahkan marketplace wellwelwel/lagune dari pengelola plugin, lalu instal lagune. Aplikasi desktop memuatnya setelah Anda menginstalnya untuk diri Anda sendiri di terminal atau ekstensi. ### Bagaimana cara memperbarui Lagune di Claude Code? Jalankan claude plugin marketplace update lagune, lalu claude plugin update lagune@lagune, atau pilih Enable auto-update untuk marketplace lagune di /plugin. Di ekstensi, buka Manage plugins dari /plugin dan pilih ikon muat ulang di marketplace lagune. Aplikasi desktop memuat pembaruan itu di sesi berikutnya. ### Bagaimana cara menjalankan perintah Lagune di Claude Code? Ketik perintah dengan namanya, misalnya /lagune-charter, atau dengan nama plugin di depannya, misalnya /lagune:lagune-charter. ### Apakah Claude Code bisa menjalankan Lagune tanpa meminta izin? Ya. Izinkan mcp__plugin_lagune_lagune__lagune_read dan mcp__plugin_lagune_lagune__lagune_write di pengaturan Claude Code Anda, ditambah Bash(npx --yes lagune@*) saat engine berjalan melalui npx. --- # Cara menginstal Lagune di Codex CLI sebagai plugin > Instal Lagune di Codex CLI sebagai plugin, jaga agar tetap terbaru, dan jalankan engine-nya di dalam sandbox. Kanonis: https://lagune.ai/id-ID/docs/install/codex Bahasa: id-ID Asli: https://lagune.ai/docs/install/codex Terakhir diperbarui: 2026-11-07 Instal plugin dari terminal Anda: ```bash codex plugin marketplace add wellwelwel/lagune codex plugin add lagune@lagune ``` ## Pembaruan Untuk memperbarui **Lagune**, jalankan: ```bash codex plugin marketplace upgrade lagune ``` ## Perintah Ketik `$` dan perintah dengan nama plugin di depannya, diikuti input Anda, misalnya `$lagune:lagune-charter` untuk `/lagune-charter`. Saat Anda mengetik `$`, daftar perintah muncul, dan memilih salah satunya menyisipkan nama lengkapnya. --- **Sandbox** Sandbox **Codex** tidak punya akses jaringan. Instal engine di proyek Anda dari terminal Anda sendiri, sekali di awal dan lagi setelah setiap pembaruan: ```bash npm i -D lagune@0.18.1 ``` ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di Codex CLI? Jalankan codex plugin marketplace add wellwelwel/lagune, lalu codex plugin add lagune@lagune. ### Bagaimana cara memperbarui Lagune di Codex CLI? Jalankan codex plugin marketplace upgrade lagune. ### Bagaimana cara menjalankan perintah Lagune di Codex CLI? Ketik $ dan perintah dengan nama plugin di depannya, diikuti input Anda, misalnya $lagune:lagune-charter. ### Apakah Lagune berfungsi di dalam sandbox Codex? Ya, setelah Anda menginstal engine di proyek Anda dengan npm i -D lagune@0.18.1 dari terminal Anda sendiri, sekali di awal dan lagi setelah setiap pembaruan. --- # Cara menginstal Lagune di Cursor sebagai plugin > Instal Lagune di Cursor dan Cursor CLI sebagai plugin, jaga agar tetap terbaru, dan izinkan engine-nya sejak awal. Kanonis: https://lagune.ai/id-ID/docs/install/cursor Bahasa: id-ID Asli: https://lagune.ai/docs/install/cursor Terakhir diperbarui: 2026-11-06 **Cursor** - Buka **Customize**. - Pilih **From GitHub Repository** lalu masukkan `https://github.com/wellwelwel/lagune`. - Pilih **Install** pada **Lagune** lalu tentukan cakupan proyek atau pengguna. **Cursor CLI** - Tambahkan marketplace dari terminal Anda: ```bash agent plugin marketplace add https://github.com/wellwelwel/lagune --git-ref plugin-cursor ``` - Ketik `/plugins` di sesi `agent`. - Instal **Lagune**. Jika **Lagune** sudah terinstal di **Claude Code**, **Cursor CLI** memuatnya dari sana. ## Pembaruan **Cursor** - Buka **Customize**. - Pilih **Refresh** pada marketplace `lagune`. **Cursor CLI** - Ganti marketplace dari terminal Anda: ```bash agent plugin marketplace remove lagune agent plugin marketplace add https://github.com/wellwelwel/lagune --git-ref plugin-cursor ``` - Ketik `/plugins` di sesi `agent`. - Instal **Lagune** lagi. ## Perintah Ketik perintah dengan namanya, misalnya `/lagune-charter`. --- **Izin** Di **Cursor**, setiap perintah menjalankan engine melalui **npx**, dan mode Auto-review default mengizinkannya tanpa bertanya. Di **Cursor CLI**, engine berjalan melalui dua tool: `lagune_read` hanya membaca proyek Anda, dan `lagune_write` hanya menulis ke `.lagune/`. Untuk mengizinkannya sejak awal, tambahkan aturan berikut ke `.cursor/cli.json` untuk satu proyek, atau ke `~/.cursor/cli-config.json` untuk semua proyek: ```json { "permissions": { "allow": [ "Mcp(plugin-lagune-lagune:lagune_read)", "Mcp(plugin-lagune-lagune:lagune_write)" ] } } ``` Saat engine berjalan melalui **npx**, seperti pada **skills.sh**, izinkan `Shell(npx:--yes lagune@*)`. ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di Cursor? Di Cursor, buka Customize, pilih From GitHub Repository, masukkan https://github.com/wellwelwel/lagune, lalu instal Lagune. Di Cursor CLI, jalankan agent plugin marketplace add https://github.com/wellwelwel/lagune --git-ref plugin-cursor, lalu instal Lagune dari /plugins. ### Bagaimana cara memperbarui Lagune di Cursor? Di Cursor, pilih Refresh pada marketplace lagune di Customize. Di Cursor CLI, hapus marketplace lagune, tambahkan lagi, lalu instal Lagune lagi dari /plugins. ### Bagaimana cara menjalankan perintah Lagune di Cursor? Ketik perintah dengan namanya, misalnya /lagune-charter. ### Apakah Cursor bisa menjalankan Lagune tanpa meminta izin? Ya. Mode Auto-review default di Cursor sudah mengizinkannya. Di Cursor CLI, izinkan Mcp(plugin-lagune-lagune:lagune_read) dan Mcp(plugin-lagune-lagune:lagune_write), ditambah Shell(npx:--yes lagune@*) saat engine berjalan melalui npx. --- # Cara menginstal Lagune di Devin CLI sebagai plugin > Instal Lagune di Devin CLI sebagai plugin, dan jaga agar tetap terbaru. Kanonis: https://lagune.ai/id-ID/docs/install/devin-cli Bahasa: id-ID Asli: https://lagune.ai/docs/install/devin-cli Terakhir diperbarui: 2026-11-06 Masuk ke **Devin**, lalu instal plugin dari terminal Anda: ```bash devin auth login devin plugins install wellwelwel/lagune ``` ## Pembaruan Untuk memperbarui **Lagune**, jalankan: ```bash devin plugins update lagune ``` ## Perintah Ketik perintah dengan nama plugin di depannya, misalnya `/lagune:lagune-charter` untuk `/lagune-charter`. Menu `/` juga menampilkan daftarnya. ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di Devin CLI? Masuk dengan devin auth login, lalu jalankan devin plugins install wellwelwel/lagune. ### Bagaimana cara memperbarui Lagune di Devin CLI? Jalankan devin plugins update lagune. ### Bagaimana cara menjalankan perintah Lagune di Devin CLI? Ketik perintah dengan nama plugin di depannya, misalnya /lagune:lagune-charter. Menu / juga menampilkan daftarnya. --- # Cara menginstal Lagune di Factory Droid sebagai plugin > Instal Lagune di Factory Droid sebagai plugin, jaga agar tetap terbaru, dan izinkan tool engine-nya. Kanonis: https://lagune.ai/id-ID/docs/install/factory-droid Bahasa: id-ID Asli: https://lagune.ai/docs/install/factory-droid Terakhir diperbarui: 2026-11-07 Instal plugin dari terminal Anda: ```bash droid plugin marketplace add wellwelwel/lagune droid plugin install lagune@lagune ``` ## Pembaruan Untuk memperbarui **Lagune**, jalankan: ```bash droid plugin marketplace update lagune droid plugin update lagune@lagune ``` ## Perintah Ketik perintah dengan namanya, misalnya `/lagune-charter`. ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di Factory Droid? Jalankan droid plugin marketplace add wellwelwel/lagune, lalu droid plugin install lagune@lagune. ### Bagaimana cara memperbarui Lagune di Factory Droid? Jalankan droid plugin marketplace update lagune, lalu droid plugin update lagune@lagune. ### Bagaimana cara menjalankan perintah Lagune di Factory Droid? Ketik perintah dengan namanya, misalnya /lagune-charter. ### Apakah Factory Droid bisa menjalankan Lagune tanpa meminta izin? Ya. Pilih untuk selalu mengizinkan lagune_read dan lagune_write saat Factory Droid meminta izin. Factory Droid akan meminta lagi setelah menyinkronkan commit baru dari marketplace lagune. --- # Cara menginstal Lagune di Gemini CLI sebagai ekstensi > Instal Lagune di Gemini CLI sebagai ekstensi, jaga agar tetap terbaru, dan izinkan engine-nya sejak awal. Kanonis: https://lagune.ai/id-ID/docs/install/gemini-cli Bahasa: id-ID Asli: https://lagune.ai/docs/install/gemini-cli Terakhir diperbarui: 2026-11-06 Instal ekstensi dari terminal Anda: ```bash gemini extensions install https://github.com/wellwelwel/lagune ``` ## Pembaruan Untuk memperbarui **Lagune**, jalankan: ```bash gemini extensions update lagune ``` Agar tetap terbaru, instal dengan `--auto-update`. ## Perintah Ketik perintah dengan nama ekstensi di depannya, misalnya `/lagune:lagune-charter` untuk `/lagune-charter`. --- **Izin** Engine berjalan melalui dua tool: `lagune_read` hanya membaca proyek Anda, dan `lagune_write` hanya menulis ke `.lagune/`. **Gemini CLI** hanya menjalankannya di folder tepercaya. Untuk mengizinkannya sejak awal, simpan aturan ini sebagai `~/.gemini/policies/lagune.toml`: ```toml [[rule]] mcpName = "lagune" toolName = ["lagune_read", "lagune_write"] decision = "allow" priority = 100 ``` Saat engine berjalan melalui **npx**, seperti pada **skills.sh**, tambahkan aturan ini ke file yang sama: ```toml [[rule]] toolName = "run_shell_command" commandRegex = 'npx --yes lagune@\d+\.\d+\.\d+\s' decision = "allow" priority = 100 ``` ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di Gemini CLI? Jalankan gemini extensions install https://github.com/wellwelwel/lagune. ### Bagaimana cara memperbarui Lagune di Gemini CLI? Jalankan gemini extensions update lagune, atau instal ekstensi dengan --auto-update. ### Bagaimana cara menjalankan perintah Lagune di Gemini CLI? Ketik perintah dengan nama ekstensi di depannya, misalnya /lagune:lagune-charter. ### Apakah Gemini CLI bisa menjalankan Lagune tanpa meminta izin? Ya. Tambahkan aturan kebijakan yang mengizinkan tool lagune_read dan lagune_write dari server lagune, ditambah satu aturan untuk run_shell_command dengan npx --yes lagune@ dan nomor versi saat engine berjalan melalui npx. --- # Cara menginstal Lagune di GitHub Copilot CLI sebagai plugin > Instal Lagune di GitHub Copilot CLI sebagai plugin, dan jaga agar tetap terbaru. Kanonis: https://lagune.ai/id-ID/docs/install/github-copilot-cli Bahasa: id-ID Asli: https://lagune.ai/docs/install/github-copilot-cli Terakhir diperbarui: 2026-11-06 Instal plugin dari terminal Anda: ```bash copilot plugin marketplace add wellwelwel/lagune copilot plugin install lagune@lagune ``` Di editor, instal **Lagune** untuk **GitHub Copilot** dengan [**skills.sh**](https://lagune.ai/id-ID/docs/install/universal). ## Pembaruan Untuk memperbarui **Lagune**, jalankan: ```bash copilot plugin marketplace update lagune copilot plugin update lagune@lagune ``` ## Perintah Ketik perintah dengan namanya, misalnya `/lagune-charter`. ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di GitHub Copilot CLI? Jalankan copilot plugin marketplace add wellwelwel/lagune, lalu copilot plugin install lagune@lagune. ### Bagaimana cara memperbarui Lagune di GitHub Copilot CLI? Jalankan copilot plugin marketplace update lagune, lalu copilot plugin update lagune@lagune. ### Bagaimana cara menjalankan perintah Lagune di GitHub Copilot CLI? Ketik perintah dengan namanya, misalnya /lagune-charter. ### Apakah saya bisa memakai Lagune dengan GitHub Copilot di VS Code? Ya. Di VS Code atau editor lain, instal Lagune dengan skills.sh, bukan dengan plugin. --- # Cara menginstal Lagune di Grok Build sebagai plugin > Instal Lagune di Grok Build sebagai plugin, jaga agar tetap terbaru, dan izinkan engine-nya sejak awal. Kanonis: https://lagune.ai/id-ID/docs/install/grok-build Bahasa: id-ID Asli: https://lagune.ai/docs/install/grok-build Terakhir diperbarui: 2026-11-06 Instal plugin dari terminal Anda: ```bash grok plugin install wellwelwel/lagune@plugin-grok --trust ``` ## Pembaruan Untuk memperbarui **Lagune**, jalankan: ```bash grok plugin update lagune ``` ## Perintah Ketik perintah dengan namanya, misalnya `/lagune-charter`, atau dengan nama plugin di depannya, misalnya `/lagune:lagune-charter`. --- **Izin** Engine berjalan melalui dua tool: `lagune_read` hanya membaca proyek Anda, dan `lagune_write` hanya menulis ke `.lagune/`. Untuk mengizinkannya sejak awal, tambahkan aturan berikut ke `~/.grok/config.toml`: ```toml [permission] allow = ["MCPTool(lagune__lagune_read)", "MCPTool(lagune__lagune_write)"] ``` Saat engine berjalan melalui **npx**, seperti pada **skills.sh**, izinkan `Bash(npx --yes lagune@*)`. ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di Grok Build? Jalankan grok plugin install wellwelwel/lagune@plugin-grok --trust. ### Bagaimana cara memperbarui Lagune di Grok Build? Jalankan grok plugin update lagune. ### Bagaimana cara menjalankan perintah Lagune di Grok Build? Ketik perintah dengan namanya, misalnya /lagune-charter, atau dengan nama plugin di depannya, misalnya /lagune:lagune-charter. ### Apakah Grok Build bisa menjalankan Lagune tanpa meminta izin? Ya. Izinkan MCPTool(lagune__lagune_read) dan MCPTool(lagune__lagune_write) di konfigurasi Grok Build, ditambah Bash(npx --yes lagune@*) saat engine berjalan melalui npx. --- # Cara menginstal Lagune di Hermes Agent sebagai plugin > Instal Lagune di Hermes Agent sebagai plugin, dan jaga agar tetap terbaru. Kanonis: https://lagune.ai/id-ID/docs/install/hermes-agent Bahasa: id-ID Asli: https://lagune.ai/docs/install/hermes-agent Terakhir diperbarui: 2026-11-06 Instal plugin dari terminal Anda: ```bash hermes plugins install wellwelwel/lagune --enable ``` - Saat **Hermes Agent** meminta Anda mengonfirmasi plugin dari luar katalognya, **konfirmasikan**. - Saat agen menawarkan untuk menginstal dependensi **Node.js** milik repositori, **tolak**. ## Pembaruan Untuk memperbarui **Lagune**, jalankan: ```bash hermes plugins update lagune ``` ## Perintah Ketik perintah dengan nama plugin di depannya, misalnya `/lagune:lagune-charter` untuk `/lagune-charter` dan `/lagune:lagune` untuk `/lagune`. ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di Hermes Agent? Jalankan hermes plugins install wellwelwel/lagune --enable. Konfirmasikan plugin saat diminta, dan tolak instalasi dependensi Node.js milik repositori. ### Bagaimana cara memperbarui Lagune di Hermes Agent? Jalankan hermes plugins update lagune. ### Bagaimana cara menjalankan perintah Lagune di Hermes Agent? Ketik perintah dengan nama plugin di depannya, misalnya /lagune:lagune-charter dan /lagune:lagune. --- # Cara menginstal Lagune di Kimi Code sebagai plugin > Instal Lagune di Kimi Code sebagai plugin, dan jaga agar tetap terbaru. Kanonis: https://lagune.ai/id-ID/docs/install/kimi-code Bahasa: id-ID Asli: https://lagune.ai/docs/install/kimi-code Terakhir diperbarui: 2026-11-06 Instal plugin dari sesi **Kimi Code**, pilih **Trust and install**, lalu mulai sesi baru untuk memuatnya: ```text /plugins install https://github.com/wellwelwel/lagune /new ``` ## Pembaruan Untuk memperbarui **Lagune**, instal ulang: ```text /plugins install https://github.com/wellwelwel/lagune /new ``` ## Perintah Ketik perintah dengan nama plugin di depannya, misalnya `/lagune:lagune-charter` untuk `/lagune-charter`. Menu `/` menampilkannya sebagai `/skill:lagune:lagune-charter`, yang juga bisa dipakai. ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di Kimi Code? Di sesi Kimi Code, jalankan /plugins install https://github.com/wellwelwel/lagune, pilih Trust and install, lalu jalankan /new. ### Bagaimana cara memperbarui Lagune di Kimi Code? Jalankan lagi /plugins install https://github.com/wellwelwel/lagune, lalu /new. ### Bagaimana cara menjalankan perintah Lagune di Kimi Code? Ketik perintah dengan nama plugin di depannya, misalnya /lagune:lagune-charter, atau seperti yang ditampilkan menu /, misalnya /skill:lagune:lagune-charter. --- # Cara menginstal Lagune di Muse Code sebagai plugin > Instal Lagune di Muse Code sebagai plugin, jaga agar tetap terbaru, dan jalankan engine-nya di dalam sandbox. Kanonis: https://lagune.ai/id-ID/docs/install/muse-code Bahasa: id-ID Asli: https://lagune.ai/docs/install/muse-code Terakhir diperbarui: 2026-11-07 Instal plugin dari terminal Anda: ```bash muse plugins marketplace add lagune wellwelwel/lagune muse plugins install lagune@lagune ``` ## Pembaruan Untuk memperbarui **Lagune**, segarkan marketplace lalu instal ulang plugin: ```bash muse plugins marketplace update lagune muse plugins remove lagune muse plugins install lagune@lagune ``` ## Perintah Ketik perintah dengan namanya, misalnya `/lagune-charter`, atau dengan nama plugin di depannya, misalnya `/lagune:lagune-charter`. --- **Sandbox** Sandbox **Muse Code** tidak bisa mengunduh engine. Instal engine di proyek Anda dari terminal Anda sendiri, sekali di awal dan lagi setelah setiap pembaruan: ```bash npm i -D lagune@0.18.1 ``` ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di Muse Code? Jalankan muse plugins marketplace add lagune wellwelwel/lagune, lalu muse plugins install lagune@lagune. ### Bagaimana cara memperbarui Lagune di Muse Code? Jalankan muse plugins marketplace update lagune, lalu instal ulang dengan muse plugins remove lagune dan muse plugins install lagune@lagune. ### Bagaimana cara menjalankan perintah Lagune di Muse Code? Ketik perintah dengan namanya, misalnya /lagune-charter, atau dengan nama plugin di depannya, misalnya /lagune:lagune-charter. ### Apakah Lagune berfungsi di dalam sandbox Muse Code? Ya, setelah Anda menginstal engine di proyek Anda dengan npm i -D lagune@0.18.1 dari terminal Anda sendiri, sekali di awal dan lagi setelah setiap pembaruan. --- # Cara menginstal Lagune di OpenCode sebagai plugin > Instal Lagune di OpenCode 1.x dan 2.x sebagai plugin, dan jaga agar tetap terbaru. Kanonis: https://lagune.ai/id-ID/docs/install/opencode Bahasa: id-ID Asli: https://lagune.ai/docs/install/opencode Terakhir diperbarui: 2026-11-07 **OpenCode 2.x** Instal plugin dari terminal Anda: ```bash opencode plugin add lagune ``` Atau tambahkan ke daftar `plugins` di `opencode.json`: ```json { "plugins": ["lagune"] } ``` **OpenCode 1.x** Instal plugin di proyek Anda dari terminal, atau tambahkan `-g` untuk menginstalnya di semua proyek Anda: ```bash opencode plugin lagune ``` Atau tambahkan ke daftar `plugin` di `opencode.json`: ```json { "plugin": ["lagune"] } ``` ## Pembaruan **OpenCode 2.x** Untuk memperbarui **Lagune**, jalankan: ```bash opencode plugin update lagune opencode reload ``` **OpenCode 1.x** Untuk memperbarui **Lagune**, instal rilis baru di atas rilis lama, dengan menambahkan `-g` jika Anda menginstalnya di semua proyek Anda: ```bash opencode plugin lagune@0.18.1 --force ``` ## Perintah **OpenCode 2.x** Ketik `@` lalu pilih perintahnya, misalnya `@lagune-charter`, kemudian tulis input Anda di pesan yang sama. **OpenCode 1.x** Ketik perintah dengan namanya, misalnya `/lagune-charter`. Perintah ini tercantum di `/skills`, bukan di menu `/`. ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di OpenCode? Di OpenCode 2.x, jalankan opencode plugin add lagune. Di OpenCode 1.x, jalankan opencode plugin lagune, dengan menambahkan -g untuk menginstalnya di semua proyek Anda. ### Bagaimana cara memperbarui Lagune di OpenCode? Di OpenCode 2.x, jalankan opencode plugin update lagune, lalu opencode reload. Di OpenCode 1.x, jalankan opencode plugin lagune@0.18.1 --force. ### Bagaimana cara menjalankan perintah Lagune di OpenCode? Di OpenCode 2.x, ketik @ lalu pilih perintahnya, misalnya @lagune-charter, kemudian tulis input Anda di pesan yang sama. Di OpenCode 1.x, ketik perintah dengan namanya, misalnya /lagune-charter, atau temukan di /skills. ### Apakah OpenCode meminta izin sebelum Lagune berjalan? Tidak. OpenCode menjalankan dua tool milik engine, lagune_read dan lagune_write, tanpa bertanya. --- # Cara menginstal Lagune di Pi sebagai paket > Instal Lagune di Pi sebagai paket, dari npm atau dari GitHub, dan jaga agar tetap terbaru. Kanonis: https://lagune.ai/id-ID/docs/install/pi Bahasa: id-ID Asli: https://lagune.ai/docs/install/pi Terakhir diperbarui: 2026-11-06 **npm** Instal paket dari terminal Anda: ```bash pi install npm:lagune ``` **GitHub** Instal commit terbaru dari **GitHub**, yang menjalankan engine melalui **npx**: ```bash pi install git:github.com/wellwelwel/lagune ``` ## Pembaruan **npm** Untuk memperbarui **Lagune**, jalankan: ```bash pi update npm:lagune ``` **GitHub** Untuk memperbarui **Lagune**, jalankan: ```bash pi update git:github.com/wellwelwel/lagune ``` `pi update --extensions` memperbarui semua paket yang Anda instal, sedangkan `pi update` saja hanya memperbarui **Pi**. ## Perintah Ketik perintah dengan awalan `skill:`, misalnya `/skill:lagune-charter` untuk `/lagune-charter`. ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di Pi? Jalankan pi install npm:lagune, atau pi install git:github.com/wellwelwel/lagune untuk commit terbaru dari GitHub. ### Bagaimana cara memperbarui Lagune di Pi? Jalankan pi update npm:lagune, atau pi update git:github.com/wellwelwel/lagune untuk instalasi dari GitHub. pi update --extensions memperbarui semua paket yang Anda instal. ### Bagaimana cara menjalankan perintah Lagune di Pi? Ketik perintah dengan awalan skill:, misalnya /skill:lagune-charter. --- # Cara menginstal Lagune di Qwen Code sebagai ekstensi > Instal Lagune di Qwen Code sebagai ekstensi, jaga agar tetap terbaru, dan izinkan engine-nya sejak awal. Kanonis: https://lagune.ai/id-ID/docs/install/qwen-code Bahasa: id-ID Asli: https://lagune.ai/docs/install/qwen-code Terakhir diperbarui: 2026-11-06 Instal ekstensi dari terminal Anda: ```bash qwen extensions install lagune ``` ## Pembaruan Untuk memperbarui **Lagune**, jalankan: ```bash qwen extensions update lagune ``` Agar selalu terbaru, instal dengan `--auto-update`. ## Perintah Ketik perintah dengan nama ekstensi di depannya, misalnya `/lagune:lagune-charter` untuk `/lagune-charter`. --- **Izin** Engine berjalan melalui dua tool: `lagune_read` hanya membaca proyek Anda, dan `lagune_write` hanya menulis ke `.lagune/`. Untuk mengizinkannya sejak awal, tambahkan aturan berikut ke `.qwen/settings.json` untuk satu proyek, atau ke `~/.qwen/settings.json` untuk semua proyek: ```json { "permissions": { "allow": ["mcp__lagune__lagune_read", "mcp__lagune__lagune_write"] } } ``` Saat engine berjalan melalui **npx**, seperti pada **skills.sh**, izinkan `Shell(npx --yes lagune@*)`. ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di Qwen Code? Jalankan qwen extensions install lagune. ### Bagaimana cara memperbarui Lagune di Qwen Code? Jalankan qwen extensions update lagune, atau instal ekstensi dengan --auto-update. ### Bagaimana cara menjalankan perintah Lagune di Qwen Code? Ketik perintah dengan nama ekstensi di depannya, misalnya /lagune:lagune-charter. ### Apakah Qwen Code bisa menjalankan Lagune tanpa meminta izin? Ya. Izinkan mcp__lagune__lagune_read dan mcp__lagune__lagune_write di pengaturan Qwen Code, ditambah Shell(npx --yes lagune@*) saat engine berjalan melalui npx. --- # Cara menginstal Lagune di agen mana pun dengan skills.sh atau GitHub CLI > Instal Lagune di agen AI mana pun dengan skills CLI atau GitHub CLI, dan jaga agar tetap terbaru. Kanonis: https://lagune.ai/id-ID/docs/install/universal Bahasa: id-ID Asli: https://lagune.ai/docs/install/universal Terakhir diperbarui: 2026-11-07 **skills.sh** Instal perintah **Lagune** di proyek Anda dari terminal dengan [**skills.sh**](https://www.skills.sh/wellwelwel/lagune), dan biarkan cakupan instalasinya tetap **Project**: ```bash npx skills add wellwelwel/lagune --skill '*' ``` Atau tempel prompt ini ke agen Anda: ```md Jalankan `npx --yes skills add wellwelwel/lagune` dan ikuti sekarang juga instruksi skill yang dihasilkannya. Baca seluruh output-nya, alihkan dulu ke file sementara jika perlu. Tentukan path relatif berdasarkan direktori file pendukung yang diberikannya. ``` **GitHub CLI** Instal perintah **Lagune** di proyek Anda dari terminal dengan [**GitHub CLI**](https://cli.github.com/) 2.90.0 atau yang lebih baru: ```bash gh skill install wellwelwel/lagune --all --scope project ``` Atau tempel prompt ini ke agen Anda: ```md Jalankan `gh skill install wellwelwel/lagune --all --scope project` dan baca seluruh output-nya, alihkan dulu ke file sementara jika perlu. ``` ## Pembaruan **skills.sh** Untuk memperbarui **Lagune**, jalankan: ```bash npx skills update ``` Atau tempel prompt ini ke agen Anda: ```md Jalankan `npx --yes skills update -y` dan baca seluruh output-nya, alihkan dulu ke file sementara jika perlu. ``` **GitHub CLI** Untuk memperbarui **Lagune**, jalankan: ```bash gh skill update --all ``` Atau tempel prompt ini ke agen Anda: ```md Jalankan `gh skill update --all` dan baca seluruh output-nya, alihkan dulu ke file sementara jika perlu. ``` --- **Sandbox** Di sandbox tanpa akses jaringan, perintah tidak bisa mengunduh engine. Instal engine di proyek Anda dari terminal Anda sendiri, sekali di awal dan lagi setelah setiap pembaruan: ```bash npm i -D lagune@0.18.1 ``` ## Pertanyaan yang sering diajukan ### Bagaimana cara menginstal Lagune di agen AI mana pun? Jalankan npx skills add wellwelwel/lagune --skill '*' atau gh skill install wellwelwel/lagune --all --scope project di proyek Anda, atau tempel prompt instalasi ke agen Anda. ### Bagaimana cara memperbarui Lagune di agen AI mana pun? Jalankan npx skills update jika Anda menginstalnya dengan skills.sh, atau gh skill update --all jika Anda menginstalnya dengan GitHub CLI. Anda juga bisa menempelkan prompt pembaruan ke agen Anda. ### Apakah saya bisa menginstal Lagune melalui lebih dari satu jalur? Tidak. Jika Anda menginstalnya melalui dua jalur, agen menampilkan setiap perintah dua kali, atau memakai satu salinan dan menyembunyikan yang lain. --- # Skill keamanan untuk agen AI > Skill yang didapat agen AI Anda dengan Lagune: audit proyek yang sudah ada atau amankan pekerjaan baru selagi Anda membangunnya, semuanya diatur oleh charter. Kanonis: https://lagune.ai/id-ID/docs/get-started/commands Bahasa: id-ID Asli: https://lagune.ai/docs/get-started/commands Terakhir diperbarui: 2026-11-06 Setelah **Lagune** [terinstal](https://lagune.ai/id-ID/docs), agen **AI** Anda mendapatkan sejumlah skill. Ada dua cara memakainya, dan keduanya diatur oleh **charter**: mengamankan pekerjaan baru selagi Anda membangunnya, atau menjalankan audit penuh pada sebuah proyek. **⌨️ Membangun / pengembangan** Anda tidak perlu menyelesaikan pekerjaan sebelum mengamankannya. Gunakan [**`/lagune`**](https://lagune.ai/id-ID/docs/commands/lagune) untuk pekerjaan yang sedang Anda tulis **saat ini**: | Skill | Apa yang dilakukannya untuk Anda | | --------------------------------------------- | --------------------------------------------------------------------------------------------- | | [**/lagune-charter**](https://lagune.ai/id-ID/docs/commands/charter) | Menetapkan aturan keamanan proyek Anda, fondasi yang menjadi acuan `/lagune` saat membangun | | [**/lagune**](https://lagune.ai/id-ID/docs/commands/lagune) | Membangun apa yang Anda minta dan memperkuat keamanannya selagi ditulis, dipandu oleh charter | **Gunakan kapan saja** [**`/lagune`**](https://lagune.ai/id-ID/docs/commands/lagune) mematuhi aturan charter Anda setiap kali dijalankan. Perintah ini menerima prompt apa pun, membangun apa yang Anda minta, dan memperkuatnya dengan default yang aman sambil jalan, bukan belakangan. --- #### Skill khusus | Skill | Fungsinya | | --------------------------------------------------- | ---------------------------------------------------------------------------------- | | [**/lagune-specialize**](https://lagune.ai/id-ID/docs/commands/specialize) | Mengajari **Lagune** spesialisasi keamanan baru dari artikel, eksploit, atau topik | **🔬 Audit: alur Blue Team** **Alur Blue Team** lengkap: membaca apa yang dilakukan sebuah proyek, memetakan risikonya, lalu menutupnya. Setiap skill dibangun di atas skill sebelumnya, jadi Anda cukup mengikuti daftar ini dari atas ke bawah: | # | Skill | Apa yang dilakukannya untuk Anda | | --- | --------------------------------------------- | -------------------------------------------------------------------------------------------- | | 1 | [**/lagune-charter**](https://lagune.ai/id-ID/docs/commands/charter) | Menetapkan aturan keamanan proyek Anda, diusulkan untuk Anda atau dibentuk dari arahan Anda | | 2 | [**/lagune-detect**](https://lagune.ai/id-ID/docs/commands/detect) | Membaca kode Anda dan memetakan apa yang dilakukan sistem Anda serta di mana risikonya | | 3 | [**/lagune-plan**](https://lagune.ai/id-ID/docs/commands/plan) | Mengubah temuan detect menjadi rencana pertahanan, dengan satu perbaikan untuk setiap temuan | | 4 | [**/lagune-harden**](https://lagune.ai/id-ID/docs/commands/harden) | Menerapkan perbaikan dari rencana ke kode Anda, dengan aman dan satu per satu | | 5 | [**/lagune-verify**](https://lagune.ai/id-ID/docs/commands/verify) | Membuktikan setiap perbaikan yang diterapkan tetap efektif, lalu menuntaskan yang terbukti | --- #### Skill khusus | Skill | Fungsinya | | --------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | | [**/lagune-specialize**](https://lagune.ai/id-ID/docs/commands/specialize) | Mengajari **Lagune** spesialisasi keamanan baru dari artikel, eksploit, atau topik | | [**/lagune-prove**](https://lagune.ai/id-ID/docs/commands/prove) | Mengubah setiap temuan yang terdeteksi menjadi pembuktian yang bisa dijalankan dan khusus pertahanan, untuk pengungkapan yang bertanggung jawab | --- #### Skill internal | Skill | Fungsinya | | ------------------------------------------- | ----------------------------------------- | | [**/lagune-repair**](https://lagune.ai/id-ID/docs/commands/repair) | Memperbaiki pelacakan internal **Lagune** | **Tips** Keamanan bukan biaya, melainkan investasi: apa yang Anda tanamkan di awal akan Anda hemat berkali-kali lipat dari insiden yang tidak pernah terjadi 🙋🏻‍♂️ ## Pertanyaan yang sering diajukan ### Skill apa saja yang ditambahkan Lagune? Perintah /lagune untuk memperkuat keamanan pekerjaan selagi Anda membangunnya, dan alur audit Blue Team lima fase: /lagune-charter, /lagune-detect, /lagune-plan, /lagune-harden, /lagune-verify. Ada juga /lagune-specialize dan /lagune-prove. ### Apa itu alur Blue Team Lagune? Audit lima fase: charter (menetapkan aturan), detect (memetakan risiko), plan (memberi skor dan merencanakan perbaikan), harden (menerapkan perbaikan), verify (membuktikan perbaikan tetap efektif lalu menuntaskannya). ### Apa bedanya /lagune dengan alur audit? Perintah /lagune mengamankan pekerjaan baru selagi Anda menulisnya, tanpa alur yang harus diikuti. Alur audit menjalankan kelima fase secara berurutan pada proyek yang sudah ada. --- # Dasbor > Lihat charter, temuan, dan katalog proyek Anda dalam tampilan langsung dan lokal yang terbuka dengan satu perintah. Kanonis: https://lagune.ai/id-ID/docs/get-started/dashboard Bahasa: id-ID Asli: https://lagune.ai/docs/get-started/dashboard Terakhir diperbarui: 2026-11-06 Jalankan **Lagune** begitu saja, tanpa subperintah, untuk mendapatkan tampilan langsung yang interaktif dari `.lagune/`. **Lagune** menyajikan dasbor dan membukanya di port acak: ```bash npx lagune ``` - [x] **Live reload** - [x] **Privat** dan **lokal** - [x] Menampilkan apa pun isi `.lagune/`, sejak charter pertama - [x] **Kelola** kategori proyek dan apa yang dipindai hook-nya, langsung dari browser Anda - [x] Tidak perlu `node_modules` maupun `package.json` 📦 ![Charter di dasbor Lagune](https://lagune.ai/img/dashboard/02.webp) ![Temuan di dasbor Lagune](https://lagune.ai/img/dashboard/03.webp) ![Side quest di dasbor Lagune](https://lagune.ai/img/dashboard/04.webp) ![Detail temuan di dasbor Lagune](https://lagune.ai/img/dashboard/05.webp) ![Katalog di dasbor Lagune](https://lagune.ai/img/dashboard/06.webp) **Tips** - 🚪 Gunakan `--port` untuk menentukan port kustom. - ⏏️ Tekan `Ctrl+C` untuk menghentikannya. ## Pertanyaan yang sering diajukan ### Bagaimana cara membuka dasbor Lagune? Jalankan npx lagune tanpa subperintah di root proyek Anda. Perintah ini menyajikan tampilan langsung dari .lagune/ di port acak dan membukanya di browser Anda. ### Apakah dasbornya privat? Ya. Dasbor hanya berjalan di komputer Anda sendiri, di alamat lokal yang tidak bisa dijangkau komputer lain. ### Apakah saya bisa mengubah proyek dari dasbor? Hanya kategorinya dan apa yang dikecualikan oleh hook-nya, dari browser Anda. Selain itu, semua yang ditampilkan dasbor hanya bisa dibaca. --- # /lagune: kode aman sejak AI Anda menulisnya > Bangun apa yang Anda minta dan perkuat keamanannya saat kode ditulis, dipandu oleh charter, tanpa alur yang harus diikuti. Kanonis: https://lagune.ai/id-ID/docs/commands/lagune Bahasa: id-ID Asli: https://lagune.ai/docs/commands/lagune Terakhir diperbarui: 2026-11-06 ⌨️ Kerjakan apa yang Anda minta, dengan keamanan yang dibangun saat kodenya ditulis. **`/lagune`** menerima prompt apa pun di tahap mana pun, membangun apa yang Anda inginkan, dan memperkuat keamanannya dengan default yang aman sebelum menyerahkannya kembali. ## Cara menggunakan Tambahkan **`/lagune`** ke prompt apa pun, lalu jelaskan pekerjaannya seperti biasa. **📘 Instruksi agen** ```md # Instruksi proyekku untuk agen ## Keamanan - Gunakan skill `/lagune` setiap kali kamu membangun atau mengubah kode, agar keamanannya meningkat secara bawaan. ``` - Contohnya: **AGENTS.md**, **CLAUDE.md**, **.github/copilot-instructions.md**, **.cursorrules**, dan sebagainya. **💬 Fitur** ```prompt /lagune izinkan pengguna mengunggah foto kustom di profil mereka. ``` **💬 Perbaikan** ```prompt /lagune tidak terjadi apa-apa saat pengguna mengirim formulir. Cari tahu penyebabnya dan perbaiki. ``` **💬 Refaktor** ```prompt /lagune pisahkan dan perbaiki logika payload ``` **Charter opsional, tetapi lebih baik dengan charter** **`/lagune`** berjalan dengan atau tanpa charter. Dengan charter, aturan proyek Anda sendiri membentuk setiap hasil pembangunan. Tetapkan sekali saja dengan [`/lagune-charter`](https://lagune.ai/id-ID/docs/commands/charter). ## Cara kerjanya Perintah ini membungkus pekerjaan dalam tiga langkah, tanpa menulis apa pun ke Lagune: 1. Memuat charter Anda, jika ada, dan prinsip-prinsipnya mengarahkan seluruh pembangunan. Jika Anda belum punya charter, perintah ini memakai standar dasar yang aman secara bawaan. 2. Menampilkan [katalog](https://lagune.ai/id-ID/docs/catalog) proyek Anda dan hanya memuat spesialisasi yang tersentuh oleh pekerjaan Anda, pengetahuan yang sama, dimuat hanya saat dibutuhkan, yang dipakai alur audit. 3. Menerapkan pertahanan saat kode ditulis, lalu membaca ulang hasilnya sendiri untuk memastikan kontrol keamanannya benar-benar bertahan sebelum menyerahkan pekerjaan kembali. Hasilnya adalah kode yang berfungsi di proyek Anda, aman sejak baris pertama. **Gunakan kapan saja** Tanpa detect, tanpa plan, tanpa beres-beres setelahnya. **`/lagune`** sama cocoknya untuk scaffold baru maupun perubahan di basis kode yang sudah matang, dan memperkuat keamanan pekerjaan sambil berjalan, bukan belakangan. ## Yang tidak dilakukannya - Tidak menulis apa pun ke direktori `.lagune`, baik artefak maupun pelacakan, jadi satu-satunya yang dihasilkannya adalah kode dengan keamanan yang diperkuat sesuai permintaan Anda. - Tidak melemahkan aturan demi memenuhi prompt, jadi jika permintaan Anda akan melanggar prinsip charter, perintah ini berhenti dan memberi tahu Anda terlebih dahulu, alih-alih langsung membangunnya dengan cara yang tidak aman. ## Pertanyaan yang sering diajukan ### Apa fungsi /lagune? Perintah ini menerima prompt apa pun di tahap mana pun, membangun apa yang Anda minta, dan memperkuat keamanannya dengan default yang aman sebelum menyerahkannya kembali. Pertahanan diterapkan saat kode ditulis, bukan belakangan. ### Apakah saya perlu charter untuk menggunakan /lagune? Tidak. Perintah ini berjalan dengan atau tanpa charter. Dengan charter, aturan proyek Anda sendiri membentuk setiap hasil pembangunan. Tanpa charter, perintah ini memakai standar dasar yang aman secara bawaan. ### Apa bedanya /lagune dengan alur Blue Team? /lagune mengamankan pekerjaan baru saat Anda menulisnya, tanpa alur yang harus diikuti. Alur Blue Team menjalankan lima fase audit secara berurutan pada proyek yang sudah ada. ### Apakah /lagune melacak temuan atau menulis artefak? Tidak. Perintah ini tidak menulis apa pun ke direktori .lagune, baik artefak maupun pelacakan. Satu-satunya yang dihasilkannya adalah kode dengan keamanan yang diperkuat sesuai permintaan Anda. ### Bagaimana agar agen saya menggunakan /lagune secara otomatis? Tambahkan instruksi ke file instruksi agen Anda (AGENTS.md, CLAUDE.md, .cursorrules, dan sejenisnya) agar agen menggunakan skill /lagune setiap kali membangun atau mengubah kode. --- # /lagune-charter: tetapkan prinsip keamanan Anda > Tetapkan prinsip keamanan proyek Anda, aturan yang dipatuhi semua fase berikutnya, dan catat kategori spesialisasi yang didukung oleh hasil pembacaan proyek. Kanonis: https://lagune.ai/id-ID/docs/commands/charter Bahasa: id-ID Asli: https://lagune.ai/docs/commands/charter Terakhir diperbarui: 2026-11-06 🧬 Ceritakan kepada **Lagune** proyek Anda itu apa, lalu **Lagune** mengubahnya menjadi aturan keamanan Anda (atau, tanpa deskripsi, menyusunnya hanya dari proyek itu sendiri). Charter adalah lapisan yang mengarahkan semua fase: sekumpulan prinsip yang mengutamakan keamanan dan wajib dipatuhi setiap fase berikutnya. Anggap saja sebagai pemeriksaan saat kompilasi untuk postur keamanan proyek Anda. ## Cara menggunakan **Deskripsikan proyek** ```prompt /lagune-charter Proyekku adalah toko online yang menjual video game. Pelanggan menambahkan produk ke keranjang dan membayar dengan kartu kredit atau transfer bank. Mereka bisa melihat pesanan mereka dan status setiap pesanan. ``` **Biarkan Lagune mengusulkan** ```prompt /lagune-charter ``` > _Saya melihat pustaka pembayaran, pengaturan login, dan model pesanan yang terhubung ke pelanggan. Ini tampaknya toko online yang menjual sesuatu. Pelanggan membayar dan memantau pesanan mereka sendiri..._ ☁️ ## Apa yang disimpulkannya **Lagune** menjadikan deskripsi atau **PRD** Anda sebagai arah, menyimpulkan dampaknya bagi keamanan, lalu membaca proyek untuk melangkah lebih jauh dari yang Anda sebutkan. Contohnya: - Keranjang yang menyimpan pesanan berarti ada **basis data**: - misalnya, `"Di mana data disimpan?"`, `"Siapa yang bisa mengaksesnya?"`, `"Apakah datanya bocor?"`. - Pelanggan yang bisa melihat pesanan mereka sendiri berarti ada semacam **login atau kontrol akses**: - misalnya, `"Bisakah seorang pelanggan mengakses pesanan pelanggan lain?"`, `"Apakah sesi terlindungi?"`. - Menerima pembayaran dengan kartu dan transfer bank berarti **ada uang dan data sensitif yang terlibat**: - misalnya, `"Apakah data kartu disimpan?"`, `"Apakah pembayaran diverifikasi?"`. Deskripsi Anda dan proyek saling melengkapi: deskripsi menetapkan tujuan, sementara pembacaan dependensi, README, dan konfigurasi mengungkap hal yang tidak Anda sebutkan. Jika ada hal penting yang masih belum jelas, **Lagune** mengajukan pertanyaan singkat dan sederhana alih-alih menebak. Dari situ, **Lagune** menyusun aturan keamanan yang disesuaikan dengan proyek, yang bisa Anda tinjau dan ubah kapan pun diperlukan. **Manfaatkan sepenuhnya** - Anda juga bisa menetapkan aturan keamanan sendiri untuk proyek. - Makin banyak detail relevan yang Anda berikan, makin baik laporan akhirnya: - Jelaskan proyeknya, cara kerjanya, dan apa yang terjadi di baliknya. - Siapa pengguna akhirnya? Apa yang boleh dilakukan pengguna, dan apa yang tidak? - Detail perilaku sama berharganya dengan detail teknis. - Memori charter ada di `.lagune/memory/charter.md`. ## Kategori yang dicatatnya Spesialisasi, yaitu pengetahuan keamanan yang dimuat fase berikutnya hanya saat dibutuhkan, masuk ke [katalog](https://lagune.ai/id-ID/docs/catalog) proyek Anda per [kategori](https://lagune.ai/id-ID/docs/categories). Selama proyek Anda belum mencatat kategori apa pun, charter mencatat setiap kategori yang didukung oleh hasil pembacaannya, seperti bahasa pemrograman proyek, pemanggilan LLM, atau container, lalu menyebutkannya dalam ringkasan. Setelah kategori tercatat, charter membiarkannya apa adanya dan hanya menyebutkan kategori yang belum digunakan proyek Anda. Anda bisa mengubahnya sendiri kapan saja: ```bash npx lagune write add --categories python npx lagune write remove --categories python ``` ## Folder yang ditawarkannya untuk dikecualikan Saat pembacaan charter menemukan folder yang di-commit tetapi bukan kode proyek Anda yang perlu dilindungi, seperti fixture tes yang sengaja ditulis agar tampak rentan, charter mencantumkannya dengan nomor di akhir ringkasannya. Charter tidak pernah mengecualikan folder atas inisiatif sendiri, karena repositori yang berniat jahat bisa membuat kodenya tampak seperti fixture, jadi hanya nomor yang Anda sebutkan dalam balasan yang dicatat. [Konfigurasi hook](https://lagune.ai/id-ID/docs/hooks/configure) menjelaskan cara mengubahnya sendiri. ## Selanjutnya Setelah aturan ditetapkan, petakan apa yang benar-benar dilakukan sistem Anda: [`/lagune-detect`](https://lagune.ai/id-ID/docs/commands/detect). ## Pertanyaan yang sering diajukan ### Apa itu charter di Lagune? Charter adalah lapisan Lagune yang mengarahkan semua fase, sekumpulan prinsip yang mengutamakan keamanan dan wajib dipatuhi setiap fase berikutnya. Anggap saja sebagai pemeriksaan saat kompilasi untuk postur keamanan proyek Anda. ### Di mana charter disimpan? Di .lagune/memory/charter.md. ### Apakah saya bisa menulis aturan charter sendiri? Bisa. Lagune mengusulkan aturan dari deskripsi dan kode Anda, dan Anda bisa mengubah kata-katanya, menghapusnya, menambahkannya, atau mempersempit cakupannya. ### Apakah charter memilihkan kategori spesialisasi untuk saya? Hanya selama belum ada kategori yang tercatat. Charter kemudian mencatat setiap kategori yang didukung oleh hasil pembacaannya, seperti bahasa pemrograman Anda atau pemanggilan LLM. Setelah kategori tercatat, charter tidak pernah mengubahnya. --- # /lagune-detect: petakan sistem Anda dan risikonya > Baca kode Anda lalu petakan apa yang dilakukan sistem Anda dan di mana letak risikonya. Kanonis: https://lagune.ai/id-ID/docs/commands/detect Bahasa: id-ID Asli: https://lagune.ai/docs/commands/detect Terakhir diperbarui: 2026-11-06 🔬 Ketahui apa yang sebenarnya dilakukan sistem Anda dan di mana letak risikonya. Detect membaca kode dan hanya mencatat apa yang benar-benar ditemukannya, beserta bukti yang dibutuhkan fase berikutnya. Prinsip utamanya adalah mendeteksi, bukan mengarang. ## Cara menggunakan **Pemindaian penuh** ```prompt /lagune-detect ``` **Tunjuk path** ```prompt /lagune-detect src/routes/ src/auth.ts ``` **Jelaskan kekhawatiran** ```prompt /lagune-detect pastikan data pelanggan tidak pernah terekspos ``` ## Apa yang dipetakannya **Lagune** membaca kode dan memetakan apa yang ditemukannya. Setiap temuan memuat apa temuan itu, mengapa penting, dan buktinya. Contohnya: - **Unggahan file**, sistem menerima file dari pengguna: - _Mengapa penting:_ file yang menyamar sebagai gambar bisa menyembunyikan kode berbahaya. - _Bukti:_ handler `POST /upload` memercayai MIME type yang dikirim klien, tanpa memeriksa jenis asli file tersebut. - **Login dan sesi**, pengguna masuk untuk mengakses akun mereka: - _Mengapa penting:_ penanganan sesi yang lemah memungkinkan sebuah akun diambil alih oleh akun lain. - _Bukti:_ logika penerbitan sesi, tempat sesi diterbitkan tanpa batas waktu kedaluwarsa. Sambil berjalan, detect memberi putusan terhadap kode untuk setiap spesialisasi di [katalog](https://lagune.ai/id-ID/docs/catalog) proyek Anda, menerapkan spesialisasi yang konteksnya ada, lalu mencatatnya di bawah **Applied specializations**, daftar yang dipakai ulang oleh harden dan verify. Dari situ, Anda memiliki peta yang jelas tentang apa yang dilakukan sistem Anda dan di mana letak risikonya, siap ditindaklanjuti di langkah berikutnya. **Tips** - Menjalankannya lagi akan memperbarui peta: temuan yang sudah selesai hilang, temuan baru masuk. - Peta detect ada di `.lagune/memory/detect.md`. ## Selanjutnya Ubah peta menjadi rencana: [`/lagune-plan`](https://lagune.ai/id-ID/docs/commands/plan). ## Pertanyaan yang sering diajukan ### Apa fungsi /lagune-detect? Perintah ini membaca kode Anda dan memetakan apa yang dilakukan sistem Anda dan di mana letak risikonya, dengan hanya mencatat apa yang benar-benar ditemukannya. Prinsipnya adalah mendeteksi, bukan mengarang. ### Apa itu temuan di Lagune? Temuan adalah satu risiko yang terdeteksi, yang memuat apa risiko itu, mengapa penting, dan buktinya di kode. Temuan adalah unit yang dilacak dan dibawa terus oleh plan, harden, dan verify. ### Di mana peta detect disimpan? Di .lagune/memory/detect.md. ### Spesialisasi mana yang digunakan detect? Setiap spesialisasi di katalog proyek Anda mendapat putusan terhadap kode. Detect menerapkan spesialisasi yang konteksnya ada dan mencatatnya di bawah Applied specializations. --- # /lagune-plan: beri skor temuan dan rencanakan perbaikan > Ubah hasil temuan detect menjadi rencana pertahanan, dengan memberi setiap temuan kategori dan skor CVSS v4.0, lalu memasangkannya dengan perbaikan. Kanonis: https://lagune.ai/id-ID/docs/commands/plan Bahasa: id-ID Asli: https://lagune.ai/docs/commands/plan Terakhir diperbarui: 2026-11-06 🛡️ Ubah hasil temuan detect menjadi rencana pertahanan: beri setiap temuan kategori dan skor CVSS v4.0, lalu pasangkan dengan perbaikan yang perlu diterapkan. ## Cara menggunakan **Rencanakan semuanya** ```prompt /lagune-plan ``` **Tunjuk path** ```prompt /lagune-plan src/routes/upload.ts ``` **Fokus pada kekhawatiran** ```prompt /lagune-plan di mana data sensitif bisa bocor ``` ## Cara kerjanya Fase ini melanjutkan dari detect. Detect sudah menemukan apa yang dilakukan sistem Anda dan risiko yang dibawa setiap bagiannya, jadi plan tidak mengulang risikonya, melainkan menilai seberapa serius risiko itu dan memutuskan tindakannya. Plan tidak pernah membaca kode, sehingga setiap perbaikan harus menunjuk ke sesuatu yang benar-benar terdeteksi oleh detect. Plan memberi skor setiap temuan dengan metode CVSS v4.0: sebuah kategori, sebuah vektor CVSS v4.0 yang disimpulkan dari apa yang dicatat detect dan charter lalu dihitung skornya oleh [hook `cvss`](https://lagune.ai/id-ID/docs/hooks/cvss), dan rentang prioritas tempat skor itu jatuh. Setiap perbaikan juga mencantumkan prinsip charter yang ditegakkannya. Contohnya: - **Unggahan file** (Prioritas: **Kritis**) - _Kategori:_ Unggahan file tanpa batasan (CWE-434). - _CVSS:_ CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N (9.3, kritis). - _Alasan prioritas ini:_ siapa pun bisa mengakses unggahan lewat internet, dan unggahan itu berada di server yang menyimpan file pelanggan. - _Menegakkan:_ III. Semua input tidak tepercaya sampai divalidasi. - _Perbaikan:_ periksa jenis asli dan ukuran file, ganti namanya saat disimpan, dan simpan unggahan di tempat yang tidak bisa dijalankan sebagai kode. Dari situ, Anda memiliki daftar perbaikan yang sudah diberi skor dan diprioritaskan, masing-masing terhubung ke satu temuan dan siap diterapkan di fase berikutnya. Skornya dihitung, tidak pernah ditaksir: vektornya membawa tingkat keterpaparan proyek dan apa yang dipertaruhkan sebagai metrik Environmental, dan siapa pun bisa menempelkannya ke kalkulator FIRST atau NVD dan mendapatkan skor yang sama. **Tips** - Plan sepenuhnya bertumpu pada detect. Jika sebuah file atau kekhawatiran belum pernah dipetakan, plan meminta Anda menjalankan `/lagune-detect` untuk itu terlebih dahulu. - Menjalankannya lagi akan memperbarui rencana: perbaikan yang sudah selesai hilang, perbaikan baru masuk. - Rencana pertahanan ada di `.lagune/memory/plan.md`. **Bergantung pada detect** Plan hanya bekerja dari apa yang sudah dipetakan oleh [`/lagune-detect`](https://lagune.ai/id-ID/docs/commands/detect), jadi jalankan detect terlebih dahulu. ## Selanjutnya Terapkan rencananya: [`/lagune-harden`](https://lagune.ai/id-ID/docs/commands/harden). ## Pertanyaan yang sering diajukan ### Bagaimana Lagune memprioritaskan kerentanan? /lagune-plan memberi setiap temuan kategori dan skor CVSS v4.0 yang dihitung oleh hook cvss, lalu memasangkannya dengan perbaikan yang perlu diterapkan. ### Apakah Lagune menggunakan CVSS v4.0? Ya. Setiap temuan mendapat vektor dan skor CVSS v4.0, yang dihitung oleh hook cvss dengan aritmetika yang sama seperti kalkulator FIRST, sehingga siapa pun bisa menempelkan vektornya di sana dan mendapatkan skor yang sama. ### Apakah plan membaca kode saya? Tidak. Plan tidak pernah membaca kode, sehingga setiap perbaikan harus menunjuk ke sesuatu yang benar-benar terdeteksi oleh detect. --- # /lagune-harden: terapkan perbaikan keamanan ke kode Anda > Terapkan perbaikan dari rencana ke kode Anda, dengan aman dan satu per satu. Kanonis: https://lagune.ai/id-ID/docs/commands/harden Bahasa: id-ID Asli: https://lagune.ai/docs/commands/harden Terakhir diperbarui: 2026-11-06 🔧 Terapkan perbaikan dari rencana ke kode Anda, dengan aman dan satu per satu. ## Cara menggunakan **Terapkan semuanya** ```prompt /lagune-harden ``` **Tunjuk path** ```prompt /lagune-harden src/routes/upload.ts ``` **Berdasarkan prioritas** ```prompt /lagune-harden hanya yang prioritasnya kritis dan tinggi ``` ## Cara kerjanya Plan sudah menentukan setiap perbaikan, jadi harden tinggal menerapkannya. Karena ini satu-satunya fase yang menyentuh kode Anda, harden bekerja dengan hati-hati: menerapkan satu perbaikan dalam satu waktu agar setiap perubahan tetap mudah ditinjau, dan tidak pernah melemahkan kontrol keamanan demi menyesuaikan perbaikan. Contohnya, perbaikan untuk unggahan: - **Unggahan file** (Status: **Applied**) - _Apa yang berubah:_ memeriksa jenis asli dan ukuran file, menolak apa pun yang tidak terduga, mengganti namanya saat disimpan, dan menyimpannya di tempat yang tidak bisa dijalankan sebagai kode. - _Di mana:_ fungsi `handleUpload`, ditambah helper penyimpanan yang dipanggilnya. Jika sebuah perbaikan tidak bisa diterapkan sepenuhnya, harden mengerjakan apa yang bisa dilakukan dengan aman dan menandai sisanya **Partial** atau **Blocked**, sehingga tetap terbuka. **Diterapkan belum berarti terverifikasi** Applied belum berarti terbukti. Itulah gunanya [verify](https://lagune.ai/id-ID/docs/commands/verify). **Tips** - Harden sepenuhnya bertumpu pada rencana. Jika sebuah perbaikan atau file belum pernah direncanakan, harden meminta Anda menjalankan `/lagune-plan` untuk itu terlebih dahulu. - Menjalankannya lagi akan menyelaraskan catatan dengan kondisi terkini: perubahan yang dibatalkan hilang, perbaikan yang baru diterapkan masuk. - Catatan hardening ada di `.lagune/memory/harden.md`. **Bergantung pada plan, dan mengubah kode Anda** Harden bertumpu pada [`/lagune-plan`](https://lagune.ai/id-ID/docs/commands/plan). Ini satu-satunya fase yang mengubah kode Anda. ## Selanjutnya Buktikan bahwa setiap perbaikan tetap efektif: [`/lagune-verify`](https://lagune.ai/id-ID/docs/commands/verify). ## Pertanyaan yang sering diajukan ### Apakah /lagune-harden mengubah kode saya? Ya. Ini satu-satunya fase yang menyentuh kode Anda, dengan menerapkan perbaikan dari rencana satu per satu. ### Apa arti Applied, Partial, dan Blocked? Ketiganya adalah status yang dicatat Lagune untuk setiap perbaikan. Applied berarti perbaikan sudah dibuat, Partial berarti baru sebagian, dan Blocked berarti perbaikan tidak bisa diterapkan. Applied belum berarti terbukti. ### Apakah Lagune menerapkan perbaikan tanpa bertanya? Perlu atau tidaknya persetujuan Anda untuk sebuah perubahan ditentukan oleh agen Anda dan mode izin yang Anda gunakan, bukan oleh Lagune, yang tidak menambahkan langkah konfirmasi sendiri. Meski begitu, Lagune tidak pernah melemahkan kontrol keamanan demi memenuhi perbaikan, dan jika sebuah perbaikan bertentangan dengan aturan charter, Lagune berhenti dan memberi tahu Anda terlebih dahulu. --- # /lagune-verify: buktikan kontrol keamanan tetap efektif > Buktikan bahwa setiap perbaikan yang diterapkan tetap efektif, lalu tuntaskan perbaikan yang lolos. Kanonis: https://lagune.ai/id-ID/docs/commands/verify Bahasa: id-ID Asli: https://lagune.ai/docs/commands/verify Terakhir diperbarui: 2026-11-06 ⚖️ Buktikan bahwa setiap perbaikan yang diterapkan tetap efektif, dengan membaca kode dan mencocokkannya dengan apa yang dicatat harden, lalu tuntaskan perbaikan yang lolos. ## Cara menggunakan **Verifikasi semuanya** ```prompt /lagune-verify ``` **Tunjuk path** ```prompt /lagune-verify src/routes/upload.ts ``` **Berdasarkan prioritas** ```prompt /lagune-verify hanya yang prioritasnya kritis dan tinggi ``` ## Cara kerjanya Verify membaca kode di setiap titik yang dicatat harden dan memastikan kode itu benar-benar sesuai dengan klaimnya. Pembuktiannya adalah pencocokan itu, kode dibandingkan dengan catatan. Setiap kontrol mendapat salah satu dari tiga putusan: | Putusan | Arti | | ---------------------------- | ----------------------------------------------------------------- | | ✅ Risk closed | Kode melakukan persis seperti yang diklaim catatan. | | ❌ Risk not closed | Kontrol masih terbuka. Verify mengarahkan Anda kembali ke harden. | | ❓ Cannot tell from the code | Buktinya tidak terlihat dari kode saja. | Risiko yang terbukti tuntas kemudian ditutup dari seluruh rantai, dengan konfirmasi Anda. Contohnya: - **Unggahan file** (Putusan: **✅ Risk closed**) - _Cara pembuktian:_ membaca handler unggahan dan melihat bahwa handler itu mendeteksi jenis asli file dari isinya, menerapkan batas ukuran, dan menolak selain itu, persis seperti yang diklaim catatan. - _Bukti:_ fungsi `handleUpload`, yang mendeteksi jenis asli file dari isinya. Jika risikonya belum tertutup, verify menyatakannya dengan jelas dan mengarahkan Anda kembali ke [`/lagune-harden`](https://lagune.ai/id-ID/docs/commands/harden), karena perbaikannya masih terbuka. **Tips** - Verify sepenuhnya bertumpu pada catatan hardening. - Verify hanya membaca kode Anda untuk menilainya, dan tidak pernah melemahkan kontrol keamanan atau menulis ulang kode agar sebuah putusan lolos. - Menjalankannya lagi akan menyelaraskan putusan dengan kondisi terkini: putusan yang usang hilang, dan risiko yang tidak lagi tertutup ditandai kembali. - Saat sebuah risiko terbukti tertutup, verify bertanya sekali, lalu menghapus temuan itu dari seluruh rantai (detect, plan, harden, dan pelacakan). - Verify tidak menulis laporan sendiri: setiap putusan berada di blok kontrolnya di `.lagune/memory/harden.md`, tempat harden membacanya pada run berikutnya. **Bergantung pada harden** Verify bertumpu pada [`/lagune-harden`](https://lagune.ai/id-ID/docs/commands/harden). ## Siklus pun tuntas Saat semua yang ada dalam cakupan sudah ditutup, siklus pun tuntas. Siklus hanya terbuka kembali saat kode berubah. Keamanan bisa dituntaskan, jadi alurnya punya titik akhir, bukan putaran tanpa ujung. ## Pertanyaan yang sering diajukan ### Bagaimana Lagune memverifikasi sebuah perbaikan? /lagune-verify membaca kode dan mencocokkannya dengan apa yang dicatat harden, lalu memberikan salah satu dari tiga putusan: Risk closed (risiko tertutup), Risk not closed (risiko belum tertutup), atau Cannot tell from the code (tidak bisa dipastikan dari kode). ### Apa artinya menutup sebuah temuan? Saat verify membuktikan sebuah risiko tertutup, temuannya ditutup: dihapus dari seluruh rantai, dengan konfirmasi Anda, sehingga tidak diproses ulang. ### Apakah pekerjaan keamanan bisa benar-benar selesai? Bisa. SDH bisa dituntaskan: temuan yang terbukti tuntas akan ditutup, jadi alurnya punya titik akhir, bukan putaran tanpa ujung. --- # Kategori > Kategori spesialisasi yang bisa dipakai proyek Lagune, dari OWASP hingga hardening per bahasa untuk JavaScript, Python, Go, dan Rust, serta cara mengubahnya. Kanonis: https://lagune.ai/id-ID/docs/categories Bahasa: id-ID Asli: https://lagune.ai/docs/categories Terakhir diperbarui: 2026-11-06 **Lagune** mengelompokkan [**spesialisasi**](https://lagune.ai/id-ID/docs/catalog) bawaannya ke dalam **13 kategori**. Kategori yang dipakai sebuah proyek menentukan spesialisasi bawaan mana yang masuk ke [**katalog**](https://lagune.ai/id-ID/docs/catalog) proyek itu, dan kategori terbagi dua: apa yang dilakukan sistem, dan bahasa yang dipakai untuk menulisnya. Selama belum ada kategori yang dicatat, proyek hanya memakai `owasp`. Perintah [`/lagune-charter`](https://lagune.ai/id-ID/docs/commands/charter) mencatat setiap kategori yang didukung oleh hasil pembacaannya terhadap proyek, dan Anda bisa mengubahnya sendiri kapan saja. ## Apa yang dilakukan sistem | Kategori | Kunci | Yang diperkuat | | ------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | | OWASP | `owasp` | Risiko keamanan aplikasi yang dipantau OWASP: injection, kontrol akses yang rusak (Broken Access Control), serta kegagalan autentikasi dan kriptografi | | Infrastruktur | `infra` | Konfigurasi container, workload, dan serverless: Dockerfile, Compose, keamanan Pod, IAM dan trigger FaaS | | AI / LLM | `ai` | Integrasi AI dan LLM, terhadap prompt injection serta rangkaian tool, agen, retrieval, dan MCP yang tidak aman | | Lovable | `lovable` | Aplikasi Supabase buatan AI (Lovable dan sejenisnya): celah RLS, kunci `service_role` yang bocor, dan default yang tidak aman | ## Bahasa yang dipakai sistem | Kategori | Kunci | Yang diperkuat | | ---------- | ------------ | ---------------------------------------------------------------------------------------------------------------- | | JavaScript | `javascript` | RCE lewat `eval` dan `child_process`, path traversal, dan prototype pollution, di semua runtime-nya | | Python | `python` | RCE lewat deserialisasi `pickle` dan YAML, traversal string lewat `str.format`, dan class pollution | | Rust | `rust` | API `unsafe` yang tidak sound, penyalahgunaan `transmute`, integer overflow, dan undefined behavior di batas FFI | | C / C++ | `c-cpp` | Bug format string, buffer overflow, dan penulisan di luar batas yang membuka jalan eksekusi kode | | PHP | `php` | Bypass autentikasi lewat type juggling, gadget chain object injection, dan konfigurasi default yang tidak aman | | Go | `go` | Bug interface typed nil, data races antar-goroutine, dan konkurensi yang tidak aman di jalur keamanan | | Java | `java` | Gadget chain deserialisasi `ObjectInputStream` yang berujung pada eksekusi kode jarak jauh | | Ruby | `ruby` | Gadget chain deserialisasi `Marshal.load` dan YAML yang mencapai eksekusi kode jarak jauh | | .NET / C# | `dotnet` | RCE lewat deserialisasi `BinaryFormatter` dan bypass encoder yang berujung pada XSS | **Tips** **Lagune** tidak bergantung pada bahasa pemrograman: seluruh alurnya membaca proyek Anda apa pun bahasanya, dan kategori ini hanya menambah kedalaman pada jebakan yang khas untuk satu bahasa. ## Tambah dan hapus kapan saja Kategori adalah titik awal, bukan komitmen. Pakai yang cocok untuk proyek saat ini dan ubah kapan saja berdasarkan kuncinya, dengan `write add` dan `write remove`. Di terminal, `--categories` tanpa nilai membuka pemilih interaktif (spasi untuk memilih atau membatalkan pilihan, enter untuk konfirmasi, kosongkan untuk melewati). Di luar terminal, tulis kategorinya setelah opsi itu. **Tambah** ```bash npx lagune write add --categories # interactive npx lagune write add --categories owasp npx lagune write add --categories owasp rust ``` **Hapus** ```bash npx lagune write remove --categories # interactive npx lagune write remove --categories owasp npx lagune write remove --categories owasp rust ``` Perintah `write add` atau `write remove` yang pertama berangkat dari `owasp`, jadi menghapus semua kategori menghasilkan daftar kosong, bukan kembali ke default. Setiap perubahan tersimpan di `.lagune/configs.json`, sehingga seluruh tim bekerja dengan kumpulan yang sama. ## Lihat kategori yang dipakai proyek Perintah `read list --categories` menampilkan semua kategori dan apakah proyek memakainya: ```bash npx lagune read list --categories # Categories # • owasp [used] Harden against the application security risks OWASP tracks # • javascript [available] Harden JavaScript and its runtimes # • php [available] Harden PHP against type-juggling auth bypass # • go [available] Harden Go against typed-nil interface bugs # ... # # No category is recorded yet, so this project uses the default: owasp. ``` Lihat [**Katalog**](https://lagune.ai/id-ID/docs/catalog) untuk mengetahui spesialisasi apa saja yang dibawa setiap kategori. Spesialisasi milik Anda sendiri, yang ditulis dengan [`/lagune-specialize`](https://lagune.ai/id-ID/docs/commands/specialize), masuk ke katalog apa pun kategorinya. ## Pertanyaan yang sering diajukan ### Bagaimana cara menambahkan kategori? Berikan kunci kategori ke --categories, misalnya npx lagune write add --categories javascript. Selama belum ada kategori yang dicatat, fase charter juga mencatat kategori yang didukung oleh hasil pembacaannya terhadap proyek. ### Apakah saya bisa memakai lebih dari satu kategori? Ya. Tulis semuanya di baris yang sama, satu setelah yang lain. ### Kategori apa yang sebaiknya dipakai sebuah proyek? Mulai dengan owasp, kategori default, lalu tambahkan kategori untuk bahasa atau stack Anda. Spesialisasi hanya dimuat saat dibutuhkan, jadi sebuah kategori tidak membebani apa pun sampai ada fase yang membutuhkan salah satu spesialisasinya. --- # Katalog: spesialisasi keamanan yang dimuat saat dibutuhkan > Cara spesialisasi di katalog proyek Anda dimuat, oleh fase hanya saat dibutuhkan, atau langsung oleh Anda. Kanonis: https://lagune.ai/id-ID/docs/catalog Bahasa: id-ID Asli: https://lagune.ai/docs/catalog Terakhir diperbarui: 2026-11-06 🧠 Spesialisasi **Lagune** adalah modul pengetahuan keamanan yang terfokus dan tidak bergantung pada bahasa pemrograman, yang dimuat hanya saat dibutuhkan, tidak pernah secara default. Spesialisasi bukan perintah. Katalog proyek Anda adalah kumpulan spesialisasi yang dipakai proyek itu: spesialisasi bawaan dari [kategori](https://lagune.ai/id-ID/docs/categories) yang dipakainya, ditambah spesialisasi milik proyek sendiri. Fase detect dan verify memakainya saat berjalan, dan Anda bisa memuat salah satunya secara langsung kapan saja. **Ikhtisar** *Ringkasan katalog interaktif ada di halaman web. Semua spesialisasi bawaan ada di tabel di bawah ini.* **Cara kerjanya** ## Jalankan sendiri Untuk memakai spesialisasi secara langsung, minta agen Anda memuatnya dengan `read catalog ` dan tulis tugasnya di prompt yang sama. Pengetahuan itu lalu bekerja pada apa yang Anda minta. Cara ini berlaku di prompt apa pun, bahkan yang tidak berkaitan dengan alur **Lagune**. Misalnya, prompt bebas yang langsung meminta kumpulan **RegExp** yang aman dengan **Python**: ```prompt Muat spesialisasi regex dengan `npx lagune read catalog regex`, lalu buat kumpulan ekspresi reguler di @src/utils/regex.py untuk memvalidasi email dan nama pengguna. ``` Prompt ini memakai hook deterministik untuk menguji setiap **RegExp** terhadap **ReDoS**, mempertahankan yang aman, lalu menghasilkan sesuatu seperti ini: ```python import re EMAIL = re.compile(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$") USERNAME = re.compile(r"^[a-zA-Z0-9_]{3,20}$") def is_email(value: str) -> bool: return EMAIL.match(value) is not None def is_username(value: str) -> bool: return USERNAME.match(value) is not None ``` **Coba pemeriksa ReDoS** Uji sendiri sebuah pola di [**devina.io/redos-checker**](https://devina.io/redos-checker). ## Spesialisasi bawaan Spesialisasi bawaan dikelompokkan ke dalam [**kategori**](https://lagune.ai/id-ID/docs/categories). Berikut kumpulan yang disertakan bersama **Lagune**: | Spesialisasi | Kategori | Fokus | | --------------------- | --------------------------- | --------------------------------------------------------------------------------------------- | | `regex` | `owasp` | **ReDoS:** pola yang meledak pada input yang sengaja dirancang. | | `network` | `owasp` | **SSRF & redirect:** tujuan fetch atau redirect yang diberikan pengguna. | | `interpreter` | `owasp`, `lovable` | **Injeksi kode:** `eval`, include dinamis, dispatch berdasarkan nama. | | `sql` | `owasp` | **Basis data relasional:** injection, pemanggilan ORM mentah, hak akses, jangkauan engine. | | `path` | `owasp` | **Path filesystem:** traversal, null byte, stream NTFS, penanaman file. | | `upload` | `owasp` | **Unggahan file:** tipe dan signature, konten berbahaya, penyimpanan, batas. | | `access-control` | `owasp`, `lovable` | **Autentikasi, otorisasi, sesi:** IDOR, mass assignment, tenant, sesi. | | `credential-endpoint` | `owasp`, `lovable` | **Penebakan & bot:** brute force, spraying, stuffing, throttling. | | `federation` | `owasp` | **Kepercayaan token:** OAuth dan OIDC, SAML, validasi JWT, login lewat QR. | | `http-request` | `owasp` | **Asal request:** CSRF, salah konfigurasi CORS, IP klien yang dipalsukan. | | `transport` | `owasp` | **Keamanan kanal:** konfigurasi TLS, HTTPS dan teks polos, HSTS, pinning. | | `crypto` | `owasp`, `lovable` | **Kriptografi data tersimpan:** algoritma lemah atau buatan sendiri, CSPRNG, manajemen kunci. | | `secrets` | `owasp`, `lovable` | **Kredensial hardcoded:** kunci, token, dan kata sandi yang ditulis langsung di kode sumber. | | `api-endpoint` | `owasp` | **Permukaan non-REST:** GraphQL, gRPC, otorisasi WebSocket, DoS, skema. | | `payment` | `owasp`, `lovable` | **Alur checkout:** verifikasi gateway di sisi server, callback bertanda tangan, idempotensi. | | `xml` | `owasp` | **Parsing XML:** XXE, entitas eksternal, ekspansi billion laughs. | | `csv` | `owasp` | **Formula injection:** sel spreadsheet yang diawali `=`/`+`/`-`/`@`. | | `container` | `owasp`, `infra` | **Konfigurasi container:** root, capabilities, mount socket, hardening image. | | `infra` | `infra` | **Infrastruktur sebagai kode:** Terraform, Dockerfile, GitHub Actions. | | `serverless` | `owasp`, `infra`, `lovable` | **Fungsi FaaS:** IAM dengan hak akses minimum, input event, konteks, secret. | | `llm` | `ai`, `lovable` | **Risiko AI dan LLM:** prompt injection, agency, RAG, MCP, output. | | `supabase` | `lovable` | **Backend Supabase:** RLS nonaktif secara default, policy yang keliru dibuat AI, model kunci. | | `browser` | `javascript`, `lovable` | **Risiko sisi klien:** XSS, CSP, framing, storage, dll. | | `javascript` | `javascript` | **Risiko tingkat bahasa:** RCE, prototype pollution, dll. | | `python` | `python` | **Risiko tingkat bahasa:** RCE lewat `pickle`, class pollution, `-O`, dll. | | `rust` | `rust` | **Soundness `unsafe`:** UB dari pemanggil yang aman, `transmute`, overflow. | | `java` | `java` | **Deserialisasi & mobile code:** rantai `readObject`, pembajakan objek. | | `ruby` | `ruby` | **Deserialisasi & `open`:** penghidupan ulang lewat `Marshal`/YAML, keanehan pipe. | | `php` | `php` | **Type juggling & `unserialize`:** magic hash, POP chain. | | `go` | `go` | **Typed nil & data races:** `nil != nil`, goroutine dengan memori bersama. | | `c-cpp` | `c-cpp` | **Format string:** `printf(user_input)`, write-what-where lewat `%n`. | | `dotnet` | `dotnet` | **Risiko tingkat platform:** RCE lewat `BinaryFormatter`, `@Html.Raw`, celah enum. | Sebagian besar pengetahuan bawaan disarikan dari OWASP. Lihat [**Sumber OWASP**](https://lagune.ai/id-ID/docs/references/owasp-sources) untuk pemetaan lengkap setiap spesialisasi ke halaman serangan dan Cheat Sheet OWASP yang menjadi rujukannya. Beberapa modul khusus untuk stack tertentu justru bersumber dari panduan vendornya sendiri: `supabase`, misalnya, berasal dari dokumentasi Supabase dan CVE-2025-48757. ## Spesialisasi milik Anda Spesialisasi bawaan bertambah dengan satu file pengetahuan dan satu baris indeks, tidak pernah dengan perintah baru. Anda menambahkan spesialisasi sendiri dengan cara yang sama, lewat perintah [`/lagune-specialize`](https://lagune.ai/id-ID/docs/commands/specialize): arahkan ke sebuah artikel atau topik, dan perintah ini menyarikan spesialisasi baru ke proyek Anda, berupa file di `.lagune/catalog/` beserta entrinya di `.lagune/configs.json`. Spesialisasi milik Anda selalu ada di katalog, apa pun kategorinya, dan spesialisasi Anda menggantikan spesialisasi bawaan yang bernama sama. **Secara internal, Lagune memuat spesialisasi secara otomatis, hanya saat dibutuhkan** Saat fase detect atau verify menemukan konteks yang dicakup sebuah spesialisasi, fase itu sendiri yang memuat spesialisasi tersebut dengan `read catalog `. Ini terjadi otomatis, sebagai bagian dari fase. Anda tidak perlu melakukannya secara manual agar ini berjalan. ## Lihat apa saja yang tersedia Untuk menampilkan katalog proyek Anda dari terminal, satu spesialisasi per baris beserta tag-nya: ```bash npx lagune read catalog # regex: Regular Expression [required] # network: Requests, Webhook, URL Fetch, Socket, IMDS, Redirect # interpreter: Evaluator, Sink, Shell, Dynamic Execution # ... ``` Spesialisasi bertanda `[required]` selalu berlaku, apa pun pekerjaannya. Spesialisasi bawaan mana saja yang muncul di daftar bergantung pada [**kategori**](https://lagune.ai/id-ID/docs/categories) proyek Anda. **Spesialisasi tidak dimuat secara default** Pengetahuan yang relevan dimuat sesuai dengan apa proyek itu sebenarnya, alih-alih menjalankan semua pemeriksaan secara default. ## Pertanyaan yang sering diajukan ### Apa itu spesialisasi Lagune? Modul pengetahuan keamanan yang terfokus dan tidak bergantung pada bahasa pemrograman, yang dimuat hanya saat dibutuhkan, tidak pernah secara default. Spesialisasi bukan perintah seperti skill agen. ### Apa itu katalog proyek? Kumpulan spesialisasi yang dipakai proyek: spesialisasi bawaan dari kategorinya, ditambah spesialisasi milik proyek sendiri. Selama belum ada kategori yang dicatat, proyek hanya memakai OWASP. ### Apakah spesialisasi dimuat secara default? Tidak. Spesialisasi hanya dimuat saat dibutuhkan, sesuai dengan apa proyek itu sebenarnya. ### Bagaimana cara memuat spesialisasi secara langsung? Di prompt yang sama dengan tugasnya, minta agen Anda menjalankan npx lagune read catalog . --- # /lagune-specialize: latih spesialisasi keamanan dengan teks biasa > Sarikan sumber atau topik keamanan yang Anda berikan menjadi spesialisasi baru yang dimuat hanya saat dibutuhkan. Kanonis: https://lagune.ai/id-ID/docs/commands/specialize Bahasa: id-ID Asli: https://lagune.ai/docs/commands/specialize Terakhir diperbarui: 2026-11-06 🎓 Ajari **Lagune** spesialisasi baru, dari sumber atau topik yang Anda berikan. Specialize membaca materinya dan menyarikannya menjadi spesialisasi yang terfokus dan khusus pertahanan, dengan bentuk yang persis sama seperti [spesialisasi bawaan](https://lagune.ai/id-ID/docs/catalog), sehingga fase detect dan verify kemudian memuatnya seperti spesialisasi lainnya. Specialize hanya mengaudit dan menjelaskan: tidak pernah menulis input serangan atau eksploit, dan tidak pernah menyentuh kode Anda. **Dari artikel** ```prompt # Tautan atau referensi: Lagune menyarikannya menjadi pertahanan /lagune-specialize https://owasp.org/www-community/attacks/SQL_Injection ``` **Dari eksploit** ```prompt # Serangan sebagai sumber: spesialisasinya tetap berupa pertahanan /lagune-specialize "' OR 1=1 -- menyisipkan SQL ke dalam teks query" ``` **Dari topik** ```prompt # Atau cukup sebutkan apa yang perlu dicakup /lagune-specialize SQL injection ``` **Serangan boleh menjadi sumber, tidak pernah menjadi hasil** Mengarahkannya ke sebuah serangan tidak masalah jika tujuannya untuk bertahan dari serangan itu: tulisan tentang eksploit adalah bahan belajar yang disarikannya menjadi pertahanan. Spesialisasi yang dihasilkannya selalu mengaudit dan menjelaskan, dan tidak pernah menghasilkan eksploit yang berfungsi, payload, atau cara menghindari deteksi. ## Apa yang ditulisnya Hasilnya berupa dua file di proyek Anda, yang di-commit dan bisa ditinjau bersama kode Anda: - Spesialisasinya di `.lagune/catalog/.md`, dengan bentuk seperti [spesialisasi bawaan](https://lagune.ai/id-ID/docs/catalog). - Entrinya di `.lagune/configs.json`, tempat proyek Anda mengindeks spesialisasinya sendiri agar katalog bisa menggabungkannya dengan spesialisasi bawaan. Setelah itu, specialize menampilkan daftar katalog untuk memastikan entri baru sudah ada. Spesialisasi milik Anda selalu ada di katalog, apa pun kategorinya. Anda tidak pernah menambahkan perintah atau menyentuh paket: spesialisasi baru hanyalah satu file pengetahuan ditambah satu entri indeks, yang ditulis ke proyek Anda sendiri. ## Menyempurnakan, tidak pernah menimpa Membuat spesialisasi dengan nama yang sudah ada, baik spesialisasi bawaan seperti `regex` maupun spesialisasi yang pernah Anda buat, akan **menyelaraskan** file yang ada dengan kondisi terkini alih-alih menggantinya. Specialize membaca isi yang ada, memasukkan pengetahuan baru, mempertahankan yang masih berlaku, dan menulis ulang yang berubah. Tidak ada yang dibuang tanpa dibaca. Spesialisasi milik Anda menggantikan spesialisasi bawaan yang bernama sama, sehingga Anda bisa mempertajam spesialisasi bawaan untuk proyek Anda sendiri tanpa kehilangannya. **Tips** - Spesialisasi baru dimuat persis seperti spesialisasi bawaan: fase detect dan verify memakainya hanya saat dibutuhkan, atau muat sendiri dengan `npx lagune read catalog ` lalu beri tugas. - Jika materinya punya asal yang jelas (sebuah artikel, penulis, tautan, atau standar), spesialisasi mencantumkan kreditnya. Topik saja tidak membawa sumber. **Catatan** **Specialize hanya berjalan saat Anda memanggilnya:** agen tidak pernah memulainya atas inisiatif sendiri. ## Pertanyaan yang sering diajukan ### Bagaimana cara menambahkan spesialisasi keamanan kustom? Jalankan /lagune-specialize dengan sebuah sumber atau topik. Perintah ini menyarikannya menjadi spesialisasi khusus pertahanan, yang ditulis ke .lagune/catalog/.md beserta entrinya di .lagune/configs.json. ### Apakah Lagune bisa belajar dari tulisan tentang eksploit? Bisa, sebagai sumber, tidak pernah sebagai hasil. Serangan boleh menjadi sumber, tidak pernah menjadi produknya. Specialize tidak pernah menulis input serangan atau eksploit. ### Apakah specialize menimpa spesialisasi bawaan? Tidak. Specialize menyempurnakan, tidak pernah menimpa. --- # /lagune-prove: proof of concept khusus pertahanan > Ubah setiap temuan yang terdeteksi menjadi proof of concept (PoC) khusus pertahanan yang bisa dijalankan, lengkap dengan advisori keamanan untuk pengungkapan yang bertanggung jawab. Kanonis: https://lagune.ai/id-ID/docs/commands/prove Bahasa: id-ID Asli: https://lagune.ai/docs/commands/prove Terakhir diperbarui: 2026-11-06 🧪 Ubah setiap temuan yang terdeteksi menjadi bukti khusus pertahanan yang bisa dijalankan, untuk pengungkapan yang bertanggung jawab. Untuk setiap temuan di peta detect, prove menulis advisori keamanan yang berdiri sendiri dan sebuah tes yang memastikan **jalur aman**, sehingga tes gagal selama masalahnya masih ada dan lolos begitu kodenya diperbaiki. **Tips** Tes **Lagune** terisolasi di `.lagune/`, terpisah dari rangkaian tes Anda sendiri. ## Cara menggunakan **Semua temuan** ```prompt /lagune-prove ``` **Temuan tertentu** Lihat nama temuan yang sudah dilacak: ```prompt npx lagune read list --findings # Findings # ... # • SQL injection pada pencarian pengguna # ... ``` ```prompt # Lalu buktikan salah satunya /lagune-prove SQL injection pada pencarian pengguna ``` ## Cara kerjanya Prove membaca kode sumber yang ditunjuk setiap temuan, lalu menulis satu direktori untuk setiap temuan yang terbukti di bawah `.lagune/proofs/`, berisi tepat dua file: | File | Isinya | | ------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | | `report.test.mjs` (atau `.cjs`) | Tesnya. Tes berjalan di Poku jika proyek Anda sudah menggunakannya, dan jika tidak, di test runner bawaan Node.js, jadi tidak perlu menginstal apa pun. | | `report.md` | Advisori keamanan yang berdiri sendiri: tingkat keparahan, dampak, cara mereproduksinya, dan perintah untuk menjalankannya, bisa dibaca tanpa konteks lain. | Pembuktiannya selalu dalam JavaScript, jadi tetap portabel apa pun bahasa pemrograman proyek Anda. Indeks `README.md` menautkan setiap pembuktian dan menyediakan satu perintah untuk menjalankan semuanya. **Tips** - Prove bersifat **opsional dan mandiri**: bukan salah satu dari lima fase, dan bukan bagian dari rantai pelacakan. - Prove hanya menulis ke `.lagune/proofs/` dan tidak pernah menyentuh artefak fase atau kode Anda, yang hanya dibacanya. - Temuan yang tesnya tidak bisa mereproduksi masalah tidak mendapat pembuktian, dan prove meminta Anda menjalankan [`/lagune-detect`](https://lagune.ai/id-ID/docs/commands/detect) di titik itu untuk menyelaraskannya dengan kondisi terkini. - Menjalankannya lagi akan menyelaraskan pembuktian dengan kondisi terkini: direktori milik temuan yang sudah hilang atau tidak lagi bisa direproduksi akan dihapus. **Catatan** **Prove hanya berjalan saat Anda memanggilnya:** agen tidak pernah memulainya atas inisiatif sendiri. **Bertumpu pada detect** Prove membaca peta detect dari [`/lagune-detect`](https://lagune.ai/id-ID/docs/commands/detect), jadi jalankan detect terlebih dahulu. ## Khusus pertahanan, dan dengan izin Sebelum menghasilkan apa pun, prove memastikan Anda berwenang menguji target tersebut, dan menolak setiap permintaan eksploit yang berfungsi, payload serangan, atau cara menghindari deteksi. Pembuktian menunjukkan perilaku yang aman, dan tidak pernah menghasilkan input serangan. ## Dari pembuktian ke pengungkapan Dua file dari setiap temuan yang terbukti dimasukkan bersama ke dalam **GitHub Gist privat** untuk melaporkan kerentanannya. Keduanya adalah bukti masalah yang masih aktif dan belum diungkapkan, jadi `.gitignore` di dalam `.lagune/proofs/` menjaganya tetap di luar setiap commit: bagikan hanya lewat Gist itu sampai maintainer menyelesaikan masalahnya. Menutup temuan di rantai **Lagune** tetap menjadi tugas [`/lagune-harden`](https://lagune.ai/id-ID/docs/commands/harden) dan [`/lagune-verify`](https://lagune.ai/id-ID/docs/commands/verify): prove menghasilkan bukti, tidak menutup apa pun. ## Pertanyaan yang sering diajukan ### Apakah Lagune membuat eksploit? Tidak. /lagune-prove menulis bukti khusus pertahanan: sebuah tes yang memastikan jalur aman, sehingga gagal selama masalahnya masih ada dan lolos begitu kodenya diperbaiki, ditambah advisori keamanan untuk pengungkapan yang bertanggung jawab. ### Apa yang dihasilkan prove? Dua file per temuan: sebuah tes (report.test.mjs atau .cjs) dan sebuah advisori keamanan (report.md). ### Bagaimana cara mengungkapkan bug yang ditemukan Lagune secara bertanggung jawab? Prove menulis advisori keamanan yang berdiri sendiri, yang bisa Anda bagikan lewat saluran privat seperti GitHub Gist privat, sesuai prinsip pengungkapan yang bertanggung jawab. --- # Konfigurasi hook: pilih apa yang dipindai > Pilih apa yang dilewati oleh hook yang memindai file, untuk semuanya atau untuk satu hook saja. Kanonis: https://lagune.ai/id-ID/docs/hooks/configure Bahasa: id-ID Asli: https://lagune.ai/docs/hooks/configure Terakhir diperbarui: 2026-11-06 Blok `checkers` di `.lagune/configs.json` menentukan apa yang dilewati oleh hook yang memindai file, untuk semuanya atau untuk satu hook saja. ## Cara mengonfigurasi Tambahkan atau hapus path dan pola dari command line, dengan mengapit pola dalam tanda kutip agar shell membiarkannya seperti yang ditulis: ```bash npx lagune write add --ignore test/fixtures npx lagune write add --ignore 'packages/*/dist' --checker secrets npx lagune write remove --ignore test/fixtures ``` Atau pilih di Settings pada [dasbor](https://lagune.ai/id-ID/docs/get-started/dashboard), atau tetapkan langsung di file: ```json { "checkers": { "ignore": ["test/fixtures"], "secrets": { "gitignore": false, "ignore": ["test/fixtures", "temp"] } } } ``` ### Pengaturan | Kunci | Nilai | Default | Deskripsi | | ----------- | ------------------------------- | ------- | ------------------------------------------------------------------------------------------------------- | | `gitignore` | `true` atau `false` | `true` | Melewati apa yang diabaikan **Git**. File yang dilacak **Git** tetap dipindai. | | `ignore` | path atau pola dari root proyek | `[]` | Melewati apa pun yang cocok dengan tiap entri beserta seluruh isinya, bahkan file yang dilacak **Git**. | Di tingkat teratas `checkers`, sebuah kunci berlaku untuk semua checker. Di bawah nama sebuah checker, kunci itu hanya berlaku untuk checker tersebut dan menggantikan kunci bersama, jadi dalam contoh di atas `secrets` memindai apa yang diabaikan **Git** dan melewati `test/fixtures` serta `temp`. Saat `write add --ignore` memberi sebuah checker daftar pertamanya sendiri, daftar itu dimulai sebagai salinan dari daftar bersama. ### Pola Pola dimulai dari root proyek, jadi `*.generated.ts` hanya menjangkau file di sana, sedangkan `**/*.generated.ts` menjangkaunya di kedalaman mana pun. Nama harus cocok persis, termasuk huruf besar dan kecilnya. | Pola | Yang dilewati | | ------------------- | --------------------------------------------------- | | `dist` | `dist` di root proyek | | `packages/*/dist` | `dist` di setiap folder di bawah `packages` | | `**/dist` | setiap `dist`, di kedalaman mana pun | | `**/*.generated.ts` | setiap file yang namanya berakhiran `.generated.ts` | | `fixture-?` | `fixture-a`, `fixture-1`, dan sejenisnya | | `[ab]-cache` | `a-cache` dan `b-cache` | | `[*]x` | `*x`, dengan `*` harfiah | ## Cara membaca hasilnya Laporan diakhiri dengan jumlah path yang dilewati pemindaian, dikelompokkan menurut apa yang mengabaikannya: ```text Skipped 25 paths that Git ignores and 3 paths that .lagune/configs.json ignores. Name one with --dir or --file to scan it. ``` Path yang disebut dengan `--dir` atau `--file` tetap dipindai, apa pun isi pengaturannya. Pengaturan yang tidak bisa dibaca engine menghentikan checker dengan error yang menyebutkannya, misalnya pola yang diawali `!` atau spasi, keluar dari proyek, membiarkan kurung siku terbuka, atau terlalu lama dicocokkan. ## Pertanyaan yang sering diajukan ### Apakah Lagune mengatur ini untuk saya? Tidak. Charter mencantumkan folder yang di-commit yang, menurut pembacaannya, bukan kode Anda yang perlu dipertahankan, seperti fixture tes yang sengaja ditulis agar terlihat rentan, dan hanya mencatat yang Anda pilih berdasarkan nomornya. ### Kapan checker perlu memindai apa yang diabaikan Git? Saat repositori itu bukan milik Anda sehingga tidak bisa langsung dipercaya, karena file .gitignore di dalamnya bisa menyembunyikan kode, atau saat folder build mungkin membawa kunci yang disisipkan saat build. Atur gitignore ke false untuk semua checker atau untuk satu checker saja. --- # Hook agent: deteksi loop agen tanpa batas > Pindai basis kode untuk menemukan panggilan agen dan LLM tanpa batas langkah atau waktu, atau nilai satu panggilan, langsung dari command line. Kanonis: https://lagune.ai/id-ID/docs/hooks/agent Bahasa: id-ID Asli: https://lagune.ai/docs/hooks/agent Terakhir diperbarui: 2026-11-06 Hook `agent` menandai **runtime agen yang berulang tanpa batas giliran, anggaran, atau waktu**, celah otonomi tak terkendali yang mengubah input yang sengaja dirancang menjadi biaya tanpa batas atau eskalasi prompt injection. Hook ini **mengenali bahasa** dan mencakup dua ekosistem framework agen: **JavaScript** (runtime `query` dari SDK agen **Claude**) dan **Python** (**LangChain**, **LangGraph**, **CrewAI**, **OpenAI Agents**). Hook ini adalah engine deterministik di balik [spesialisasi `llm`](https://lagune.ai/id-ID/docs/catalog), dan Anda bisa menjalankannya sendiri dalam mode **scan** atau **check**. ## Menjalankan **Pindai basis kode** ```bash npx lagune read agent # scans the whole project npx lagune read agent --dir src/ai # scans a directory npx lagune read agent --file chat.ts # scans a single file ``` **Periksa satu panggilan** ```bash npx lagune read agent --lang javascript --pattern 'query({ prompt })' # => uncapped npx lagune read agent --lang javascript --pattern 'query({ prompt, options: { maxTurns: 5 } })' # => safe npx lagune read agent --lang python --pattern 'AgentExecutor(agent=a, max_iterations=None)' # => uncapped ``` Setiap baris di bawah **Uncapped agent loops found**, di file yang mengimpor SDK agen, adalah salah satu dari dua hal: runtime `query` dari SDK agen Claude yang dipanggil tanpa batas giliran, anggaran, atau waktu (JavaScript, tanpa batas secara bawaan), atau penghapusan eksplisit batas bawaan sebuah framework, seperti `max_iterations=None` / `max_turns=None` (Python, dengan batas secara bawaan). Keduanya keluar dengan kode bukan nol. Di Vercel AI SDK, `generateText`/`streamText` secara bawaan hanya menjalankan satu langkah (`stopWhen: stepCountIs(1)`), jadi panggilan polos di sana tidak bisa berulang dan tidak ditandai, dan `db.query(...)` biasa tidak pernah dikira panggilan agen. Proses yang bersih mencetak `no uncapped agent loops found`. ## Cara membaca putusan | Putusan | Arti | | ---------- | --------------------------------------------------------------------------------------------------------------------- | | `uncapped` | Panggilan runtime `query` tanpa batas (JS), atau penghapusan batas secara eksplisit (`=None`, Py). | | `safe` | Panggilan `query` yang menetapkan batas, generasi satu langkah, atau panggilan framework yang dibatasi secara bawaan. | | `invalid` | Potongan kode tidak berisi panggilan agen yang bisa dikenali untuk dinilai. | ### Opsi CLI | Opsi | Nilai | Deskripsi | | ----------- | ------------- | ---------------------------------------------------------------------------------- | | `--pattern` | potongan kode | Memeriksa satu panggilan. Ulangi untuk memeriksa beberapa, satu putusan per baris. | | `--lang` | sebuah bahasa | Wajib bersama `--pattern`: `javascript` atau `python`. | | `--dir` | direktori | Membatasi pemindaian ke satu direktori. Bisa diulang dan digabung dengan `--file`. | | `--file` | file | Membatasi pemindaian ke satu file. Bisa diulang dan digabung dengan `--dir`. | Tanpa opsi apa pun, hook ini memindai seluruh proyek. `--pattern` memerlukan `--lang` dan tidak bisa digabung dengan `--dir` atau `--file`. ### Pilih apa yang dipindai Hook ini melewati apa yang diabaikan **Git**. Untuk melewati lebih banyak, atau untuk memindai apa yang diabaikan **Git**, beri `agent` pengaturannya sendiri: ```bash npx lagune write add --ignore test/fixtures --checker agent ``` ```json { "checkers": { "agent": { "gitignore": false, "ignore": ["test/fixtures"] } } } ``` [Konfigurasi hook](https://lagune.ai/id-ID/docs/hooks/configure) membahas semua pengaturannya. **Upaya terbaik, tidak menyeluruh** Loop agen yang dibuat sendiri, dalam bahasa apa pun, berada di luar jangkauan pemindaian statis. Anggap ini sebagai dasar yang kuat, bukan inventaris yang lengkap. **Tips** Hook ini hanya memutuskan soal batas: pembatasan kemampuan, pencampuran tingkat kepercayaan, dan otorisasi adalah soal penilaian yang tetap dicakup oleh [spesialisasi `llm`](https://lagune.ai/id-ID/docs/catalog). ## Pertanyaan yang sering diajukan ### Kenapa loop agen perlu dibatasi? Agen tanpa batas bisa digiring ke rekursi, biaya, atau eskalasi prompt injection yang tak berujung. Menetapkan maxTurns/maxBudgetUsd/stopWhen/signal membatasinya, dan hook agent menandai panggilan runtime query yang tidak menetapkan satu pun. --- # Hook cors: audit origin CORS > Pindai kode sumber untuk menemukan daftar izin origin CORS yang bisa ditembus, atau nilai apakah satu origin memberi akses yang terlalu longgar, langsung dari command line. Kanonis: https://lagune.ai/id-ID/docs/hooks/cors Bahasa: id-ID Asli: https://lagune.ai/docs/hooks/cors Terakhir diperbarui: 2026-11-06 Hook `cors` adalah engine deterministik di balik [spesialisasi `http-request`](https://lagune.ai/id-ID/docs/catalog), dan Anda bisa menjalankannya sendiri. Hook ini bekerja dalam dua mode dari satu perintah: **scan**, yang memindai kode sumber untuk menemukan **daftar izin origin yang bisa ditembus** (regex validasi host yang bisa dilewati host milik penyerang), dan **score**, yang menilai satu nilai **origin CORS** sebagai `wildcard`, `null`, atau `safe`. ## Memindai basis kode Tanpa flag apa pun, hook ini memindai seluruh proyek. **Seluruh proyek** ```bash npx lagune read cors ``` **Satu direktori** ```bash npx lagune read cors --dir src/server ``` **Satu file** ```bash npx lagune read cors --file internal/auth/origin.go ``` Hook ini mencantumkan setiap daftar izin yang bisa ditembus di bawah satu header, dikelompokkan per file. Validator host yang menempatkan `.+`/`.*` di segmen authority sebelum sufiks host tepercaya (`^https?://.+\.trusted\.com`) meloloskan host penyerang seperti `your-site.com.attacker.com`. ```text Origin-allowlist patterns with a greedy wildcard (bypassable, review): internal/auth/origin.go ^https?://.+\.trusted\.com ``` Ini adalah petunjuk untuk ditinjau, bukan temuan yang sudah pasti: dari teksnya saja tidak bisa dipastikan apakah regex itu benar-benar menjaga keputusan kepercayaan, jadi pemindaian tidak pernah mengubah kode keluar. Baca masing-masing dan pastikan daftar izinnya membandingkan dengan kesamaan penuh. Jika tidak ada yang ditemukan, hook ini mencetak satu baris. ```bash npx lagune read cors --dir src/clean # => no bypassable origin allowlist found ``` ## Menilai origin Berikan setiap origin dengan `--origin`. Hook ini mencetak satu kata per origin dan keluar dengan kode bukan nol jika ada `wildcard` atau `null`. **Satu origin** ```bash npx lagune read cors --origin '*' # => wildcard npx lagune read cors --origin 'null' # => null npx lagune read cors --origin 'https://app.example.com' # => safe ``` **Beberapa origin** Ulangi `--origin` untuk menilai seluruh daftar izin dalam satu panggilan, satu putusan per baris, sesuai urutan. ```bash npx lagune read cors \ --origin 'https://app.example.com' \ --origin '*' \ --origin 'null' # => safe # => wildcard # => null ``` | Putusan | Arti | | ---------- | ------------------------------------------------------------------------------------------------------------ | | `safe` | Bukan `*`, `null`, atau glob `*`. Tidak menjamin origin-nya berformat benar. | | `wildcard` | `*`, atau glob subdomain, host, atau port: situs mana pun (atau sekumpulan luas situs) bisa membaca respons. | | `null` | Origin `null`, yang bisa dipalsukan oleh iframe dalam sandbox dan redirect. | Hanya `safe` yang berarti diizinkan, dan `--origin` adalah oracle nilai: ia menilai nilainya, bukan handler-nya, jadi pastikan handler-nya dengan spesialisasi `http-request`. ### Opsi CLI | Opsi | Nilai | Deskripsi | | ---------- | --------- | ---------------------------------------------------------------------------------- | | `--origin` | origin | Menilai satu nilai origin. Ulangi untuk menilai beberapa, satu per baris. | | `--dir` | direktori | Membatasi pemindaian ke satu direktori. Bisa diulang dan digabung dengan `--file`. | | `--file` | file | Membatasi pemindaian ke satu file. Bisa diulang dan digabung dengan `--dir`. | Tanpa opsi apa pun, hook ini memindai seluruh proyek. `--origin` adalah mode score dan tidak bisa digabung dengan `--dir` atau `--file`. ### Pilih apa yang dipindai Hook ini melewati apa yang diabaikan **Git**. Untuk melewati lebih banyak, atau untuk memindai apa yang diabaikan **Git**, beri `cors` pengaturannya sendiri: ```bash npx lagune write add --ignore test/fixtures --checker cors ``` ```json { "checkers": { "cors": { "gitignore": false, "ignore": ["test/fixtures"] } } } ``` [Konfigurasi hook](https://lagune.ai/id-ID/docs/hooks/configure) membahas semua pengaturannya. **Yang tidak dicakup** Pemindaian membaca bentuk **regex yang bisa ditembus**, dan `--origin` menilai **nilai** origin. Dua pola di tingkat kode sumber tetap di luar jangkauan: pemantulan `Origin` dari request (server mengembalikan `Origin` yang masuk, atau memasangkannya dengan kredensial), dan daftar izin longgar berbasis `endsWith` atau substring. Kenali keduanya di kode dan tangani seperti yang dijelaskan [spesialisasi `http-request`](https://lagune.ai/id-ID/docs/catalog). ## Pertanyaan yang sering diajukan ### Kenapa origin CORS null berbahaya? Iframe dalam sandbox dan sebagian redirect mengirim Origin: null, jadi daftar izin yang memercayai null memberi konteks tersebut akses baca. Hook cors menandainya bersama wildcard. ### Bagaimana cara menemukan daftar izin origin CORS yang bisa ditembus? Jalankan npx lagune read cors di basis kode Anda. Hook ini menandai regex validasi host yang wildcard serakahnya berada sebelum sufiks tepercaya, sehingga host penyerang seperti your-site.com.attacker.com bisa lolos. --- # Hook crypto: deteksi kriptografi lemah > Pindai basis kode untuk menemukan primitif kriptografi yang lemah, atau nilai satu potongan kode, langsung dari command line. Kanonis: https://lagune.ai/id-ID/docs/hooks/crypto Bahasa: id-ID Asli: https://lagune.ai/docs/hooks/crypto Terakhir diperbarui: 2026-11-06 Hook `crypto` menandai **primitif kriptografi yang lemah** di titik pemanggilannya: cipher yang usang, mode yang tidak aman, atau digest yang sudah rusak. Hook ini **mengenali bahasa** dan membaca setiap file dengan aturan bahasanya sendiri, sehingga konstruksi Python tidak pernah ditandai di file Rust. Hook ini juga engine deterministik di balik [spesialisasi `crypto`](https://lagune.ai/id-ID/docs/catalog), yang bisa Anda jalankan sendiri dalam mode **scan** atau **check**. ## Menjalankan **Pindai basis kode** ```bash npx lagune read crypto # scans the whole project npx lagune read crypto --dir src # scans a directory npx lagune read crypto --file hash.ts # scans a single file ``` **Periksa potongan kode** ```bash npx lagune read crypto --lang javascript --pattern 'createCipher("aes-256-cbc", k)' # => weak npx lagune read crypto --lang python --pattern 'hashlib.md5(data)' # => review npx lagune read crypto --lang go --pattern 'sha256.Sum256(data)' # => safe ``` Pemindaian mencetak hingga dua bagian. **Weak cryptography found** berisi temuan (DES, 3DES, RC4, Blowfish, RC2, mode ECB): masing-masing adalah primitif cipher yang rusak, jadi hook ini keluar dengan kode bukan nol. **Cryptography to review manually** berisi petunjuk yang tidak bisa dinilainya sendiri: digest MD5 atau SHA-1 (rusak untuk keperluan keamanan, tetapi sah sebagai checksum biasa, jadi niat penggunaannya yang menentukan), RNG non-kriptografis dalam konteks keamanan, atau perbandingan yang rentan terhadap serangan timing. Proses yang bersih mencetak `no weak cryptography found`. ## Cara membaca putusan | Putusan | Arti | | --------- | ----------------------------------------------------------------------------------------------------------------------- | | `weak` | Potongan kode memakai primitif cipher yang rusak (DES atau 3DES, RC4, Blowfish, RC2, atau mode ECB). | | `review` | Primitif yang bergantung pada niat penggunaan: digest MD5 atau SHA-1, atau RNG non-kriptografis dalam konteks keamanan. | | `safe` | Potongan kode memakai kriptografi, dan tidak ada primitif lemah yang ditemukan. | | `invalid` | Potongan kode tidak berisi konstruksi kriptografi yang bisa dikenali untuk dinilai. | ### Opsi CLI | Opsi | Nilai | Deskripsi | | ----------- | ------------- | ------------------------------------------------------------------------------------------------------ | | `--pattern` | potongan kode | Memeriksa satu potongan kode. Ulangi untuk memeriksa beberapa, satu putusan per baris. | | `--lang` | sebuah bahasa | Wajib bersama `--pattern`: javascript, python, go, java, kotlin, php, ruby, rust, csharp, c, atau cpp. | | `--dir` | direktori | Membatasi pemindaian ke satu direktori. Bisa diulang dan digabung dengan `--file`. | | `--file` | file | Membatasi pemindaian ke satu file. Bisa diulang dan digabung dengan `--dir`. | Tanpa opsi apa pun, hook ini memindai seluruh proyek. `--pattern` memerlukan `--lang` dan tidak bisa digabung dengan `--dir` atau `--file`. ### Pilih apa yang dipindai Hook ini melewati apa yang diabaikan **Git**. Untuk melewati lebih banyak, atau untuk memindai apa yang diabaikan **Git**, beri `crypto` pengaturannya sendiri: ```bash npx lagune write add --ignore test/fixtures --checker crypto ``` ```json { "checkers": { "crypto": { "gitignore": false, "ignore": ["test/fixtures"] } } } ``` [Konfigurasi hook](https://lagune.ai/id-ID/docs/hooks/configure) membahas semua pengaturannya. ### Bahasa yang didukung Pemindaian membaca bahasa berikut, dikenali dari ekstensi file, dan memeriksa masing-masing terhadap API kriptografinya sendiri. | Bahasa | Cipher lemah (temuan) serta digest dan RNG (tinjauan) | | --------------------------- | ---------------------------------------------------------------------------------------------------------------------- | | **JavaScript / TypeScript** | `createCipher`, `CryptoJS.DES/RC4`, `*-ecb` dalam tanda kutip; MD5/SHA-1 `createHash`/`subtle.digest`; `Math.random()` | | **Python** | pycryptodome `DES/ARC4/Blowfish.new`, `algorithms.TripleDES`, `MODE_ECB`; `hashlib.md5/sha1`; `random.*` | | **Go** | `des.NewCipher`, `rc4.NewCipher`, `blowfish.NewCipher`, `NewECBEncrypter`; `md5/sha1.Sum`; `math/rand` | | **Java / Kotlin** | `Cipher.getInstance("DES"/…/ECB")`; `MessageDigest.getInstance("MD5")`, `HmacMD5`; `java.util.Random` | | **PHP** | `openssl_encrypt("des-…"/"…-ecb")`, `mcrypt_*`; `md5()`/`sha1()`, `hash("md5", …)`; `rand()`/`mt_rand()` | | **Ruby** | `OpenSSL::Cipher.new("des-…")`, `:ECB`; `Digest::MD5/SHA1`; `rand()`/`Random` | | **Rust** | `Rc4::`, `Blowfish::`, `des::`, `ecb::`; `Md5::`, `Sha1::`, `Hmac`; `SmallRng`/`XorShiftRng` | | **C#** | `DES/TripleDES/RC2.Create`, `CipherMode.ECB`; `MD5/SHA1.Create`, `HMACMD5`; `new Random()` | | **C / C++** | OpenSSL `DES_*`/`RC4`/`EVP_des_*`, `EVP_*_ecb`; `MD5()`/`SHA1()`, `EVP_md5`; `rand()`/`random()` | **Upaya terbaik, tidak menyeluruh** Hook ini membaca kode sumber sebagai teks, jadi primitif yang dirakit saat runtime, disembunyikan di balik alias, atau ditulis dalam bentuk yang tidak dikenalinya bisa lolos. Anggap tabel ini sebagai titik awal yang kuat, bukan inventaris yang lengkap. **Tips** Hook ini menjamin dasarnya (konstruksi ini memang ada): manajemen kunci, penggunaan ulang IV, dan padding RSA adalah soal penilaian yang tetap dicakup oleh [spesialisasi `crypto`](https://lagune.ai/id-ID/docs/catalog). ## Pertanyaan yang sering diajukan ### Bagaimana cara memindai basis kode untuk menemukan kriptografi yang lemah? Jalankan hook crypto tanpa flag apa pun. Cipher yang rusak dan mode ECB adalah temuan yang keluar dengan kode bukan nol. Digest MD5/SHA-1 adalah petunjuk untuk ditinjau, karena rusak untuk keperluan keamanan tetapi sah sebagai checksum biasa. ### Apakah hook crypto menandai Math.random()? Hanya sebagai petunjuk untuk ditinjau dalam konteks keamanan, tidak pernah sebagai temuan otomatis, karena keacakan sah dipakai untuk jitter atau pengurutan elemen di UI. --- # Hook cvss: hitung skor vektor CVSS v4.0 > Hitung skor satu atau beberapa vektor CVSS v4.0 dari command line, dengan aritmetika yang sama seperti kalkulator FIRST, dan baca penjelasan tiap vektor dalam bahasa sederhana. Kanonis: https://lagune.ai/id-ID/docs/hooks/cvss Bahasa: id-ID Asli: https://lagune.ai/docs/hooks/cvss Terakhir diperbarui: 2026-11-06 Hook `cvss` menghitung skor **vektor CVSS v4.0** lalu mencetak skor dan tingkat keparahannya, yaitu penilaian yang ditulis perintah [`/lagune-plan`](https://lagune.ai/id-ID/docs/commands/plan) di setiap perbaikan dan perintah [`/lagune-prove`](https://lagune.ai/id-ID/docs/commands/prove) di setiap advisori keamanan. Hook ini adalah engine deterministik di balik penilaian tersebut, dengan aritmetika yang sama seperti [kalkulator FIRST](https://www.first.org/cvss/calculator/4.0), dan Anda bisa menjalankannya sendiri. ## Menjalankan Berikan setiap vektor dengan `--vector`. Hook ini mencetak satu baris per vektor: skor dan tingkat keparahannya. **Satu vektor** ```bash npx lagune read cvss --vector 'CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N' # => 9.3, Critical ``` **Beberapa vektor** Ulangi `--vector` untuk menghitung beberapa sekaligus, satu baris untuk masing-masing, sesuai urutan. ```bash npx lagune read cvss \ --vector 'CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N' \ --vector 'CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N/MAV:A' # => 9.3, Critical # => 8.7, High ``` **Dalam bahasa sederhana** Tambahkan `--explain` untuk membaca penjelasan setiap metrik dalam bahasa sederhana. Jika metrik Threat atau Environmental mengubah skornya, skor Base saja ditampilkan lebih dulu. ```bash npx lagune read cvss --explain --vector 'CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N/MAV:A' # => 8.7, High # => Base metrics alone: 9.3, Critical # => Attack Vector: Network, modified to Adjacent # => Attack Complexity: Low # => ... ``` ## Cara membaca hasilnya | Tingkat | Skor | | ---------- | --------------- | | `None` | 0.0 | | `Low` | 0.1 sampai 3.9 | | `Medium` | 4.0 sampai 6.9 | | `High` | 7.0 sampai 8.9 | | `Critical` | 9.0 sampai 10.0 | Vektor yang hanya berisi metrik Base menilai celahnya sendiri dengan asumsi terburuk: setiap kebutuhan keamanan bernilai High dan celahnya sudah dieksploitasi di dunia nyata. Metrik Environmental (`MAV` dan metrik modifikasi lainnya, ditambah `CR`, `IR`, dan `AR`) menyesuaikan skornya untuk satu deployment tertentu, dan metrik Threat (`E`) menyesuaikannya dengan apa yang diketahui tentang eksploitasinya. Vektor yang tidak valid mencetak `invalid vector:` beserta letak kesalahannya, dan hook ini keluar dengan kode bukan nol. ### Opsi CLI | Opsi | Nilai | Deskripsi | | ----------- | ----------------- | ---------------------------------------------------------------------------------------------------- | | `--vector` | vektor `CVSS:4.0` | Menghitung skor satu vektor. Ulangi untuk menghitung beberapa, satu baris per vektor, sesuai urutan. | | `--explain` | | Menambahkan penjelasan setiap metrik dalam bahasa sederhana di bawah setiap baris penilaian. | Minimal satu `--vector` wajib diberikan. Vektor tidak pernah diberikan sebagai argumen posisional polos, jadi tidak bisa dikira sebuah flag. **Kenapa nilai flag** Setiap vektor diberikan sebagai nilai flag, tidak pernah disisipkan ke dalam perintah. Nilai yang berisi tanda kutip atau backtick tetap tidak berbahaya dan tidak bisa melakukan injeksi ke shell. Selalu apit vektornya dengan tanda kutip tunggal agar shell Anda tidak mengekspansinya lebih dulu. **Yang tidak dicakup** Hanya CVSS v4.0: vektor v2.0, v3.0, atau v3.1 ditolak alih-alih dihitung, karena **Lagune** memberi skor setiap temuan dalam v4.0. **Tips** Validasi di fase plan menjalankan ulang aritmetika yang sama di setiap baris CVSS, jadi skor yang menyimpang dari vektornya ketahuan sebelum rencana diterima. ## Pertanyaan yang sering diajukan ### Bagaimana Lagune menghitung skor CVSS? Hook cvss mengikuti kalkulator referensi FIRST untuk CVSS v4.0, jadi skor sebuah vektor sama persis dengan skornya di situs FIRST. ### Apakah saya bisa menghitung skor vektor CVSS v3.1 dengannya? Tidak. Lagune memberi skor setiap temuan dalam CVSS v4.0, dan hook ini menolak versi lain alih-alih menghitungnya. ### Apa fungsi flag --explain? Flag ini menjelaskan setiap metrik dalam bahasa sederhana dan menampilkan skor Base di samping skor keseluruhan, sehingga siapa pun bisa melihat apa arti vektornya dan bagaimana konteks proyek mengubahnya. --- # Hook infra: deteksi miskonfigurasi IaC > Pindai Terraform, Dockerfile, dan GitHub Actions untuk menemukan miskonfigurasi, atau nilai satu potongan kode, langsung dari command line. Kanonis: https://lagune.ai/id-ID/docs/hooks/infra Bahasa: id-ID Asli: https://lagune.ai/docs/hooks/infra Terakhir diperbarui: 2026-11-06 Hook `infra` menandai **miskonfigurasi infrastructure as code** yang bisa dipastikan dari file-nya saja: jaringan yang terbuka untuk seluruh dunia, izin wildcard, secret di dalam manifest, container yang berjalan sebagai root, nilai tidak tepercaya di shell CI. Hook ini hanya membaca file IaC (`.tf`/`.tf.json`/`.hcl`, `Dockerfile*`, `.github/workflows/**`). Hook ini adalah engine deterministik di balik [spesialisasi `infra`](https://lagune.ai/id-ID/docs/catalog), dalam mode **scan** atau **check**. ## Menjalankan **Pindai basis kode** ```bash npx lagune read infra # scans every IaC file npx lagune read infra --dir infra # scans a directory npx lagune read infra --file Dockerfile # scans a single file ``` **Periksa potongan kode** Berikan potongan kode dengan `--pattern` dan jenisnya dengan `--kind` (`terraform`, `dockerfile`, atau `github-actions`). ```bash npx lagune read infra --kind terraform --pattern 'actions = ["*"]' # => iam-wildcard npx lagune read infra --kind dockerfile --pattern 'FROM node:20' # => mutable-tag ``` Pemindaian mencetak hingga dua bagian. **Infrastructure risks found** keluar dengan kode bukan nol dan berisi cacat yang bisa dipastikan (ingress `0.0.0.0/0` di port sensitif, pernyataan IAM wildcard, secret di manifest, `encrypted = false`, modul git yang versinya tidak dikunci, image yang secara eksplisit berjalan sebagai root, `curl | sh`, injeksi skrip di CI, `permissions: write-all`). **Infrastructure hardening advisories** tidak mengubah kode keluar (tag base image yang bisa berubah, action yang dikunci dengan tag). Proses yang bersih mencetak `no infrastructure risks found`. ## Cara membaca putusan Mode check mencetak tag dengan tingkat keparahan tertinggi yang cocok (misalnya `public-ingress`, `iam-wildcard`, `root-user`, `curl-pipe`, `script-injection`, `write-all`), tag peringatan (`mutable-tag`, `unpinned-action`), atau `safe`. Hanya tag dengan tingkat keparahan temuan yang keluar dengan kode bukan nol. ### Opsi CLI | Opsi | Nilai | Deskripsi | | ----------- | ----------------------------------------------- | ----------------------------------------------------------------------------------- | | `--pattern` | potongan kode | Memeriksa satu potongan kode. Memerlukan `--kind`. Ulangi untuk memeriksa beberapa. | | `--kind` | `terraform` \| `dockerfile` \| `github-actions` | Jenis yang dipakai untuk menilai potongan kode. | | `--dir` | direktori | Membatasi pemindaian ke satu direktori. Bisa diulang dan digabung dengan `--file`. | | `--file` | file | Membatasi pemindaian ke satu file. Bisa diulang dan digabung dengan `--dir`. | Tanpa opsi apa pun, hook ini memindai setiap file IaC di proyek. `--pattern` tidak bisa digabung dengan `--dir` atau `--file`. ### Pilih apa yang dipindai Hook ini melewati apa yang diabaikan **Git**. Untuk melewati lebih banyak, atau untuk memindai apa yang diabaikan **Git**, beri `infra` pengaturannya sendiri: ```bash npx lagune write add --ignore examples --checker infra ``` ```json { "checkers": { "infra": { "gitignore": false, "ignore": ["examples"] } } } ``` [Konfigurasi hook](https://lagune.ai/id-ID/docs/hooks/configure) membahas semua pengaturannya. **Tips** Hook ini menangkap kasus yang gamblang dan bisa dipastikan: enkripsi yang tidak ada, paparan `pull_request_target`, dan cakupan IAM yang tepat adalah soal penilaian yang tetap dicakup oleh [spesialisasi `infra`](https://lagune.ai/id-ID/docs/catalog). ## Pertanyaan yang sering diajukan ### File infrastruktur apa saja yang dibaca hook infra? Terraform/HCL (.tf, .tf.json, .hcl), Dockerfile, serta YAML workflow dan action GitHub Actions di bawah .github/. Hook ini menjangkau file tersebut meskipun pemindai kode sumber melewatinya. --- # Hook interpreter: tandai sink eksekusi kode dinamis > Pindai basis kode untuk menemukan sink eksekusi kode dinamis di berbagai bahasa, atau nilai satu potongan kode, langsung dari command line. Kanonis: https://lagune.ai/id-ID/docs/hooks/interpreter Bahasa: id-ID Asli: https://lagune.ai/docs/hooks/interpreter Terakhir diperbarui: 2026-11-06 Hook `interpreter` menandai **sink eksekusi kode dinamis**: konstruksi yang mengubah data menjadi kode yang dijalankan atau menyerahkannya ke shell, mulai dari `eval` hingga deserialisasi native. Hook ini mengenali bahasa dan membaca setiap file dengan aturan bahasanya sendiri. Hook ini juga engine deterministik di balik [spesialisasi `interpreter`](https://lagune.ai/id-ID/docs/catalog), yang bisa Anda jalankan sendiri dalam mode **scan** atau **check**. ## Menjalankan **Pindai basis kode** ```bash npx lagune read interpreter # scans the whole project npx lagune read interpreter --dir src # scans a directory npx lagune read interpreter --file app.py # scans a single file ``` **Periksa potongan kode** ```bash npx lagune read interpreter --lang javascript --pattern 'eval(x)' # => careful npx lagune read interpreter --lang python --pattern 'json.loads(x)' # => safe ``` Sink ini bersifat dwiguna: pemindaian statis tidak bisa memastikan apakah input yang dipengaruhi penyerang sampai ke sana, jadi setiap kecocokan adalah **peringatan untuk ditinjau**, tidak pernah temuan yang terkonfirmasi. Pemindaian mencetak satu bagian saja, **Dynamic-execution sinks to review**, yang dikelompokkan per file. Proses yang bersih mencetak `no dynamic-execution sinks found`. **Baca kode yang ditandai, jangan pernah menjalankannya!** Analisis setiap sink secara **statis**, dengan menelusuri apakah input yang tidak tepercaya sampai ke sana. Jangan pernah menjalankan atau memberikan ke `eval` kode yang ditandai, maupun kode jarak jauh atau kode yang diambil saat runtime yang dimuatnya, hanya untuk "menguji" apa yang dilakukannya. ## Cara membaca putusan | Putusan | Arti | | --------- | ------------------------------------------------------------------------------------------------------------ | | `careful` | Potongan kode berisi sink eksekusi dinamis untuk bahasanya. Tinjau dengan membacanya, jangan menjalankannya. | | `safe` | Tidak ada sink eksekusi dinamis yang ditemukan untuk bahasa yang diberikan. | ### Opsi CLI | Opsi | Nilai | Deskripsi | | ----------- | ------------- | ------------------------------------------------------------------------------------------------------ | | `--pattern` | potongan kode | Memeriksa satu potongan kode. Ulangi untuk memeriksa beberapa, satu putusan per baris. | | `--lang` | sebuah bahasa | Wajib bersama `--pattern`: javascript, python, php, ruby, java, kotlin, go, rust, c, cpp, atau csharp. | | `--dir` | direktori | Membatasi pemindaian ke satu direktori. Bisa diulang dan digabung dengan `--file`. | | `--file` | file | Membatasi pemindaian ke satu file. Bisa diulang dan digabung dengan `--dir`. | Tanpa opsi apa pun, hook ini memindai seluruh proyek. `--pattern` memerlukan `--lang` dan tidak bisa digabung dengan `--dir` atau `--file`. ### Pilih apa yang dipindai Hook ini melewati apa yang diabaikan **Git**. Untuk melewati lebih banyak, atau untuk memindai apa yang diabaikan **Git**, beri `interpreter` pengaturannya sendiri: ```bash npx lagune write add --ignore test/fixtures --checker interpreter ``` ```json { "checkers": { "interpreter": { "gitignore": false, "ignore": ["test/fixtures"] } } } ``` [Konfigurasi hook](https://lagune.ai/id-ID/docs/hooks/configure) membahas semua pengaturannya. ### Bahasa yang didukung Pemindaian membaca bahasa berikut, dikenali dari ekstensi file, dan memeriksa masing-masing terhadap kumpulan sink eksekusi dinamisnya sendiri. | # | Bahasa | Ekstensi | Sink yang ditandai | | --- | --------------------------- | ------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | 1 | **JavaScript / TypeScript** | `.js`, `.jsx`, `.mjs`, `.cjs`, `.ts`, `.tsx`, `.mts`, `.cts`, `.astro`, `.vue`, `.svelte`, `.marko`, `.riot` | `eval()`, constructor Function, `setTimeout`/`setInterval` dengan body berupa string, modul `vm`, exec dari `child_process`, `require()` dinamis, `import()` dinamis | | 2 | **Python** | `.py`, `.pyi` | `eval`/`exec`, `__import__()`, `os.system`/`os.popen`, `subprocess` dengan `shell=True`, `pickle.load`/`loads`, `yaml.load` (tidak aman) | | 3 | **Ruby** | `.rb` | keluarga eval (`instance_eval`/`class_eval`/`module_eval`/`eval`), `system`/`exec`, backtick atau `%x`, `Kernel#open` / `IO.popen`/`read`/`binread` / `Open3`, `Process.spawn`, `Marshal.load` | | 4 | **Go** | `.go` | `exec.Command`/`exec.CommandContext`, `plugin.Open` | | 5 | **PHP** | `.php` | `eval()`, `assert()` dengan string, `create_function()`, eksekusi shell (`system`/`exec`/`shell_exec`/`passthru`/`popen`/`proc_open`), `call_user_func`/`call_user_func_array`, `include`/`require` dengan path yang ditentukan saat runtime | | 6 | **Rust** | `.rs` | `Command::new`, `process::Command` | | 7 | **Java** | `.java` | `Runtime.exec`, `ProcessBuilder`, `ScriptEngine`, `ObjectInputStream.readObject` | | 8 | **Kotlin** | `.kt`, `.kts` | Sink JVM: `Runtime.exec`, `ProcessBuilder`, `ScriptEngine`, `ObjectInputStream.readObject` | | 9 | **C#** | `.cs` | `Process.Start` / `new Process`, `BinaryFormatter`, `Assembly.Load` | | 10 | **C** | `.c`, `.h` | `system()`, `popen()`, keluarga `exec*` (`execl`, `execve`, `execvp`, …) | | 11 | **C++** | `.cc`, `.cpp`, `.cxx`, `.hpp`, `.hh`, `.hxx` | `system()`, `popen()`, keluarga `exec*` (`execl`, `execve`, `execvp`, …) | **Upaya terbaik, tidak menyeluruh** Hook ini membaca kode sumber sebagai teks, jadi sink yang dirakit saat runtime, disembunyikan di balik alias, atau ditulis dalam bentuk yang tidak dikenalinya bisa lolos. Anggap tabel ini sebagai titik awal yang kuat, bukan inventaris yang lengkap. **Tips** Hook ini menjamin dasarnya (sink ini ada, dan di mana letaknya): apakah nilai yang tidak tepercaya benar-benar sampai ke salah satunya adalah soal penilaian yang dicakup oleh [spesialisasi `interpreter`](https://lagune.ai/id-ID/docs/catalog). ## Pertanyaan yang sering diajukan ### Apakah hook interpreter mengonfirmasi kerentanan? Tidak. Hook ini menandai sink eksekusi dinamis sebagai peringatan untuk ditinjau, tidak pernah sebagai temuan yang terkonfirmasi, karena pemindaian statis tidak bisa memastikan apakah input yang dipengaruhi penyerang sampai ke sink tersebut. ### Bahasa apa saja yang dicakup hook interpreter? Hook ini membaca bahasa yang ada di tabel bahasa yang didukung, dikenali dari ekstensi file, dan memeriksa masing-masing terhadap kumpulan sink-nya sendiri. Bahasa lain tidak menghasilkan sink. --- # Hook jwt: deteksi verifikasi JWT tanpa algoritma yang dikunci > Pindai basis kode untuk menemukan verifikasi JWT tanpa algoritma yang dikunci, atau nilai satu panggilan, langsung dari command line. Kanonis: https://lagune.ai/id-ID/docs/hooks/jwt Bahasa: id-ID Asli: https://lagune.ai/docs/hooks/jwt Terakhir diperbarui: 2026-11-06 Hook `jwt` menandai **verifikasi JWT tanpa algoritma yang dikunci**, celah algorithm confusion yang membuat verifier memercayai header `alg` milik token itu sendiri, serta **verifikasi yang dimatikan sepenuhnya**. Hook ini **mengenali bahasa** dan membaca setiap file sesuai pustaka JWT bahasanya. Hook ini juga engine deterministik di balik [spesialisasi `federation`](https://lagune.ai/id-ID/docs/catalog), yang bisa Anda jalankan sendiri dalam mode **scan** atau **check**. ## Menjalankan **Pindai basis kode** ```bash npx lagune read jwt # scans the whole project npx lagune read jwt --dir src # scans a directory npx lagune read jwt --file auth.ts # scans a single file ``` **Periksa satu panggilan** ```bash npx lagune read jwt --lang javascript --pattern 'jwt.verify(token, secret)' # => unpinned npx lagune read jwt --lang python --pattern 'jwt.decode(t, k, options={"verify_signature": False})' # => unpinned npx lagune read jwt --lang python --pattern 'jwt.decode(t, k, algorithms=["HS256"])' # => safe ``` Setiap baris di bawah **Unpinned JWT verification found** adalah panggilan verifikasi yang tidak menetapkan daftar izin `algorithms` (jika pustakanya memerlukannya), menerima daftar yang tidak aman (`none`, atau algoritma asimetris yang dicampur dengan HMAC), atau mematikan pengecekan tanda tangan sama sekali, sehingga panggilan itu memercayai `alg` milik token itu sendiri. Ini adalah paparan yang terkonfirmasi, jadi hook ini keluar dengan kode bukan nol. Proses yang bersih mencetak `no unpinned JWT verification found`. ## Cara membaca putusan | Putusan | Arti | | ---------- | ----------------------------------------------------------------------------------------------------------------------------------------- | | `unpinned` | Panggilan verifikasi tanpa daftar izin algoritma (jika diperlukan), dengan daftar yang tidak aman, atau dengan verifikasi yang dimatikan. | | `safe` | Panggilan verifikasi yang mengunci daftar izin algoritma yang aman, atau yang pustakanya menguncinya secara implisit. | | `invalid` | Potongan kode tidak berisi panggilan verifikasi yang bisa dikenali untuk dinilai. | ### Opsi CLI | Opsi | Nilai | Deskripsi | | ----------- | ------------- | ---------------------------------------------------------------------------------------------- | | `--pattern` | potongan kode | Memeriksa satu panggilan. Ulangi untuk memeriksa beberapa, satu putusan per baris. | | `--lang` | sebuah bahasa | Wajib bersama `--pattern`: javascript, python, go, java, kotlin, php, ruby, rust, atau csharp. | | `--dir` | direktori | Membatasi pemindaian ke satu direktori. Bisa diulang dan digabung dengan `--file`. | | `--file` | file | Membatasi pemindaian ke satu file. Bisa diulang dan digabung dengan `--dir`. | Tanpa opsi apa pun, hook ini memindai seluruh proyek. `--pattern` memerlukan `--lang` dan tidak bisa digabung dengan `--dir` atau `--file`. ### Pilih apa yang dipindai Hook ini melewati apa yang diabaikan **Git**. Untuk melewati lebih banyak, atau untuk memindai apa yang diabaikan **Git**, beri `jwt` pengaturannya sendiri: ```bash npx lagune write add --ignore test/fixtures --checker jwt ``` ```json { "checkers": { "jwt": { "gitignore": false, "ignore": ["test/fixtures"] } } } ``` [Konfigurasi hook](https://lagune.ai/id-ID/docs/hooks/configure) membahas semua pengaturannya. ### Bahasa yang didukung Pemindaian membaca pustaka berikut, dikenali dari ekstensi file. Karena sebagian pustaka mengunci algoritma secara implisit (tidak adanya daftar eksplisit tetap aman), aturan "tanpa daftar izin ⇒ unpinned" hanya berlaku jika pustakanya mengharapkan daftar eksplisit, sehingga panggilan yang dikonfigurasi dengan benar tidak pernah ditandai. | Bahasa | Pustaka | Menandai tidak adanya daftar izin sebagai unpinned? | Selalu menandai | | --------------------------- | ----------------------- | ----------------------------------------------------------------------------- | -------------------------------------------------- | | **JavaScript / TypeScript** | jsonwebtoken, jose | Ya | `none`, campuran algoritma asimetris dan HMAC | | **Python** | PyJWT, python-jose | Ya (PyJWT mewajibkannya, python-jose secara bawaan memakai `algorithms=None`) | `none`, `verify_signature: False` | | **Go** | golang-jwt | Ya (tanpa `WithValidMethods`) | `none`, `ParseUnverified` | | **Ruby** | ruby-jwt | Ya | `none`, `verify = false` | | **Java / Kotlin** | jjwt, nimbus | Tidak (diturunkan dari kunci) | `none`, parser tanpa tanda tangan atau `unsecured` | | **PHP** | firebase/php-jwt | Tidak (`Key` membawa alg-nya) | `none` | | **Rust** | jsonwebtoken | Tidak (`Validation` mewajibkan satu algoritma) | `none`, `insecure_disable_signature_validation` | | **C#** | Microsoft.IdentityModel | Tidak (parameternya ditulis dalam beberapa baris) | `none`, `RequireSignedTokens = false` | **Tips** Hook ini hanya memutuskan soal penguncian algoritma: pengecekan claim, kunci, dan alur adalah soal penilaian yang tetap dicakup oleh [spesialisasi `federation`](https://lagune.ai/id-ID/docs/catalog). ## Pertanyaan yang sering diajukan ### Apa itu algorithm confusion pada JWT? Verifier yang membaca algoritma dari header token memungkinkan penyerang menukar RS256 dengan HS256 lalu menandatangani token dengan kunci publik. Mengunci daftar izin algoritma yang aman di dalam kode mencegahnya, dan hook jwt menandai panggilan verifikasi yang tidak menetapkan daftar itu atau menetapkan daftar yang tidak aman. --- # Hook network: nilai URL terhadap SSRF > Nilai satu atau beberapa tujuan request terhadap SSRF, langsung dari command line. Kanonis: https://lagune.ai/id-ID/docs/hooks/network Bahasa: id-ID Asli: https://lagune.ai/docs/hooks/network Terakhir diperbarui: 2026-11-06 Hook `network` memutuskan apakah tujuan request dari sisi server aman dari **SSRF** (request yang bisa diarahkan ke layanan internal, metadata cloud, atau host privat). Hook ini adalah engine deterministik di balik [spesialisasi `network`](https://lagune.ai/id-ID/docs/catalog), dan Anda bisa menjalankannya sendiri. ## Menjalankan Berikan setiap tujuan dengan `--url`. Hook ini mencetak satu kata per tujuan, yang dijelaskan di tabel di bawah. **Satu tujuan** ```bash npx lagune read network --url 'http://example.com/' # => safe npx lagune read network --url 'http://0x7f000001/' # => private-target ``` **Beberapa tujuan** Ulangi `--url` untuk menilai seluruh daftar izin atau daftar blokir dalam satu panggilan, satu putusan per baris, sesuai urutan. ```bash npx lagune read network \ --url 'http://example.com/' \ --url 'http://[::1]/' \ --url 'http://allowed.com@evil.example/' # => safe # => private-target # => parser-divergent ``` Hook ini meresolusi host dengan cara yang sama seperti jaringan, sehingga bentuk terenkode dari alamat internal tidak lolos: heksadesimal, oktal, desimal tanpa titik, bentuk singkat, IPv6, dan IPv4 yang dipetakan ke IPv6 semuanya terbaca `private-target`. Dan jika validator yang ceroboh dan fetcher sebenarnya akan membaca host yang berbeda, putusannya adalah `parser-divergent`. ## Cara membaca putusan | Putusan | Arti | | ------------------ | -------------------------------------------------------------------------------------------------- | | `safe` | Tujuan terhubung ke host publik, dan validator yang ceroboh akan membaca host yang sama. | | `private-target` | Host diresolusi ke alamat privat, loopback, link-local, unspecified, atau metadata cloud. | | `parser-divergent` | Validator teks yang ceroboh akan membaca host nyata yang berbeda dari host yang dihubungi fetcher. | | `invalid url` | String tidak bisa di-parse sebagai URL, jadi tidak ada yang bisa diambil. | Hanya `safe` yang berarti diizinkan. Perlakukan `private-target`, `parser-divergent`, dan `invalid url` sebagai blokir. ### Opsi CLI | Opsi | Nilai | Deskripsi | | ------- | ------------- | ------------------------------------------------------------------------------- | | `--url` | URL atau host | Memeriksa satu tujuan. Ulangi untuk memeriksa beberapa, satu putusan per baris. | Minimal satu `--url` wajib diberikan. Tujuan tidak pernah diberikan sebagai argumen posisional polos, jadi tidak bisa dikira sebuah flag. **Kenapa nilai flag** Setiap tujuan diberikan sebagai nilai flag, tidak pernah disisipkan ke dalam perintah. Nilai yang berisi tanda kutip atau backtick tetap tidak berbahaya dan tidak bisa melakukan injeksi ke shell. Selalu apit nilainya dengan tanda kutip tunggal agar shell Anda tidak mengekspansinya lebih dulu. **Yang tidak dicakup** Hook ini murni dan tidak pernah meresolusi DNS, jadi dua celah saat runtime berada di luar cakupan: **DNS rebinding** (nama yang diresolusi ke alamat publik saat diperiksa, tetapi ke alamat internal saat diambil) dan **rantai redirect** (lompatan pertama yang lolos, lalu dialihkan ke dalam). Tutup celah itu dengan meresolusi nama sekali saja lalu terhubung ke alamat yang sudah divalidasi, serta dengan menolak redirect. Hook ini langsung menetapkan nama loopback yang dicadangkan (`localhost` dan keluarga `.localhost`) sebagai internal tanpa lookup, tetapi nama DNS lainnya terbaca `safe`, karena memastikan nama itu diresolusi ke dalam memerlukan resolusi: daftar izin yang menjaga nama tersebut, dan daftar izin itulah yang divalidasi checker ini. **Tips** Ini adalah pengecekan yang sama dengan yang dijalankan [spesialisasi `network`](https://lagune.ai/id-ID/docs/catalog) untuk membuktikan bahwa filter tujuan tetap efektif. ## Pertanyaan yang sering diajukan ### Bagaimana cara menguji URL terhadap SSRF? Jalankan hook network. Hook ini menilai tujuan request dan mengembalikan safe, private-target, parser-divergent, atau invalid url. Hanya safe yang berarti diizinkan. ### Apa itu URL parser-divergent? URL yang dibaca secara berbeda oleh parser yang berbeda, yang merupakan cara klasik untuk menembus perlindungan SSRF. Hook network menandainya alih-alih mengizinkannya. --- # Hook regex: deteksi pola ReDoS > Pindai basis kode untuk mencari regex yang rawan ReDoS, atau beri skor satu pola, langsung dari command line. Kanonis: https://lagune.ai/id-ID/docs/hooks/regex Bahasa: id-ID Asli: https://lagune.ai/docs/hooks/regex Terakhir diperbarui: 2026-11-06 Hook `regex` adalah engine keamanan regex deterministik yang dijalankan [spesialisasi `regex`](https://lagune.ai/id-ID/docs/catalog), dan Anda juga bisa menjalankannya sendiri. Hook ini bekerja dalam dua mode dari satu perintah: **scan** yang memindai basis kode untuk mencari pola yang rawan **ReDoS** dan pola yang dibangun saat runtime, serta **check** yang memberi skor satu pola yang Anda berikan. ## Memindai basis kode Tanpa flag, hook ini memindai seluruh proyek. `--dir` membatasi pemindaian ke satu direktori, `--file` ke satu file. Keduanya bisa diulang dan digabung menjadi satu laporan, dengan setiap file dicantumkan sekali meski tercakup oleh lebih dari satu target. **Seluruh proyek** ```bash npx lagune read regex ``` **Satu direktori** ```bash npx lagune read regex --dir src/services ``` **Satu file** ```bash npx lagune read regex --file bin/import.pl ``` **Beberapa target** ```bash npx lagune read regex --dir core --dir workers --file Sources/App/Router.swift ``` **Dengan batas** `--limit` menetapkan ambang ReDoS untuk pemindaian (default 25), batas yang sama yang diterima mode check. Batas yang lebih rendah lebih ketat. ```bash npx lagune read regex --dir src/services --limit 15 ``` Output-nya berupa teks mentah, dan header-nya menjelaskan cara membaca tiap bagian. Sebuah bagian hanya ditampilkan jika ada temuan. ```text Vulnerable regular expressions found: cmd/server/main.go ([a-z]+)+$ (exponential, search) Dynamically built regular expressions (review manually by simulating a constructed regex): app/payments.php crates/parser/lexer.rs lib/validate.py Static regex wrapped in a constructor (use a literal instead): config/token.rb ``` Jika tidak ada yang ditemukan, hook ini mencetak satu baris. ```bash npx lagune read regex --dir src/clean # => no unsafe patterns found ``` ### Cara membaca tiap bagian | Bagian | Arti | | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `Vulnerable regular expressions found` | Pola yang rawan ReDoS, dikelompokkan per file dengan setiap pola menjorok di bawahnya, diikuti dalam tanda kurung oleh alasan pola itu tidak aman serta, jika ada, cakupan dan flag-nya. Setiap baris tidak aman, jadi putusannya tidak diulang. | | `Regular expressions the analysis could not settle (review manually)` | Pola yang tidak bisa dipastikan oleh analisis dalam batas kerjanya, dicantumkan dengan cara yang sama. | | `Dynamically built regular expressions (review manually by simulating a constructed regex)` | File yang membangun regex dari variabel, konkatenasi, atau interpolasi. | | `Static regex wrapped in a constructor (use a literal instead)` | File yang meneruskan string literal biasa ke konstruktor regex, padahal literal regex lebih sederhana dan tidak perlu dikompilasi saat runtime. | Bagian pertama adalah temuan keamanan. Bagian kedua dan ketiga bukan temuan dengan sendirinya: keduanya menunjuk kode yang tidak bisa dipastikan oleh pemeriksaan statis, jadi perlu dibaca manusia. Bagian keempat adalah petunjuk kejelasan, bukan temuan keamanan. ### Opsi CLI | Opsi | Nilai | Deskripsi | | ----------- | -------------------------- | ---------------------------------------------------------------------------------------------------------- | | `--pattern` | sumber regex | Periksa satu pola. Ulangi untuk memeriksa beberapa pola, satu putusan per pola, sesuai urutan. | | `--flags` | flag regex | Periksa setiap `--pattern` dengan flag ini, seperti `im`. Hanya berlaku untuk mode check. | | `--dir` | direktori | Batasi pemindaian ke satu direktori. Bisa diulang dan digabung dengan `--file`. | | `--file` | file | Batasi pemindaian ke satu file. Bisa diulang dan digabung dengan `--dir`. | | `--limit` | bilangan bulat non-negatif | Tetapkan batas repetisi ReDoS (default 25). Berlaku untuk kedua mode. Batas yang lebih rendah lebih ketat. | Tanpa opsi, hook ini memindai seluruh proyek. `--pattern` adalah mode check dan tidak bisa digabung dengan `--dir` atau `--file`. ### Pilih yang dipindai Hook ini melewati apa yang diabaikan **Git**. Untuk melewati lebih banyak, atau untuk memindai apa yang diabaikan **Git**, beri `regex` pengaturannya sendiri: ```bash npx lagune write add --ignore test/fixtures --checker regex ``` ```json { "checkers": { "regex": { "gitignore": false, "ignore": ["test/fixtures"] } } } ``` Semua pengaturan dibahas di [Mengonfigurasi hook](https://lagune.ai/id-ID/docs/hooks/configure). ### Bahasa yang didukung Pemindaian membaca bahasa berikut, dikenali dari ekstensi file, masing-masing dengan aturannya sendiri sehingga pola dari satu bahasa tidak pernah diuji dengan aturan bahasa lain. Bahasa lain dilewati, bukan dipindai dengan aturan yang salah. | # | Bahasa | Ekstensi | | --- | --------------------------- | ------------------------------------------------------------------------------------------------------------ | | 1 | **JavaScript / TypeScript** | `.js`, `.jsx`, `.mjs`, `.cjs`, `.ts`, `.tsx`, `.mts`, `.cts`, `.astro`, `.vue`, `.svelte`, `.marko`, `.riot` | | 2 | **Python** | `.py`, `.pyi` | | 3 | **Ruby** | `.rb` | | 4 | **Go** | `.go` | | 5 | **PHP** | `.php` | | 6 | **Rust** | `.rs` | | 7 | **Java** | `.java` | | 8 | **C#** | `.cs` | | 9 | **C** | `.c`, `.h` | | 10 | **C++** | `.cc`, `.cpp`, `.cxx`, `.hpp`, `.hh`, `.hxx` | | 11 | **Kotlin** | `.kt`, `.kts` | | 12 | **Swift** | `.swift` | | 13 | **Scala** | `.scala`, `.sc` | | 14 | **Dart** | `.dart` | | 15 | **PowerShell** | `.ps1`, `.psm1`, `.psd1` | | 16 | **Elixir** | `.ex`, `.exs` | | 17 | **Objective-C** | `.m`, `.mm` | | 18 | **R** | `.r` | | 19 | **Julia** | `.jl` | | 20 | **Clojure** | `.clj`, `.cljs`, `.cljc`, `.edn` | | 21 | **Crystal** | `.cr` | | 22 | **Nim** | `.nim`, `.nims` | | 23 | **V** | `.v` | | 24 | **D** | `.d` | | 25 | **Perl** | `.pl`, `.pm` | **Upaya terbaik, tidak menyeluruh** Hook ini membaca kode sumber sebagai teks, sehingga tidak bisa menilai pola yang dirakit saat runtime, dan pola yang tersebar di beberapa baris, tersembunyi di balik alias, atau ditulis dalam bentuk yang tidak dikenalinya bisa lolos. Anggap bagian-bagian ini sebagai titik awal yang kuat, bukan inventaris lengkap, dan tetap baca kodenya untuk hal yang tidak terjangkau olehnya. ## Memeriksa satu pola Berikan `--pattern` dengan sumber pola untuk memberinya skor. Hook ini mencetak satu kata: `safe`, `unsafe`, `undetermined` jika analisis mencapai batas kerjanya sebelum bisa memastikan pola, atau `invalid regex`. Ulangi `--pattern` untuk memberi skor beberapa pola sekaligus, satu putusan per pola, sesuai urutan. **Satu pola** ```bash npx lagune read regex --pattern '(a+)+$' # => unsafe npx lagune read regex --pattern '^[a-z0-9_]{3,20}$' # => safe ``` **Beberapa pola** ```bash npx lagune read regex --pattern '(a+)+$' --pattern '^[a-z]+$' # => unsafe # => safe ``` **Dengan flag** `--flags` memeriksa setiap `--pattern` dalam pemanggilan itu dengan flag yang dipakainya saat berjalan, karena flag mengubah karakter mana yang dicocokkan sebuah pola. ```bash npx lagune read regex --pattern '^(?:a|A)+$' # => safe npx lagune read regex --pattern '^(?:a|A)+$' --flags 'i' # => unsafe ``` **Dengan batas** `--limit` menetapkan batas repetisi (default 25) dan berlaku untuk setiap `--pattern` dalam pemanggilan itu. Batas yang lebih rendah lebih ketat. ```bash npx lagune read regex --pattern 'a?a?a?' --limit 2 # => unsafe ``` **Mengapa argumen diberi tanda kutip** Setiap pola diteruskan sebagai nilai flag, tidak pernah disisipkan ke dalam perintah. Nilai yang berisi tanda kutip atau backtick tetap tidak berbahaya dan tidak bisa melakukan injeksi ke shell. Selalu apit pola dengan tanda kutip tunggal agar shell Anda tidak mengekspansinya lebih dulu. **Tips** Ini adalah engine yang sama yang dijalankan [spesialisasi `regex`](https://lagune.ai/id-ID/docs/catalog): scan membuka pemeriksaan ReDoS, dan check memastikan pola yang ditemukannya. ## Pertanyaan yang sering diajukan ### Bagaimana cara memeriksa regex terhadap ReDoS dari CLI? Jalankan npx lagune read regex --pattern ''. Hasilnya safe, unsafe, undetermined, atau invalid regex. ### Bagaimana cara memindai seluruh proyek untuk mencari regex yang tidak aman? Jalankan hook regex dalam mode scan di seluruh basis kode. Hook ini melaporkan pola yang rawan ReDoS di 25 bahasa yang didukung. --- # Hook secrets: deteksi secret yang hardcoded > Pindai basis kode untuk menemukan kredensial yang hardcoded, langsung dari command line. Kanonis: https://lagune.ai/id-ID/docs/hooks/secrets Bahasa: id-ID Asli: https://lagune.ai/docs/hooks/secrets Terakhir diperbarui: 2026-11-06 Hook `secrets` menandai **kredensial yang tertanam di kode sumber** alih-alih dibaca dari environment. Hook ini berpatokan pada **asal-usul nilainya** (literal atau pembacaan dari environment), bukan pada isi nilainya, sehingga tidak memerlukan katalog lengkap prefiks penyedia layanan dan hampir tidak menghasilkan positif palsu. Hook ini adalah engine deterministik di balik [spesialisasi `secrets`](https://lagune.ai/id-ID/docs/catalog). Signature format penyedia layanan, kredensial di connection string, dan literal yang diberikan ke identifier bernama secret bersifat **tidak bergantung pada bahasa**: string yang sama terbaca sama di file mana pun. Dua heuristik yang bergantung pada sintaksis, yaitu pembacaan environment dengan nilai default yang hardcoded dan secret yang mengalir ke sink log, **mengenali bahasa**, sehingga `console.log` JavaScript tidak pernah dicari di file Rust dan `os.getenv("X", "default")` milik Python dikenali tersendiri. ## Menjalankan ```bash npx lagune read secrets # scans the whole project npx lagune read secrets --dir src # scans a directory npx lagune read secrets --file config.ts # scans a single file ``` Pemindaian mencetak hingga dua bagian. **Hardcoded secrets found** berisi temuan (nilai default yang hardcoded untuk variabel environment bernama secret, kredensial yang tertanam di connection string, atau nilai yang cocok dengan format penyedia layanan yang terkurasi), jadi hook ini keluar dengan kode bukan nol. **Secret handling to review manually** berisi petunjuk: literal biasa yang diberikan ke identifier bernama secret (asal-usulnya bisa dipastikan, tetapi apakah nilainya secret sungguhan tidak bisa), dan nilai bernama secret yang mengalir ke sink log atau response. Proses yang bersih mencetak `no hardcoded secrets found`. ### Opsi CLI | Opsi | Nilai | Deskripsi | | -------- | --------- | ---------------------------------------------------------------------------------- | | `--dir` | direktori | Membatasi pemindaian ke satu direktori. Bisa diulang dan digabung dengan `--file`. | | `--file` | file | Membatasi pemindaian ke satu file. Bisa diulang dan digabung dengan `--dir`. | Tanpa opsi apa pun, hook ini memindai seluruh proyek. ### Pilih apa yang dipindai Hook ini melewati apa yang diabaikan **Git**. Untuk melewati lebih banyak, atau untuk memindai apa yang diabaikan **Git**, beri `secrets` pengaturannya sendiri: ```bash npx lagune write add --ignore test/fixtures --checker secrets ``` ```json { "checkers": { "secrets": { "gitignore": false, "ignore": ["test/fixtures"] } } } ``` [Konfigurasi hook](https://lagune.ai/id-ID/docs/hooks/configure) membahas semua pengaturannya. ### Cakupan bahasa Temuan default environment dan petunjuk sink log membaca kumpulan bentuk yang berbeda untuk tiap bahasa, jadi keduanya mencakup bahasa di bawah ini dan diam di bahasa lain. Tiga sinyal lainnya berjalan di **setiap** file. | Sinyal | Bahasa | | ---------------------- | ------------------------------------------------------------------------------- | | Default environment | JavaScript/TypeScript, Python, Ruby, PHP, Kotlin, Java, Go (`cmp.Or`), Rust, C# | | Sink log atau response | JavaScript/TypeScript, Python, Ruby, PHP, Java, Kotlin, Go, Rust, C, C++, C# | **Apakah ini masalah kebijakan?** Tidak. Mendeteksi format secret untuk memperingatkan bahwa secret itu telah di-commit adalah praktik standar perangkat keamanan defensif, operasi yang sama dengan yang dilakukan gitleaks, trufflehog, dan push protection GitHub. Hook ini membawa signature deteksi (**format** token yang bersifat publik), tidak pernah secret sungguhan, dan hook ini mengaudit serta menjelaskan alih-alih mengeksfiltrasi. ## Pertanyaan yang sering diajukan ### Bagaimana hook secrets menghindari positif palsu? Hook ini berpatokan pada asal-usul nilai, bukan pada isinya. Format dengan tingkat keyakinan tinggi (token penyedia layanan, fallback environment, connection string) adalah temuan yang keluar dengan kode bukan nol. Literal biasa yang diberikan ke identifier bernama secret adalah petunjuk untuk ditinjau dan dikonfirmasi, dan identifier yang sama yang dibaca dari process.env sama sekali tidak ditandai. --- # Contoh prompt Lagune: otomatiskan alur Blue Team > Prompt Lagune siap salin: pemindaian read-only, alur Blue Team lengkap, dan audit Zero Trust, ditambah deteksi yang cakupannya dibatasi pada sebuah commit, diff branch atau PR, atau insiden nyata. Kanonis: https://lagune.ai/id-ID/docs/examples/prompts Bahasa: id-ID Asli: https://lagune.ai/docs/examples/prompts Terakhir diperbarui: 2026-11-06 Prompt Lagune siap salin yang bisa langsung Anda tempel ke agen AI Anda. ## 💧 Pemindaian cepat Pemindaian read-only yang membaca kode secara mandiri dan melaporkan setiap celah beserta perbaikannya, tanpa menjalankan alur Blue Team dan tanpa menulis apa pun ke pelacakan Lagune. **Tips** Hasilnya lebih baik dalam mode perencanaan dan jika charter (`/lagune-charter`) sudah ditetapkan. **🪼 Standar** | Aspek | Trade-off | Level | | -------------------- | ------------------------------------------------------------------------------- | ------------------- | | **Upaya** | Satu agen memindai dan melapor, tanpa subagen. | 1/5 | | **Waktu** | Cepat. Satu kali proses read-only, tidak ada yang diterapkan. | 2/5 | | **Penggunaan token** | Sedang, dengan konteks bersama. Seluruh pemindaian berjalan dalam satu konteks. | 2/5 | ```md /lagune Kamu adalah peneliti keamanan siber dengan keahlian mendalam di bidang keamanan defensif, yang memakai Lagune untuk meningkatkan pengetahuan dan ketelitianmu. Pindai workspace secara mandiri dan pasangkan setiap celah yang kamu temukan dengan perbaikan yang konkret. Ini pemindaian tersendiri, bukan alur Blue Team: jangan jalankan detect, plan, harden, atau verify, dan jangan menulis apa pun ke pelacakan Lagune. Di akhir, buat daftar semua celah yang kamu temukan, masing-masing dengan tingkat keparahan dan perbaikan konkretnya. ``` **🐬 Multi-agen** | Aspek | Trade-off | Level | | -------------------- | ---------------------------------------------------------------------------------- | ------------------- | | **Upaya** | Satu subagen per file, disesuaikan dengan ukuran basis kode Anda. | 2/5 | | **Waktu** | Paralel per file, lalu digabung menjadi satu laporan. Tetap read-only. | 3/5 | | **Penggunaan token** | Lebih tinggi, tetapi terisolasi. Setiap subagen memindai dalam konteksnya sendiri. | 3/5 | ````md /lagune Kamu adalah orkestrator keamanan siber yang memakai Lagune untuk mendata path, mengirim satu subagen per path, dan menggabungkan laporan mereka (semua konten dibaca oleh subagen). Kamu harus mendelegasikan tugas ke subagen sesuai ukuran proyek saat ini: makin besar basis kodenya, makin banyak subagen yang harus dikirim, semuanya secara paralel, dan berikan prompt di bawah ini kepada masing-masing: ```prompt /lagune Kamu adalah peneliti keamanan siber dengan keahlian mendalam di bidang keamanan defensif, yang memakai Lagune untuk meningkatkan pengetahuan dan ketelitianmu. Pindai secara mandiri dan pasangkan setiap celah yang kamu temukan dengan perbaikan yang konkret. Ini pemindaian tersendiri, bukan alur Blue Team: jangan jalankan detect, plan, harden, atau verify, dan jangan menulis apa pun ke pelacakan Lagune. Di akhir, buat daftar semua celah di , masing-masing dengan tingkat keparahan dan perbaikan konkretnya. ``` Di akhir, gabungkan semua laporan subagen menjadi satu daftar celah dan perbaikan yang diurutkan berdasarkan prioritas. ```` **Peringatan** Pemindaian cepat adalah satu prompt yang luas dan tanpa cakupan, sehingga sebagian agen lebih mungkin menolaknya atau menghentikannya di tengah jalan. Jika agen Anda menolak, jalankan **alur Blue Team** lengkap di bawah ini sebagai gantinya: fasenya yang terbatas cakupannya dan berjalan langkah demi langkah jauh lebih jarang diblokir. --- ## 🌊 Audit Blue Team otomatis Menjalankan [alur perintah lengkap](https://lagune.ai/id-ID/docs/get-started/commands) dari awal sampai akhir. **🪼 Standar** | Aspek | Trade-off | Level | | -------------------- | ---------------------------------------------------------------------------------------------------------------------- | ------------------- | | **Upaya** | Satu agen, tanpa subagen, berapa pun ukuran basis kodenya. | 3/5 | | **Waktu** | Sedang, tetapi kurang menyeluruh di basis kode besar. Setiap perintah berjalan sekali, satu per satu secara berurutan. | 4/5 | | **Penggunaan token** | Lebih rendah, tetapi kurang terisolasi. Semua perintah berbagi konteks yang sama. | 4/5 | ```md Jalankan perintah berikut satu per satu: `/lagune-charter`, `/lagune-detect`, `/lagune-plan`, `/lagune-harden`, dan `/lagune-verify`. ## Loop Jika `/lagune-verify` menolak satu atau beberapa perbaikan, ulangi `/lagune-harden` lalu `/lagune-verify` sampai semua temuan benar-benar terselesaikan. ``` **🐋 Multi-agen (deep scan)** | Aspek | Trade-off | Level | | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | ------------------- | | **Upaya** | Jumlah subagen disesuaikan dengan ukuran basis kode Anda. | 5/5 | | **Waktu** | Lebih lama, tetapi lebih menyeluruh. Mengirim banyak subagen untuk mendeteksi, merencanakan, dan memperkuat keamanan temuan secara paralel. | 5/5 | | **Penggunaan token** | Lebih tinggi, tetapi lebih aman. Setiap subagen punya konteks terisolasinya sendiri tanpa bias. | 5/5 | ````md Jalankan setiap perintah berikut di satu subagen, satu per satu (tanpa backtick, hanya perintahnya): Prompt subagen 1: `/lagune-charter` Prompt subagen 2: `/lagune-detect` Prompt subagen 3: `/lagune-plan` Prompt subagen 4: `/lagune-harden` Prompt subagen 5: `/lagune-verify` Di perintah `/lagune-detect`, `/lagune-plan`, `/lagune-harden`, dan `/lagune-verify`, kamu harus mendelegasikan tugas ke subagen sesuai ukuran proyek saat ini: makin besar basis kodenya, makin banyak subagen yang harus dikirim. Contohnya: ```prompt /lagune-detect ``` ```prompt /lagune-plan ``` ```prompt /lagune-harden ``` ```prompt /lagune-verify ``` - Beberapa agen pada perintah yang sama harus dikirim secara paralel. - Setelah semua subagen `/lagune-detect` selesai, jalankan: ```prompt /lagune-detect gabungkan temuan yang setara. Jangan mencari temuan baru dan jangan memindai basis kode lagi. ``` ## Loop Jika `/lagune-verify` menolak satu atau beberapa perbaikan, ulangi `/lagune-harden` lalu `/lagune-verify` sampai semua temuan benar-benar terselesaikan. ```` --- ## 🪄 Deteksi dengan cakupan terbatas Arahkan perintah [`/lagune-detect`](https://lagune.ai/id-ID/docs/commands/detect) ke sebagian proyek Anda, bukan ke seluruh proyek. Jelaskan cakupannya dengan bahasa sehari-hari (sebuah commit, pull request, atau situasi nyata), dan perintah ini hanya memetakan temuan yang relevan dengan keamanan di bagian tersebut. **Tips** Semua yang terdeteksi di sini adalah temuan biasa, jadi Anda bisa langsung membawanya ke `/lagune-plan`, `/lagune-harden`, dan `/lagune-verify`, dengan cakupan hanya pada item tersebut. **📌 Sejak sebuah commit** Jalankan pemeriksaan keamanan khusus untuk sekumpulan commit terbaru, hanya pada apa yang diubah commit tersebut, misalnya: ```prompt /lagune-detect Batasi deteksi pada semua yang berubah sejak commit `a1b2c3d`. ``` **🔀 Diff branch atau PR** Tinjau keamanan pull request sebelum di-merge, hanya pada diff-nya, misalnya: ```prompt /lagune-detect Batasi deteksi pada perubahan yang dibawa branch ini dibandingkan dengan `main`. ``` **⛑️ Setelah insiden** Ceritakan apa yang terjadi dengan kata-kata Anda sendiri. Lagune membaca situasinya, bukan sebuah flag, lalu mengubahnya menjadi penelusuran yang terfokus, misalnya: ```prompt /lagune-detect Situs kami mengalami kebocoran data beberapa minggu lalu. Saya tidak tahu persis bagaimana itu terjadi, dan saya khawatir masih ada celah terbuka yang bisa membocorkan data lagi. Telusuri kodenya dengan teliti, fokus di setiap tempat data sensitif dibaca, disimpan, atau diekspos, dan petakan apa pun yang masih bisa menjadi jalan keluar bagi data. Anggap ini insiden sungguhan, bukan latihan. ``` --- ## 🚨 Audit Zero Trust Memperlakukan seluruh workspace dan setiap dependensi sebagai sesuatu yang berbahaya: audit ini memburu interpreter, panggilan jaringan, payload yang di-encode, dan kode yang disembunyikan di tempat tak terduga agar lolos dari pemindai, lalu diakhiri dengan putusan go/no-go tentang apakah proyek tersebut aman digunakan. Prompt berikut langsung memuat spesialisasi yang diandalkan audit ini, apa pun kategori proyek Anda. Untuk bagian katalog lainnya yang dicocokkan `/lagune`, pastikan proyek memakai **OWASP**, **AI/LLM**, dan kategori stack-nya (misalnya **JavaScript**, **Python**, dan lainnya): ```bash npx lagune write add --categories owasp ai javascript ``` File `.gitignore` dan konfigurasi milik repositori itu sendiri bisa menyembunyikan file dari checker, jadi atur blok `checkers` di `.lagune/configs.json` untuk [memindai semuanya](https://lagune.ai/id-ID/docs/hooks/configure), menggantikan blok apa pun yang dibawa repositori: ```json { "checkers": { "gitignore": false } } ``` **Bahaya** Hati-hati saat menjalankan proyek dari sumber yang tidak tepercaya di lingkungan lokal Anda. Gunakan lingkungan terisolasi, seperti **sandbox** (disarankan), **VM**, atau sejenisnya, agar kode berbahaya tidak memengaruhi sistem Anda. **🪼 Standar** | Aspek | Trade-off | Level | | -------------------- | --------------------------------------------------------------------------------------------------- | ------------------- | | **Upaya** | Satu agen memindai seluruh workspace, tanpa subagen. | 2/5 | | **Waktu** | Sedang. Satu agen menelusuri kode dan dependensinya secara berurutan. | 3/5 | | **Penggunaan token** | Sedang, tetapi berbagi konteks. Spesialisasi, kode, dan dependensi semuanya dimuat ke satu konteks. | 3/5 | ```md /lagune Kamu adalah peneliti keamanan siber dengan keahlian mendalam di bidang keamanan defensif zero trust, yang memakai Lagune untuk meningkatkan pengetahuan dan ketelitianmu. Petakan seluruh workspace sebagai sumber yang tidak tepercaya dan cakupan yang berpotensi berbahaya. Setiap interpreter, fetch, base64, dan sejenisnya harus diperlakukan sebagai potensi ancaman. Perluas analisismu ke dependensi dan sub-dependensi: sebuah proyek bisa saja mencoba menyembunyikan kode berbahaya di tempat yang tak terduga agar lolos dari pemindai. Spesialisasi wajib (muat satu per satu dengan `npx lagune read catalog `): - interpreter - secrets - llm - path Supaya jelas: setiap kerentanan yang terpetakan harus diperlakukan sebagai potensi ancaman, tanpa kecuali. Di akhir, berikan putusan apakah proyek ini aman dan tepercaya untuk saya gunakan atau tidak. ``` **🐋 Multi-agen (deep scan)** | Aspek | Trade-off | Level | | -------------------- | ------------------------------------------------------------------------------------------------------- | ------------------- | | **Upaya** | Satu subagen per file, disesuaikan dengan ukuran basis kode Anda. | 5/5 | | **Waktu** | Lebih lama, tetapi lebih menyeluruh. File dipindai secara paralel, lalu digabung menjadi satu putusan. | 4/5 | | **Penggunaan token** | Tertinggi, tetapi paling aman. Setiap subagen membaca spesialisasi dalam konteks terisolasinya sendiri. | 5/5 | ````md /lagune Kamu adalah orkestrator keamanan siber yang memakai Lagune untuk mendata file, mengirim satu subagen per file, dan membuat laporan (semua konten dibaca oleh subagen). Kirim satu subagen per file, semuanya secara paralel, dan berikan prompt di bawah ini kepada masing-masing, dengan cakupan pada file masing-masing: ```prompt /lagune Kamu adalah peneliti keamanan siber dengan keahlian mendalam di bidang keamanan defensif zero trust, yang memakai Lagune untuk meningkatkan pengetahuan dan ketelitianmu. Perlakukan sebagai sumber yang tidak tepercaya dan cakupan yang berpotensi berbahaya. Setiap interpreter, fetch, base64, dan sejenisnya harus diperlakukan sebagai potensi ancaman. Perluas analisis ke apa pun yang diimpor , termasuk dependensi dan sub-dependensi, tempat kode berbahaya bisa bersembunyi agar lolos dari pemindai. Spesialisasi wajib untuk setiap subagen (muat satu per satu dengan `npx lagune read catalog `): - interpreter - secrets - llm - path Supaya jelas: setiap kerentanan yang terpetakan harus diperlakukan sebagai potensi ancaman, tanpa kecuali. Di akhir, berikan putusan apakah proyek ini aman dan tepercaya untuk saya gunakan atau tidak. ``` Di akhir, gabungkan semua laporan subagen menjadi satu putusan akhir. ```` --- # Security-Driven Hardening: konvensi untuk era pengembangan berbantuan AI > Metodologi Security-Driven Hardening (SDH): konvensi Blue Team yang peka konteks untuk mengaudit dan memperkuat keamanan perangkat lunak yang dibuat dengan bantuan AI dan vibe coding. Kanonis: https://lagune.ai/id-ID/docs/references/paper Bahasa: id-ID Asli: https://lagune.ai/docs/references/paper Terakhir diperbarui: 2026-11-06 - **Weslley Araújo** - **Makalah metodologi, 2026.** --- ## Abstrak Security-Driven Hardening (SDH) adalah metodologi keamanan yang terstruktur, digerakkan oleh AI, dan khusus pertahanan, untuk era ketika perangkat lunak makin banyak ditulis oleh agen AI dan oleh orang yang bukan spesialis keamanan. Alih-alih menjalankan daftar periksa generik, SDH lebih dulu mendeteksi apa yang sebenarnya dilakukan sebuah sistem (login, unggahan file, pembayaran, paparan data, dan sebagainya), lalu menggerakkan pekerjaan keamanan yang spesifik untuk konteks itu. SDH diatur oleh prinsip aman secara bawaan, sepenuhnya berorientasi pada pertahanan, dan disampaikan dalam bahasa sederhana sehingga pengguna mana pun bisa menindaklanjutinya. Dokumen ini berargumen bahwa SDH adalah konvensi yang selama ini belum ada, bukan sekadar satu alat. Pengetahuan keamanan berada di dalam metodologi dan spesialisasinya yang dimuat hanya saat dibutuhkan, sebuah fondasi yang bisa dikembangkan setiap pengguna, sehingga pemula dan pakar bisa dilayani lewat alur yang sama. Dua sifat membedakannya dari pendekatan spec-first sebelumnya `[1]`. SDH **independen terhadap kondisi**: SDH menyesuaikan diri dengan direktori kosong, proyek yang sedang berjalan, satu pull request, maupun basis kode lama yang besar, di stack apa pun. Dan SDH **bisa dituntaskan**: risiko yang terverifikasi tertutup akan ditutup dari seluruh alur, sehingga temuan itu mencapai kondisi tuntas dan baru dibuka kembali saat kode berubah. SDH tidak menggantikan profesional keamanan atau tool Blue Team khusus. SDH memperluas pengetahuan developer itu sendiri, dan makin paham seorang developer tentang keamanan, makin jauh ia bisa mengarahkannya. **Lagune** adalah implementasi referensinya, dan membuktikan bahwa metodologi ini bisa dibangun dan dibawa ke lingkungan lain. SDH ditawarkan sebagai konvensi yang bisa diadopsi pihak lain. > **Kata kunci** > > Pengembangan berbantuan AI, keamanan perangkat lunak, keamanan defensif, spec-driven development, hardening keamanan, alur kerja yang digerakkan agen, ketertuntasan, keamanan peka konteks, pengetahuan yang dimuat saat dibutuhkan, tool yang tidak terikat agen. --- ## I. Pendahuluan: celah keamanan yang dibuka oleh pengembangan berbantuan AI Perangkat lunak makin banyak dirilis oleh orang, dan oleh agen AI, yang tidak bisa diandalkan untuk mengenali pola yang tidak aman: secret yang bocor, pemeriksaan otorisasi yang terlewat, query yang bisa diinjeksi. Ini bukan risiko yang langka. Semuanya termasuk kelas risiko yang mendominasi insiden nyata, terdokumentasi selama bertahun-tahun dalam referensi publik `[6]`, `[7]`, dan studi terbaru melaporkan bahwa porsi yang cukup berarti dari kode buatan AI dirilis dengan cacat seperti itu `[8]`. Asisten coding AI memperparahnya dengan memungkinkan orang yang bukan developer merilis perangkat lunak sungguhan, tetapi celahnya lebih luas daripada satu kelompok pengguna mana pun. Sebagian besar proyek tidak pernah mendapat pemeriksaan keamanan yang spesifik untuk apa yang sebenarnya mereka lakukan. Ekosistemnya makin rapuh setiap kali keputusan prematur "sudah jalan, rilis saja" diambil. Saran keamanan generik tidak menutup celah ini. Daftar periksa statis tidak spesifik untuk apa yang dilakukan sebuah sistem, sehingga proyek kecil dibanjiri item yang tidak relevan, sementara risiko yang penting bagi proyek itu tetap terlewat. Masalahnya bukan kurangnya pengetahuan keamanan di dunia. Masalahnya adalah mencocokkan pengetahuan yang tepat dengan sistem yang benar-benar ada di hadapan pengguna, dan melakukannya untuk seseorang yang mungkin tidak tahu harus meminta apa. SDH menjawabnya dengan satu pembalikan: **pengetahuan keamanan berada di spesifikasi dan spesialisasinya yang dimuat hanya saat dibutuhkan, sebuah fondasi yang bisa dikembangkan setiap pengguna**. Metodologi ini mendeteksi konteks, melakukan triase atas risiko yang dibawa konteks itu, dan memandu perbaikannya, sehingga developer dan bukan developer dilayani lewat alur yang sama. Temuan dan rekomendasinya tetap dalam bahasa sederhana, sehingga bisa ditindaklanjuti berapa pun kedalaman teknis pembacanya. Pakar tidak dibatasi olehnya, justru diperkuat, sebuah dualitas yang kami kembangkan di `§VI`. > **Wawasan kunci** > > **Pembalikan inti:** Pengetahuan keamanan berada di spesifikasi dan spesialisasinya yang dimuat hanya saat dibutuhkan, sebuah fondasi yang bisa dikembangkan setiap pengguna. Metodologi ini mempelajari apa yang dilakukan sistem, mencocokkan pekerjaan keamanan dengannya, dan memperluas apa pun yang sudah diketahui pengguna. Bayangkan seorang developer yang berkata kepada asisten AI, "aplikasi saya memungkinkan pengguna mengunggah foto profil." Tanpa pemeriksaan keamanan, asisten itu menghasilkan kode yang berfungsi tetapi diam-diam memercayai apa pun yang dikirim klien: jenis file yang dinyatakan, nama file, ukurannya. Fitur unggahan itu dirilis, lalu file yang menyamar sebagai gambar bisa membawa kode, nama yang sengaja dirancang bisa keluar dari path penyimpanan, dan file yang terlalu besar bisa menghabiskan sumber daya server. Semua ini tidak terlihat dalam demo, jadi semuanya ikut dirilis. Kode yang sama, bila dijalankan lewat SDH, berperilaku lain. SDH mendeteksi bahwa sistem menerima file dari luar (deteksi), menerjemahkannya menjadi risiko yang dibawa sebuah unggahan (triase), mengusulkan pemeriksaan jenis dan ukuran file yang sebenarnya, penggantian nama saat disimpan, dan penyimpanan di tempat kode tidak bisa dijalankan (remediasi), lalu membaca hasilnya dan memastikan setiap kontrol benar-benar tetap efektif (verifikasi). Developer itu tidak perlu tahu istilah "unggahan file tanpa batasan". Metodologi inilah yang menyediakannya untuknya. Dokumen ini memberikan kontribusi berikut: - Definisi yang tepat tentang SDH sebagai metodologi, terlepas dari implementasi mana pun, beserta prinsip desainnya (`§III`). - Siklus hidup defensif lima fase yang pemisahan tugasnya justru menjadi kontribusinya: deteksi tidak pernah mengarang, perencanaan tidak pernah membaca kode, hanya satu fase yang mengubah kode, dan verifikasi tidak pernah melunakkan penilaiannya (`§IV`). - **Ketertuntasan** sebagai sikap metodologis: setiap temuan punya titik akhir, bukan putaran tanpa akhir (`§V`). - Dualitas **perluasan pengetahuan developer**: satu alur yang melindungi pemula dan memperkuat pakar (`§VI`). - **Spesialisasi yang tidak bisa dipanggil langsung dan prompt-on-demand**: pengetahuan keamanan terfokus yang dimuat agen saat konteks proyek membutuhkannya, tidak pernah secara default (`§VII`). - **Independensi kondisi** dan **adaptivitas non-otoritatif**: SDH cocok untuk kondisi pengembangan apa pun dan menyesuaikan diri dengan skenario alih-alih memaksakan cakupan yang tetap (`§VIII`). - **Mode preventif**: pertahanan yang sama dijalankan selagi pekerjaan biasa dibangun, sehingga kode langsung aman secara bawaan dan setiap fase punya lebih sedikit hal untuk dikoreksi (`§IX`). - Perbandingan khusus dengan Spec-Driven Development, akar tempat SDH tumbuh lalu memisahkan diri (`§X`). - Disiplin rekayasa yang membuat metodologi ini bertahan dari refactor dan tetap tidak terikat agen mana pun: pelacakan identitas berdasarkan nama (`§XI`) dan wahana yang tidak terikat agen (`§XII`). --- ## II. Latar belakang dan karya terkait SDH dibangun di atas karya sebelumnya. SDH mewarisi struktur yang sudah terbukti dari pengembangan spec-first yang digerakkan agen `[1]`, `[2]`, `[3]`: templat, perintah slash yang dikonsumsi agen, dokumen yang mengarahkan, dan agen yang menjalankan setiap fase. SDH mengimplementasikan ulang struktur itu dengan tujuan defensif. Silsilah ini disengaja, dan salah satu prinsip kerja SDH menyebutnya secara langsung: bangun alur kerja dari struktur yang sudah terbukti, lalu arahkan untuk keamanan. SDH bukan daftar periksa statis berisi rekomendasi generik. Daftar periksa tahu banyak tentang keamanan secara umum, tetapi tidak tahu apa-apa tentang proyek di hadapannya. SDH membalik penekanan itu. Upaya pertamanya dicurahkan untuk deteksi, untuk mempelajari apa yang dilakukan sistem, dan baru setelah itu SDH meraih pengetahuan yang menjadi relevan berkat deteksi tersebut. SDH juga bukan pengganti praktisi keamanan atau tool Blue Team khusus. SDH memperluas pengetahuan developer (`§VI`). Tim yang punya fungsi keamanan khusus sebaiknya tetap mempertahankannya. SDH memberi tim itu wahana yang terstruktur, dan memberi tim yang tidak memilikinya sebuah fondasi yang bisa dipertanggungjawabkan. SDH juga berdampingan dengan pemindai keamanan deterministik (analisis statis, linter) `[4]`, `[5]`. Tool semacam itu berharga justru karena deterministik dan bisa diulang. SDH sebagian besar bekerja dengan penalaran agen, yang menukar determinisme ketat dengan kepekaan terhadap konteks. Metodologi ini tidak berpura-pura sebaliknya. Di tempat determinisme penting, SDH menanamkan engine deterministik di dalam penalaran itu (`§VII`): agen memutuskan apakah sebuah input layak diperiksa, dan program deterministik memutuskan apakah input itu berbahaya. Karya sebelumnya yang paling dekat adalah Spec-Driven Development (SDD), keluarga metodologi spec-first yang menggerakkan pembangunan maju dari spesifikasi yang bisa dieksekusi. Kami memperlakukan SDD sebagai satu kelas. Rumusan paling jelasnya sebagai metodologi praktisi adalah laporan Piskala `[1]`, dan toolkit berbasis agen yang paling dikenal adalah Spec Kit dari GitHub `[2]`, dengan OpenSpec `[3]` sebagai tool kedua dari keluarga yang sama. Ketiganya menjadi referensi kanonis untuk perbandingan di `§X`. --- ## III. SDH: definisi dan prinsip desain **Security-Driven Hardening** adalah metodologi keamanan yang terstruktur dan digerakkan AI, yang membuat basis kode menjadi lebih aman dengan menggerakkan pekerjaan dari spesifikasi yang dijalankan agen, bukan dari perbaikan ad hoc. Namanya terinspirasi dari **Blue Team**, pihak bertahan dalam dunia keamanan. SDH berfokus pada pertahanan, hardening, dan verifikasi, tidak pernah pada serangan. > **Definisi** > > **Security-Driven Hardening (SDH):** Metodologi keamanan yang terstruktur, digerakkan AI, dan khusus pertahanan, yang lebih dulu mendeteksi apa yang sebenarnya dilakukan sebuah sistem, lalu menggerakkan pekerjaan keamanan yang spesifik untuk konteks itu, diatur oleh prinsip aman secara bawaan dan disampaikan dalam bahasa sederhana. SDH didefinisikan oleh serangkaian prinsip yang mengikat. Masing-masing adalah aturan, dan masing-masing memberi pengguna jaminan tertentu. | Prinsip | Aturannya | Apa yang dijamin bagi pengguna | | ------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | Aman secara bawaan, dalam bahasa sederhana, setara bagi semua | Setiap default, pesan, dan perbaikan aman sejak awal dan bisa dipahami pembaca mana pun, developer atau bukan. Tidak ada tingkatan pengguna yang diistimewakan. | Pemula mendapat fondasi yang aman tanpa harus memintanya, dan membaca hasilnya dengan istilahnya sendiri. | | Peka konteks, bukan generik | Setiap fase dimulai dari konteks yang terdeteksi di fase detect, dan bertindak atas apa yang sebenarnya dilakukan sistem. | Rekomendasinya sesuai dengan proyek, bukan dengan daftar periksa. Pengetahuan keamanan berada di spesifikasi dan spesialisasinya yang dimuat hanya saat dibutuhkan, memperluas apa pun yang dibawa pengguna. | | Fleksibel, bukan kaku | Prinsip, persyaratan, dan rekomendasi adalah titik awal. Pengguna bisa mengubah kata-katanya, menghapus, menambah, atau mempersempit cakupan apa pun. | Metodologi ini menyesuaikan diri dengan proyek dan pengguna, dan tidak pernah lebih ketat daripada yang diinginkan pengguna. Fleksibilitas tidak pernah melemahkan fondasi yang aman secara bawaan. | | Selaraskan, jangan sekadar menambah | Artefak adalah dokumen hidup, bukan log. Setiap eksekusi memeriksa ulang setiap entri: pertahankan yang masih berlaku, tulis ulang yang berubah, hapus yang sudah tidak relevan. | Catatannya selalu mencerminkan kondisi terkini, sehingga tidak pernah membusuk menjadi backlog yang usang. | | Khusus pertahanan | SDH mengaudit, memperkuat, dan memverifikasi. SDH tidak pernah menghasilkan tool ofensif, eksploit untuk tujuan jahat, atau teknik penghindaran deteksi untuk merugikan. | Metodologi ini tidak bisa diubah menjadi senjata. Konten dwiguna hanya muncul dalam kerangka yang jelas-jelas defensif. | | Spec-first, digerakkan agen, diarahkan untuk keamanan | Alur kerjanya dibangun dari templat, perintah, charter yang mengarahkan, dan agen yang menjalankan setiap fase. | Struktur pengembangan yang sudah terbukti, dialihfungsikan agar agen mengerjakan pekerjaan keamanan yang substansial. | **Tabel 1.** Prinsip desain SDH dan jaminan yang diberikan masing-masing kepada pengguna. Prinsip ini bukan hiasan. Semuanya adalah batasan yang wajib dipatuhi setiap fase di bawah, dan pembahasan di `§XV` kembali ke prinsip ini untuk menandai batas metodologi. Bagian selanjutnya dari dokumen ini mengembangkan sembilan pilar bernama. Pilar inilah bagian yang perlu bisa diingat pembaca, sekaligus bagian yang akan diimplementasikan ulang oleh tim lain jika ingin menyatakan bahwa mereka menjalankan SDH. | Pilar | Apa yang diberikan | Bagian | | ---------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------- | ----------- | | Pembalikan yang peka konteks | Pengetahuan keamanan berada di spesifikasi dan spesialisasinya yang dimuat hanya saat dibutuhkan, sehingga pemula dan pakar berbagi satu alur. | `§I`, `§VI` | | Siklus hidup defensif lima fase | Pemisahan tugas: kebijakan, deteksi, triase, remediasi, verifikasi, masing-masing dengan satu tugas. | `§IV` | | Ketertuntasan | Temuan punya titik akhir, bukan putaran tanpa akhir. Pekerjaan yang sudah tertutup pun ditutup. | `§V` | | Dualitas perluasan pengetahuan developer | Satu alur yang melindungi pemula dan memperkuat pakar, tanpa pernah menggantikan keduanya. | `§VI` | | Prompt-on-demand, pengetahuan yang tidak bisa dipanggil langsung | Pengetahuan keamanan yang relevan dimuat sesuai dengan apa proyek itu, tidak pernah secara default. | `§VII` | | Independensi kondisi dan adaptivitas non-otoritatif | Cocok untuk kondisi pengembangan apa pun di stack apa pun, dan menyesuaikan diri dengan skenario alih-alih memaksakan cakupan. | `§VIII` | | Mode preventif | Pertahanan yang sama berjalan selagi pekerjaan baru dibangun, sehingga kode langsung aman secara bawaan. | `§IX` | | Pelacakan identitas berdasarkan nama | Sebuah temuan tetap menjadi satu item di semua fase, dan penggantian nama hanya memutus tautan di satu tempat. | `§XI` | | Wahana yang tidak terikat agen | Nilai keamanannya ditulis sekali dan tidak bergantung pada agen atau stack mana pun. | `§XII` | **Tabel 2.** Sembilan pilar bernama SDH dan tempat masing-masing dikembangkan. --- ## IV. Alur Blue Team 5 fase SDH menyusun pekerjaan sebagai siklus hidup defensif lima fase (Gambar 1). Setiap fase berorientasi pada pertahanan, setiap fase dibangun di atas fase sebelumnya, dan urutan fasenya mengikuti aktivitas Blue Team yang nyata: menetapkan kebijakan, mendeteksi, melakukan triase, meremediasi, dan memverifikasi. ```mermaid flowchart TB charter["1 · charter (kebijakan)
membaca: proyek, dan deskripsi pengguna jika ada
menulis: charter
setiap prinsip memuat risiko yang dicegahnya, dalam bahasa sederhana"] detect["2 · detect (deteksi)
membaca: kode pengguna
menulis: peta detect
mendeteksi, bukan mengarang: catat hanya yang didukung kode"] plan["3 · plan (triase)
membaca: peta detect, tidak pernah kode
menulis: rencana pertahanan
setiap perbaikan menunjuk sesuatu yang benar-benar dipetakan detect"] harden["4 · harden (remediasi)
membaca: rencana pertahanan, dan kode yang disentuhnya
menulis: kode, dan catatan hardening
satu-satunya fase yang mengubah kode, satu perbaikan setiap kali, perubahan terkecil yang tetap efektif"] verify["5 · verify (verifikasi)
membaca: kode, dan catatan hardening
menulis: setiap putusan terbuka ke catatan hardening
pencocokan kode dengan catatan, secara statis, tidak pernah dilunakkan"] charter --> detect --> plan --> harden --> verify verify -.->|"ditolak: pekerjaan dibuka kembali untuk harden,
diterapkan ulang sesuai alasan yang dicatat"| harden verify -.->|"penutupan: menutup apa yang terbukti tertutup
dari seluruh rantai,
satu baris di riwayat"| detect ``` **Gambar 1.** Alur lima fase: apa yang dibaca setiap fase, apa yang ditulisnya, dan invarian yang menopangnya. Verify menggerakkan kedua jalur balik: kontrol yang ditolak membuka kembali harden, dan temuan yang terbukti tuntas ditutup dari seluruh rantai, dengan satu baris di riwayat. Pemisahan tugas itulah kontribusinya. Karena setiap fase hanya punya satu tugas, kegagalan terkurung di satu tempat, dan pembaca bisa memercayai apa yang dinyatakan setiap artefak. > **Wawasan kunci** > > **Applied bukan berarti terverifikasi:** Harden mencatat bahwa sebuah perbaikan sudah diterapkan. Verify memverifikasinya dengan mencocokkan kode dengan catatan itu, dan putusannya tidak pernah dilunakkan agar sesuai dengan catatan. Sebuah kontrol bisa ada di kode, tetapi risikonya tetap bisa dijangkau, dan dalam kasus itu putusan yang jujur adalah "risiko belum tertutup." ### charter (kebijakan) Charter menetapkan prinsip keamanan proyek, aturan yang wajib dipatuhi setiap fase sesudahnya. Charter adalah lapisan yang mengarahkan semua fase, semacam pemeriksaan saat kompilasi untuk postur keamanan proyek. Setiap prinsip punya nama yang jelas, aturan yang tidak bisa ditawar dan bisa diperiksa terhadap kode, serta baris `Why:` yang menyatakan risiko yang dicegahnya, bukan sekadar perbaikannya. Charter selalu membaca proyek itu sendiri (manifest, struktur, dan dependensinya), dan deskripsi pengguna, jika diberikan, menjadi arahan yang kemudian diperluas oleh pembacaan itu melampaui apa yang disebut pengguna. Tanpa deskripsi, proyek menjadi satu-satunya sumber. Keduanya saling melengkapi, bukan bersaing, dan charter mencatat kebijakan yang seharusnya dipegang proyek, bukan kondisi kodenya. Orang yang bukan developer pun harus bisa membacanya dan memahami aturan sekaligus risikonya. ### detect (deteksi) Detect membaca kode dan memetakan apa yang sebenarnya dilakukan sistem yang punya bobot keamanan. Instruksi yang mengarahkannya adalah "mendeteksi, bukan mengarang": catat hanya yang didukung kode, beserta bukti yang dibutuhkan fase berikutnya. Detect bersifat netral. Fase ini tidak memaksa temuannya agar cocok dengan charter, karena mencocokkan risiko dengan aturan charter adalah tugas fase plan. Setiap temuan memuat tiga bagian: apa temuan itu (deskripsi dalam bahasa sederhana), mengapa penting (risikonya, bukan sekadar faktanya), dan buktinya (fungsi atau rute tempatnya berada). Bukti itu tidak memuat path file. Path hanya disimpan di peta pelacakan (`§XI`), sehingga teksnya tidak pernah menyimpan path yang bisa menjadi usang. ### plan (triase) Plan mengubah setiap temuan menjadi perbaikan, dinamai menurut kelas risikonya (dengan merujuk referensi yang sudah mapan, CWE dan OWASP, jika memang mendasarinya) dan dikaitkan dengan prinsip charter yang ditegakkan perbaikan itu. Prioritasnya (kritis, tinggi, sedang, rendah) bukan pilihan bebas: plan memberi skor setiap temuan dengan metode Base-and-Environmental dari CVSS v4.0, sehingga tingkatnya adalah skor itu dalam kata-kata sederhana, dibenarkan oleh satu baris berbahasa sederhana tentang paparan dan taruhannya, dan dua kali menjalankan akan menghasilkan urutan yang sama. Vektornya adalah jangkar yang presisi bagi pakar, sedangkan tingkat beserta pembenarannya adalah penilaian yang sama yang bisa diikuti siapa pun. Plan hanya bekerja dari peta detect dan tidak pernah membaca kode. Ini batasan yang disengaja, bukan keterbatasan: batasan ini memaksa setiap perbaikan menunjuk sesuatu yang benar-benar dideteksi detect. Jika suatu cakupan belum pernah dipetakan, plan berhenti dan mengarahkan pengguna kembali ke detect alih-alih menebak. ### harden (remediasi) Harden adalah satu-satunya fase yang mengubah kode, jadi fase ini bergerak dengan hati-hati. Apakah sebuah suntingan memerlukan persetujuan pengguna ditentukan oleh agen dan mode izin tempat agen itu berjalan, sehingga harden tidak menambahkan gerbang konfirmasi sendiri. Harden menerapkan satu perbaikan setiap kali, dependensi lebih dulu, lalu prioritas tertinggi, agar setiap perubahan tetap kecil, mudah ditinjau, dan mudah dibatalkan. Harden tidak pernah melemahkan kontrol yang sudah ada demi memuat perbaikan baru, dan tidak pernah melanggar prinsip charter. Jika sebuah perbaikan akan bertentangan dengan suatu prinsip, harden berhenti dan menampilkan konfliknya alih-alih menerapkannya. Setiap blok dicatat sebagai Applied, Partial, atau Blocked. "Applied belum berarti terverifikasi", dan itulah yang ditangani fase berikutnya. ### verify (verifikasi) Verify memverifikasi setiap kontrol yang diterapkan dengan membaca kode dan mencocokkannya dengan apa yang dicatat harden. Verifikasinya adalah pencocokan itu, kode dengan catatan, dan sifatnya statis: verifikasi ini memastikan sebuah kontrol ada dan benar di dalam kode, bukan bahwa kontrol itu bertahan dari serangan pada sistem yang sedang berjalan. Pemeriksaan runtime semacam itu, yang menjalankan serangan nyata atau simulasi terhadap sistem yang aktif, sengaja berada di luar cakupan. Verify mengembalikan salah satu dari tiga putusan: risiko tertutup, risiko belum tertutup, atau tidak bisa dipastikan dari kode. Verify tidak menghasilkan artefak sendiri: harden dan verify berbagi catatan hardening, harden memiliki apa yang sudah dikerjakan dan verify memiliki putusan beserta alasannya, dan keduanya tidak pernah menulis field milik yang lain. Kontrol yang ditolak menjadi pekerjaan yang dibuka kembali untuk harden, yang pada eksekusi berikutnya memperlakukan putusan itu sebagai lebih kuat daripada pembacaannya sendiri atas kode dan menerapkan ulang perbaikan tepat pada celah yang disebut alasan itu. Verify lebih memercayai kode daripada catatan, karena catatan bisa mengklaim lebih dari yang diberikan kode. Verify hanya membaca kode pengguna, dan tidak pernah melunakkan putusan agar sesuai dengan catatan. Sebuah kontrol bisa ada, tetapi risikonya tetap bisa dijangkau lewat jalan lain, dan dalam kasus itu putusan yang jujur adalah "risiko belum tertutup." Jika, saat membaca, verify melihat masalah keamanan yang tidak pernah tercakup oleh peta detect, verify tidak mengarang putusan untuknya, karena deteksi adalah tugas detect: verify menampilkan masalah itu dan mengarahkan pengguna kembali ke detect, sehingga temuannya masuk lewat alur yang sama alih-alih melompatinya. > **Benang merah: unggahan file.** Satu temuan menunjukkan tulang punggung alur ini dari awal sampai akhir. > > - **detect** menemukannya: sistem menerima file dari pengguna, dan handler unggahan memercayai jenis MIME yang dikirim klien tanpa memeriksa jenis file yang sebenarnya. _Mengapa ini penting:_ file yang menyamar sebagai gambar bisa menyembunyikan kode berbahaya. > - **plan** menentukan perbaikannya, prioritas **kritis**, dengan menegakkan prinsip "Semua input tidak tepercaya sampai divalidasi": periksa jenis dan ukuran file yang sebenarnya, ganti namanya saat disimpan, dan simpan unggahan di tempat file itu tidak bisa dijalankan sebagai kode. > - **harden** menerapkannya, status **Applied**: handler kini mendeteksi jenis sebenarnya dari isi file, memberlakukan batas ukuran, menolak apa pun yang tidak terduga, mengganti nama saat menyimpan, dan menyimpan di tempat kode tidak bisa dijalankan. > - **verify** membaca handler itu, mencocokkannya dengan catatan, dan mengembalikan **risiko tertutup**: kode melakukan persis apa yang diklaim catatan. > > Nama temuan yang sama terbawa melalui peta detect, rencana, dan catatan hardening, dan verify bertindak atas catatan itu dengan nama yang sama: putusan yang masih terbuka ditulis ke blok temuan tersebut, dan temuan yang terbukti tuntas pun ditutup (`§V`). Nama bersama itulah identitasnya (`§XI`). --- ## V. Ketertuntasan: setiap temuan punya titik akhir Sebagian besar tool keamanan meninggalkan pengguna dengan backlog yang terus bertambah. SDH mengambil posisi yang berbeda: **sebuah temuan bisa dituntaskan, sehingga punya titik akhir alih-alih tinggal di backlog tanpa akhir** (Gambar 2). Ini mengikuti langsung dari prinsip penyelarasan. > **Definisi** > > **Ketertuntasan:** Risiko yang terverifikasi tertutup akan ditutup dari seluruh alur, sehingga temuan itu mencapai kondisi tuntas dan baru dibuka kembali saat kode berubah. Sebuah temuan punya titik akhir, meskipun program keamanannya sendiri tetap berkelanjutan. Artefak SDH adalah dokumen hidup, bukan log. Setiap kali sebuah fase dijalankan ulang, fase itu memeriksa ulang setiap entri yang ada terhadap kondisi terkini dan melakukan salah satu dari tiga hal: mempertahankan yang masih berlaku, menulis ulang yang berubah, atau menghapus yang sudah tidak relevan. Temuan yang menurut kode sudah teratasi cukup dihapus. Catatan kerjanya mencerminkan masa kini, bukan masa lalu. Penutupan adalah penyelarasan yang sama yang mencapai kesimpulannya. Saat verify memverifikasi sebuah risiko sudah tertutup, verify menutup temuan itu dari seluruh alur: peta detect, rencana, catatan hardening, dan peta pelacakan. Inilah sebabnya verify menjadi satu-satunya fase yang menulis ke artefak fase lain: verify adalah fase yang menutup putaran. Saat temuan keluar dari rantai, proses penutupan menyarikannya menjadi entri singkat di catatan riwayat yang berada di luar rantai kerja dan tidak pernah diproses ulang. Inilah batas antara menghilang dan ditutup: temuan yang dihapus oleh penyelarasan karena tidak lagi benar tidak meninggalkan apa pun, sedangkan temuan yang terbukti tertutup mendapat satu baris di riwayat. Temuan yang sudah ditutup tidak lagi muncul di artefak kerja mana pun sesudahnya, dan ketiadaan itu memang diharapkan, bukan tanda rantai yang rusak. ```mermaid stateDiagram-v2 direction TB [*] --> OPEN: detect mendeteksi OPEN --> Plan: plan Plan --> Harden: harden Harden --> Verify: verify Verify --> StoodDown: risiko tertutup StoodDown --> SETTLED SETTLED --> OPEN: perubahan kode membuka kembali temuan Plan: plan Harden: harden Verify: verify StoodDown: STOOD DOWN · satu baris di riwayat ``` **Gambar 2.** Mesin status ketertuntasan. Sebuah temuan bergerak dari OPEN → STOOD DOWN → SETTLED, dan baru dibuka kembali saat kode berubah. Saat semua yang berada dalam cakupan sudah ditutup, siklus pun tuntas, dan kondisi tuntas itu punya bentuk yang nyata: artefak yang temuan terakhirnya tertutup dihapus seluruhnya, sehingga rantai yang sepenuhnya tertutup hanya menyisakan charter dan riwayat, kebijakan dan buktinya. Siklus baru dibuka kembali saat kode berubah. Metodologi ini memberi setiap temuan akhir yang pasti, sesuatu yang justru tidak bisa diberikan backlog tanpa akhir. --- ## VI. Dualitas perluasan pengetahuan developer SDH tidak menggantikan orang, dan tidak menggantikan tool Blue Team khusus. SDH **memperluas pengetahuan developer itu sendiri**. Makin paham seorang developer tentang keamanan, makin presisi ia bisa mengarahkan alurnya, dan makin besar otonominya. Developer yang hanya paham sedikit tetap mendapat hasil yang aman, karena mode otomatis melindunginya. Pembalikan dari `§I`, bahwa pengetahuan keamanan berada di spesifikasi, berlaku ke dua arah. Bagi pemula, itu perlindungan: mereka tidak perlu tahu harus meminta apa, karena spesifikasilah yang mengusulkan. Bagi pakar, itu penguatan: spesifikasi yang sama memungkinkan mereka mengarahkan alur dengan presisi, alih-alih melawan daftar periksa yang kaku. Setiap fase membawa dualitas ini dalam cara kerjanya sendiri (Gambar 3). Dijalankan tanpa input, fase itu bertindak atas seluruh cakupan atas nama pengguna. Jika diberi arahan, fase yang sama menyempit tepat ke apa yang dituju pengguna. ```mermaid flowchart TB inversion["satu pembalikan, dua arah:
pengetahuan keamanan berada di spesifikasi"] inversion --> auto["mode otomatis (tanpa input)
fase mengusulkan dan bertindak
atas seluruh cakupan"] inversion --> directed["mode terarah (dengan input)
fase menyempit tepat
ke apa yang dituju pengguna"] auto --> novice["pemula, terlindungi:
hasil yang aman tanpa
perlu tahu harus meminta apa"] directed --> expert["pakar, diperkuat:
alur diarahkan dengan presisi,
bukan daftar periksa yang kaku"] novice -.-> phases["lima fase yang sama melayani keduanya:
charter · detect · plan · harden · verify"] expert -.-> phases ``` **Gambar 3.** Dualitas perluasan pengetahuan developer. Satu pembalikan melayani dua kelompok: mode otomatis melindungi pemula, dan mode terarah memperkuat pakar, lewat lima fase yang sama. Spesialisasi yang dimuat saat dibutuhkan (`§VII`) menyatakan dualitas ini secara eksplisit di dalam teksnya sendiri. Setiap spesialisasi memberi tahu agen bahwa pengetahuannya "memperluas penilaianmu" dan agar agen terus bernalar melampaui apa yang diberikan spesialisasi itu. Pengetahuan itu adalah lantai, bukan langit-langit. Inilah yang melayani kedua kelompok dalam keseimbangan yang dimaksud dokumen ini: komunitas developer mendapat instrumen yang substansial, dan praktisi Blue Team mendapat wahana terstruktur yang tidak berpura-pura mengerjakan pekerjaan mereka. --- ## VII. Spesialisasi yang tidak bisa dipanggil langsung dan prompt-on-demand Inilah pola paling baru dari metodologi ini. SDH membawa pengetahuan keamanan yang terfokus dalam bentuk spesialisasi yang dimuat **hanya saat dibutuhkan**, dan agen sendirilah yang memutuskan mana yang dimuat dengan mencocokkan konteks proyek. Kami menyebutnya **prompt-on-demand**: cara bagi agen untuk memilih pengetahuan mana yang diaktifkan berdasarkan cakupan proyek tempat ia berada, alih-alih menjalankan setiap pemeriksaan secara default. Spesialisasinya terus berkembang, dan mana pun bisa berubah atau diganti kapan saja. Kontribusinya adalah polanya, bukan spesialisasinya. > **Definisi** > > **Prompt-on-demand:** Agen memilih pengetahuan keamanan mana yang diaktifkan dengan mencocokkannya dengan cakupan proyek di hadapannya, sehingga pengetahuan yang relevan dimuat sesuai dengan apa proyek itu sebenarnya, alih-alih menjalankan setiap pemeriksaan secara default. > **Definisi** > > **Spesialisasi yang tidak bisa dipanggil langsung:** Unit pengetahuan keamanan yang terfokus dan tidak terikat bahasa pemrograman untuk satu konteks, seperti unggahan file atau kode yang berjalan di browser. Spesialisasi mengaudit dan menjelaskan, tidak pernah menulis ulang kode, dan tidak pernah menghasilkan input serangan. Spesialisasi bukan perintah: ia dimuat saat konteks yang ditanganinya masuk dalam cakupan, atau saat sebuah prompt memintanya berdasarkan nama. Setiap spesialisasi menyebutkan bentuk yang lebih aman untuk risiko yang ditanganinya dan memberi tahu agen cara bertindak atas temuan di setiap fase yang memakainya: cara menilainya saat deteksi, cara menerapkan perbaikannya dengan aman saat remediasi, dan cara membuktikannya saat verifikasi. Ciri penentunya adalah bahwa spesialisasi **tidak bisa dipanggil secara langsung**: ia bukan perintah, dan di dalam alur, kecocokanlah yang memuatnya. Fase deteksi menampilkan katalog sekali, mencocokkan konteks proyek dengan apa yang dicakup setiap entri, dan hanya memuat spesialisasi yang konteksnya ada dalam cakupan. Fase sesudahnya memakai ulang daftar hasil pencocokan itu alih-alih menampilkan katalog lagi, sehingga satu pencocokan melayani seluruh rantai, dan mode preventif (`§IX`) menjalankan pencocokan yang sama terhadap pekerjaan yang akan dibangun. Spesialisasi yang konteksnya tidak ada akan dilewati, dan melewatinya sama-sama harus dipertanggungjawabkan seperti memuatnya: setiap entri di katalog menerima putusan eksplisit, diterapkan atau dilewati, dengan alasan yang dibaca dari kode, sehingga kesan samar bahwa sesuatu tidak relevan tidak pernah menggantikan ketiadaan yang nyata. Tidak menemukan satu pun yang berlaku adalah hasil yang sah. Katalog adalah data, dan pertumbuhannya berarti satu file pengetahuan ditambah satu baris katalog, tidak pernah perintah baru. Spesialisasi bawaan dikelompokkan ke dalam kategori, seperti OWASP, sebuah bahasa pemrograman, atau integrasi AI, dan katalog yang dipakai sebuah proyek berisi spesialisasi bawaan dari kategori yang dipilihnya ditambah spesialisasi miliknya sendiri. Proyek mencatat pilihan itu bersama state proyek lainnya, sehingga seluruh tim mencocokkan dengan katalog yang sama. Ini adalah prinsip peka konteks yang sama seperti pada setiap fase, diterapkan pada pengetahuan: pengetahuan yang relevan dimuat sesuai dengan apa proyek itu sebenarnya, alih-alih menjalankan setiap pemeriksaan secara default. Sifat yang sama memungkinkan pengguna, bukan hanya pengelola, menumbuhkan katalog: sumber atau topik keamanan yang diberikan pengguna disarikan menjadi spesialisasi baru milik proyek, masuk ke katalognya apa pun kategorinya, dan dimuat persis seperti spesialisasi bawaan, menggantikan spesialisasi bawaan yang bernama sama. Menyusun spesialisasi pun bersifat khusus pertahanan dan mematuhi batas yang sama yang ditegakkan spesialisasi: tulisan tentang serangan boleh menjadi sumbernya, tetapi spesialisasi yang dihasilkannya mengaudit dan menjelaskan, tidak pernah menghasilkan eksploit yang berfungsi. Dengan begitu, pembalikan dari `§I`, yaitu kecerdasan yang berada di spesifikasi, meluas ke katalog itu sendiri, yang bisa diperdalam pengguna untuk konteksnya sendiri tanpa menulis kode. Contoh singkat berikut menggambarkan prompt-on-demand. Detect membaca folder berisi kode yang berjalan di browser. Detect mencocokkan konteks itu di katalog, memuat spesialisasi yang menanganinya, dan menampilkan temuan sisi klien lewat langkah normal detect. Spesialisasi yang konteksnya tidak ada dalam cakupan ini tidak cocok, sehingga tidak pernah dimuat, dan masing-masing dicatat sebagai dilewati. Proyeklah yang menentukan pengetahuan mana yang relevan, bukan konfigurasi yang tetap. Determinisme muncul tepat di tempat yang penting. Spesialisasi bisa membawa checker deterministik, bukan hanya teks: jika suatu kelas risiko punya prosedur keputusan yang tegas, sebuah program kecil mengembalikan putusan tetap untuk input tertentu, misalnya sekumpulan kecil kata seperti `safe`, `unsafe`, atau `invalid input`. Sebagian kelas risiko memang bisa diputuskan secara deterministik dengan cara ini, dengan sejumlah karya sebelumnya di balik prosedur keputusannya `[9]`, `[10]`, `[11]`. Checker itu menilai kandidat yang diberikan agen atau memindai cakupan untuk menemukannya sendiri, dan dalam kedua kasus, checker-lah, bukan agen, yang mengembalikan putusan. Spesialisasi yang cukup universal bisa ditandai wajib di katalog sehingga selalu diterapkan, dengan checker-nya dijalankan di seluruh cakupan. Inilah satu-satunya kasus ketika pengetahuan dimuat tanpa kecocokan konteks, dan hal itu dinyatakan di data katalog, tidak pernah diputuskan agen saat itu juga. Di sinilah SDH menambatkan penalaran agennya pada sesuatu yang bisa diulang, tanpa berpura-pura bahwa seluruh alurnya deterministik. Terakhir, spesialisasi bersifat **bisa dilepas**. Karena pengetahuannya berdiri sendiri, pengguna bisa menjalankan satu spesialisasi langsung di prompt yang tidak ada hubungannya dengan alur SDH lengkap, sehingga keamanan tetap menyertai pengembangan sehari-hari. Spesialisasi dengan checker deterministik, misalnya, bisa menyaring setiap kandidat yang dihasilkan selama coding biasa dan hanya menyisakan yang aman. Kemampuan dilepas inilah sebagian alasan SDH bisa menyesuaikan diri dengan begitu banyak situasi, yang menjadi pokok bahasan `§VIII`, dan wujud penuhnya adalah mode preventif (`§IX`), tempat pengetahuan yang sama menjaga pengembangan biasa dari awal sampai akhir. --- ## VIII. Independensi kondisi dan adaptivitas non-otoritatif Dua sifat membedakan SDH dari metodologi spesifikasi yang kaku. ### Independensi kondisi > **Definisi** > > **Independensi kondisi:** Metodologi ini tidak bergantung pada kondisi pengembangan. SDH cocok untuk direktori kosong, proyek yang sedang berjalan, satu pull request, atau basis kode lama yang besar, di stack apa pun, karena SDH mempelajari titik awalnya dengan membacanya. Setiap fase bekerja dengan cara yang sama, baik proyeknya benar-benar baru maupun sudah ada. Charter menyimpulkan prinsip dari kode apa pun yang ada. Detect memetakan kode apa pun yang tersedia, sekalipun sangat sedikit. Tidak ada titik awal yang diasumsikan. ### Adaptivitas non-otoritatif > **Definisi** > > **Adaptivitas non-otoritatif:** Metodologi ini menyesuaikan diri dengan skenario alih-alih memaksakan cakupan tetap yang harus diikuti pengguna. Saat pengguna tidak tahu harus berkata apa, SDH membaca lingkungan tempat ia dipanggil, membangun konteks, dan mengajukan pertanyaan yang menentukan langkah berikutnya. Mode usulan charter adalah contoh paling jelas: SDH menurunkan charter yang aman secara bawaan dengan menganalisis proyek, bertanya kepada pengguna hanya jika sebuah celah benar-benar mengubah hasilnya, lalu menuliskannya dan menyajikan setiap prinsip dalam bahasa sederhana beserta risiko yang dicegahnya. Charter adalah dokumen hidup yang dirombak pengguna dengan menjalankannya ulang, bukan kontrak yang tertahan di balik permintaan persetujuan, sehingga pengguna tidak pernah dituntut tahu harus meminta apa. Adaptivitas ini tampak sebagai kepekaan terhadap bentuk input: fase yang sama membaca apa yang diberikan kepadanya dan memilih mode (Gambar 4). Sebuah file di prompt, satu temuan dari daftar, sebuah kekhawatiran, misi terfokus terhadap titik lemah yang sudah diketahui, atau permintaan pemindaian brute-force menyeluruh: masing-masing sesuai dengan kebutuhan pengguna, karena alurnya memang dirancang non-otoritatif. Semua ini tidak melemahkan fondasi yang aman secara bawaan. Fleksibilitas membentuk cara fondasi itu diterapkan, tidak pernah menurunkannya. ```mermaid flowchart TB shape["fase membaca bentuk
dari apa yang diberikan"] shape --> none["tanpa input"] shape --> paths["satu path atau lebih"] shape --> concern["kekhawatiran yang dijelaskan"] shape --> finding["temuan yang disebut namanya"] shape --> band["satu tingkat prioritas"] none --> auto["mode otomatis:
mengusulkan, atau memindai
seluruh cakupan"] paths --> focus["fokus hanya pada
file atau direktori itu"] concern --> scoped["batasi cakupan pada
satu kekhawatiran itu"] finding --> item["bertindak atas satu
item yang dilacak itu"] band --> priority["bertindak hanya atas kritis,
tinggi, sedang, atau rendah"] ``` **Gambar 4.** Adaptivitas non-otoritatif. Fase yang sama membaca bentuk inputnya dan memilih mode, sehingga cakupannya selalu milik pengguna, tidak pernah dipaksakan. --- ## IX. Mode preventif universal: pertahanan yang sama selagi pekerjaan dibangun SDH membawa satu mode pelengkap: pengembangan biasa yang dikerjakan dengan pertahanan yang sama tetap aktif selagi kode ditulis. Pengguna meminta pekerjaannya sendiri, halaman login, unggahan, endpoint, dan metodologi ini menjaga proses pembangunan saat sedang berlangsung, sehingga hasilnya aman secara bawaan begitu selesai, bukan setelah putaran hardening berikutnya. > **Definisi** > > **Mode preventif:** pengembangan biasa yang dijalankan di bawah lapisan pengarah dan pengetahuan SDH. Charter mengikat proses pembangunan, spesialisasi yang relevan dengan apa yang akan dibuat dimuat hanya saat dibutuhkan, dan hasilnya dicocokkan dengan persis pertahanan yang dipakai sebelum pekerjaan dinyatakan selesai. Mode ini memakai ulang setiap bagian yang sudah dibawa setiap fase, diarahkan ke kode yang belum ada. Deteksi konteks beralih dari kode ke niat: agen menalar apa yang akan dibangunnya dan batas yang dilintasi pekerjaan itu (login berarti kredensial, sesi, dan input dari luar), dan penalaran itulah yang dicocokkan dengan katalog pengetahuan. Prompt-on-demand (`§VII`) digeneralisasi di sini: konteks bisa dideteksi dari rencana pembuatan kode, bukan hanya dari kode yang sudah ada. Charter mengarahkan seperti biasa, dan permintaan yang akan melanggar sebuah prinsip ditampilkan sebagai konflik, tidak pernah dibangun. Pertahanan diterapkan langsung, pada saat setiap bagian ditulis, dengan memvalidasi di batas dan memakai konstruksi yang aman sejak pertama kali, sehingga versi yang berfungsi tetapi tidak aman tidak pernah ada untuk dikoreksi. Mode ini berakhir dengan cara verify dimulai. Sebelum pekerjaan dinyatakan selesai, pihak yang membangun mencocokkan hasilnya sendiri dengan pertahanan yang dipakainya: kontrol harus berada di jalur risiko, bukan di sampingnya, kontrol harus lengkap, dan jika sebuah spesialisasi membawa checker deterministik, putusan checker itu mengalahkan pembacaan agen sendiri. Celah yang ditemukan di sini ditutup sebagai bagian dari pekerjaan yang sama, karena menyelesaikan pekerjaan berarti menyelesaikannya dengan aman. Apa yang ditolak mode ini sama disengajanya dengan apa yang dilakukannya. Mode ini hanya membangun apa yang diminta dan tidak mengaudit apa pun di sekitarnya: mengaudit apa yang sudah ada adalah tugas kelima fase. Mode ini tidak menulis artefak dan tidak melacak temuan, karena temuan adalah risiko yang terdeteksi pada apa yang sudah ada, dan tujuan mode ini adalah agar versi yang tidak aman tidak pernah masuk sama sekali. Kedua arah ini saling melengkapi: kelima fase menutup apa yang sudah ada (`§V`), dan mode preventif menjaga agar pekerjaan baru tidak membukanya kembali. Rantai yang sudah tuntas tetap tuntas bukan karena pengembangan berhenti, tetapi karena apa yang dibangun selama rantai itu tuntas dibangun dengan pertahanan. --- ## X. Security-Driven Hardening versus Spec-Driven Development Security-Driven Hardening (SDH) tumbuh dari fondasi Spec-Driven Development (SDD), lalu menyimpang tajam. Warisan strukturalnya nyata dan diakui: spec-first, digerakkan agen, dokumen yang mengarahkan, dan serangkaian perintah berfase yang dijalankan agen. SDH memakai ulang struktur itu dengan sengaja. Yang berbeda adalah tujuannya, model otoritasnya, kondisi yang diasumsikan, dan kondisi akhirnya. Kami memperlakukan SDD sebagai satu kelas, dengan laporan Piskala `[1]` sebagai rumusan kanonis metodologinya, Spec Kit dari GitHub `[2]` sebagai toolkit agen yang kanonis, dan OpenSpec `[3]` sebagai tool kedua dari keluarga yang sama. SDD membalik pengembangan tradisional dengan membuat spesifikasi bisa dieksekusi: spesifikasi langsung menghasilkan implementasi yang berfungsi, bukan sekadar memandunya `[1]`. Rangkaian fasenya menggerakkan pembangunan maju `[2]` (menetapkan prinsip pengarah, menentukan apa yang dibangun, merencanakan stack teknis, memecah rencana menjadi tugas, lalu mengimplementasikan). Dokumen pengarahnya, sebuah konstitusi berisi prinsip, adalah bagian fondasional yang wajib dipatuhi agen dari awal sampai akhir. Di situlah inti perbedaannya. Otoritas SDD mengalir dari spesifikasi ke pembangunan, dan implementasinya diharapkan mengikutinya. SDH membalik hampir setiap sumbu dari kontrak itu (Tabel 3). > **Wawasan kunci** > > **Perbedaan inti:** Otoritas SDD mengalir dari spesifikasi ke pembangunan, dan implementasinya diharapkan mengikutinya. SDH bersifat non-otoritatif dan mengalir ke arah sebaliknya, ke dalam dari konteks sistem yang terdeteksi, memperkuat keamanan apa yang sudah ada. | Sumbu | SDD | SDH | | -------------------------- | --------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- | | Tujuan | Menghadirkan fitur. Spesifikasi menjadi implementasi yang berfungsi. | Memperkuat keamanan apa yang sudah ada atau sedang dibangun. Setiap fase diarahkan untuk pertahanan. | | Model otoritas | Otoritatif. Spesifikasi dan konstitusi membatasi pembangunan pada cakupan yang harus diikuti. | Non-otoritatif. SDH menyesuaikan diri dengan skenario, dan pengguna bisa mengubah kata-kata, menghapus, atau mempersempit cakupan. | | Asumsi kondisi | Pembangunan maju dari sebuah spesifikasi. | Independen terhadap kondisi: direktori kosong, proyek yang sedang berjalan, satu PR, atau kode lama. | | Kondisi akhir | Selesai saat fitur sudah dibangun. | Bisa dituntaskan. Sebuah temuan mencapai kondisi tuntas, dan baru dibuka kembali saat kode berubah. | | Dokumen pengarah | Konstitusi berisi prinsip yang wajib dipatuhi agen. | Charter berisi prinsip berbasis risiko (masing-masing memuat baris `Why:`), secara eksplisit bukan kontrak yang kaku. | | Cara pengetahuan bertambah | Menambah perintah (atau memperluas rangkaian fase). | Menambah spesialisasi yang tidak bisa dipanggil langsung, yang dimuat agen saat dibutuhkan: satu file ditambah satu baris katalog, tanpa perintah baru. | | Siapa yang dilayani | Pembangun yang mendorong sebuah fitur maju. | Pengguna mana pun, developer atau bukan, dilayani lewat alur yang sama. | | Apa yang mengubah kode | Fase implementasi menghasilkan hasil pembangunan. | Hanya fase harden yang mengubah kode, satu perbaikan setiap kali. | **Tabel 3.** SDD dibandingkan SDH di delapan sumbu. Struktur yang dipinjam, kontrak yang dibalik. Agar adil terhadap silsilahnya: SDD adalah karya sebelumnya yang sudah terbukti, dan SDH berutang kepada SDD atas struktur tempatnya berjalan. Penyimpangan ini bukan kritik terhadap SDD, yang menyelesaikan masalah yang berbeda (membangun maju) dengan baik. SDH mengambil mesin yang sama yang sudah terbukti dan mengarahkannya ke pertahanan, adaptivitas, dan penutupan. OpenSpec `[3]`, yang disusun di sekitar usulan perubahan, daftar tugas, dan spesifikasi per perubahan, menegaskan polanya: keluarga ini menggerakkan pembangunan maju dari spesifikasi, sementara SDH memperkuat sistem ke dalam dari konteks yang terdeteksi. Bahkan mode preventif SDH (`§IX`), satu-satunya tempat SDH mengiringi pembangunan maju, tetap memegang kontrak yang dibalik: mode ini mengatur bagaimana pekerjaan dibangun dan tidak pernah memutuskan apa yang dibangun. --- ## XI. Ketelitian rekayasa: disiplin pelacakan Disiplin selaraskan-jangan-sekadar-menambah (`§V`) membutuhkan landasan yang bertahan dari refactor. Sebuah temuan harus tetap menjadi satu item di setiap fase yang menyentuhnya, dan file yang diganti namanya atau dipindahkan tidak boleh memutus rantai. SDH menyelesaikannya dengan **identitas berdasarkan nama** dan **path yang hanya disimpan di pelacakan**. > **Definisi** > > **Identitas berdasarkan nama:** Identitas sebuah temuan adalah namanya, ditulis sama persis di setiap artefak. Teksnya memuat nama, tidak pernah path. Path file hanya disimpan di peta pelacakan, sehingga penggantian nama atau pemindahan file hanya memutus tautan di tepat satu tempat. Setiap temuan detect adalah satu item yang dilacak. Identitasnya adalah **namanya**, judul bagiannya, yang ditulis sama persis di peta detect, rencana, dan catatan hardening. Fase berikutnya memakai ulang nama itu kata demi kata saat bertindak atas item yang sama, dan verify menulis putusannya ke catatan hardening dengan nama yang sama. Peta pelacakan hanya berisi pelacakan, tidak ada yang lain, satu entri per item: ```json { "name": "File uploads", "paths": ["src/routes/upload.ts"] } ``` Peta itu tidak mencatat teks, anotasi, pengenal terpisah, maupun fase. Artefak teks memuat redaksinya, dan peta hanya memuat identitas dan path. Path file adalah satu-satunya hal yang mudah berubah, dan path hanya disimpan di sini. Penggantian nama atau pemindahan file hanya bisa memutus tautan di tepat satu tempat, tidak pernah di dua salinan yang saling menyimpang. ```mermaid flowchart TB detect["peta detect"] --> name plan["rencana pertahanan"] --> name harden["catatan hardening
verify menulis putusannya di sini"] --> name name["name = "File uploads"
teks memuat nama, tidak pernah path"] name -.-> tracking tracking["peta pelacakan
{ name: "File uploads",
paths: ["src/routes/upload.ts"] }
path hanya ada di sini, jadi penggantian nama hanya mengoreksi entri ini"] ``` **Gambar 5.** Ban berjalan identitas. Satu nama temuan mengalir melalui setiap artefak, sementara path-nya hanya ada di peta pelacakan, sehingga penggantian nama dikoreksi di satu tempat. Dua tindakan memelihara peta itu dalam alur normal, dan tindakan ketiga berdiri terpisah sebagai pemeliharaan. **Track** adalah pendaftaran yang bersifat menambah: sebuah fase melaporkan temuan yang ditulisnya, lalu engine mencatat temuan yang baru dan mengikuti path yang diganti namanya untuk sisanya, sambil mengelompokkan masing-masing sebagai baru, dipindahkan, atau tidak berubah. Track tidak pernah menghapus apa pun yang tidak dilaporkan fase itu. **Untrack** menutup temuan yang sudah dinyatakan tertutup oleh verify: dalam satu putaran deterministik, untrack menyarikan masing-masing menjadi entri riwayatnya, menghapus seluruh bagiannya dari artefak, menghapus artefak yang temuan terakhirnya sudah hilang, dan membuang entri pelacakannya, sehingga agen tidak mengerjakan satu pun dari itu secara manual. Di tempat yang tidak bisa dijangkau putaran deterministik itu dengan aman, misalnya nama yang sudah ditutup tetapi masih dikutip di teks temuan lain, untrack menandai titik itu untuk agen alih-alih menebak suntingannya. Keduanya inilah yang dipanggil fase selagi berjalan. **Repair** adalah tindakan pemeliharaan: sebuah fase mendelegasikan kepadanya secara otomatis saat penyelarasannya sendiri menemukan pelacakan yang tidak konsisten (path tercatat yang sudah tidak ada), dan di luar itu repair dijalankan saat dibutuhkan. Repair menyelaraskan ulang seluruh peta sekaligus, dengan membaca setiap artefak dan kode terkini, mengoreksi path setiap item, dan menampilkan apa yang tidak bisa diputuskannya sendiri: item yatim (item yang dilacak tetapi tidak lagi disebut artefak mana pun) atau kandidat ganti nama (item yang path-nya cocok dengan nama lain yang dilaporkan). Repair adalah pemeliharaan, bukan fase keenam. Repair tidak menyentuh kode pengguna maupun artefak teks, hanya pelacakan. Repair membaca kode sumber pengguna hanya untuk satu alasan, yaitu mengetahui path baru dari file yang diganti namanya, dan tidak pernah menulis konten keamanan. Manusia adalah penentu akhir untuk satu-satunya keputusan yang tidak mau ditebak engine: apakah item yang hilang sudah teratasi atau hanya diganti namanya. Lebih baik bertanya daripada menebak, karena item yang terhapus secara keliru akan memutus rantai. Metodologi ini menerapkan disiplin pertahanannya pada dirinya sendiri. Engine deterministik dipanggil sebagai program command line, dan setiap input diteruskan sebagai argumen proses tersendiri, sehingga input itu tetap inert, dan nilai yang mengandung tanda kutip atau backtick tidak akan pernah bisa menyusup ke perintah. Pemeriksaan yang tidak dikenal akan gagal alih-alih menjawab, sehingga pemeriksaan yang salah ketik tidak pernah terbaca sebagai hasil yang bersih. SDH tidak mengecualikan perangkat internalnya sendiri dari prinsip aman secara bawaan. --- ## XII. Wahana: arsitektur yang tidak terikat agen sebagai bukti portabilitas Agar SDH menjadi konvensi yang diadopsi pihak lain, SDH tidak boleh terikat pada satu agen atau satu stack, sehingga wahananya memisahkan tiga urusan (Gambar 6). Lagune membuktikan bahwa hal ini bisa dicapai. **Nilai keamanan** ditulis sekali dan tidak tahu apa pun tentang agen mana yang menjalankannya: instruksi fase dan templat yang diisinya, katalog pengetahuan, dan engine deterministik. **Penyaluran** dibuat tipis: satu-satunya tugasnya adalah membawa nilai itu ke agen tertentu dalam bentuk dan tempat yang diharapkan agen tersebut, dan penyaluran tidak membawa logika keamanan sendiri. **State proyek** adalah milik proyek: charter, artefak fase, peta pelacakan, kategori yang dipilihnya, dan spesialisasi miliknya sendiri, di-commit dan bisa ditinjau seperti bagian lain dari kodenya. ```mermaid flowchart TB value["nilai keamanan, ditulis sekali
instruksi fase · templat · katalog pengetahuan · engine deterministik
tidak tahu agen mana yang menjalankannya"] delivery["penyaluran
membawa nilai itu ke setiap agen dalam bentuk yang diharapkannya
tidak membawa logika keamanan"] agent["agen
menjalankan setiap fase"] project["state proyek
di-commit bersama kodenya
charter · artefak fase · pelacakan · kategori · spesialisasi sendiri"] value --> delivery --> agent agent -->|"membaca dan menulis"| project ``` **Gambar 6.** Wahana yang tidak terikat agen. Nilai keamanan ditulis sekali, penyaluran yang tipis membawanya ke setiap agen, dan state tetap milik proyek. Karena penyaluran tidak membawa logika keamanan, cara membangunnya tidak mengubah apa pun dalam SDH. Sebuah wahana bisa membangun penyalurannya sendiri atau menyerahkannya ke ekosistem yang sudah mendistribusikan skill agen, seperti yang dilakukan implementasi referensi, sementara fase, artefaknya, dan jaminannya tetap sama. Semua ini juga tidak spesifik untuk bahasa atau runtime tertentu. Implementasi referensinya kebetulan ditulis dalam satu stack, tetapi metodologinya adalah batas di antara ketiga urusan ini, bukan toolchain yang membangunnya. Desain yang sama bisa diimplementasikan ulang dalam bahasa yang sama sekali berbeda tanpa mengubah hakikat SDH. --- ## XIII. Studi kasus: SDH dari awal sampai akhir > **Studi kasus** > > **Hardening defensif untuk permukaan unggahan dan admin.** > **Konteks:** aplikasi kecil yang menerima unggahan file dari pengguna dan menampilkan daftarnya di halaman admin. > **Pola:** charter → detect (dengan pengetahuan yang diaktifkan konteks saat dibutuhkan) → plan → harden → verify, dengan satu penutupan dan satu kegagalan nyata. > **Hasil (kemampuan):** satu risiko terverifikasi tertutup dan ditutup dari seluruh rantai, dan satu kontrol terverifikasi _belum_ tertutup lalu dikembalikan ke harden. Putusannya mencerminkan kode, bukan catatan. _Ini adalah contoh ilustratif tentang mekanisme metodologi, bukan studi yang diukur di lapangan, dan tidak melaporkan metrik efektivitas apa pun._ Satu penelusuran utuh menunjukkan metodologi ini bekerja, bukan hanya bagian-bagiannya. Kami melanjutkan benang merah unggahan file dari `§IV` dengan aktivasi pengetahuan saat dibutuhkan dan sebuah penutupan, dan kami menyertakan satu kegagalan nyata. 1. **charter** mengusulkan prinsip "Semua input tidak tepercaya sampai divalidasi," beserta risikonya dalam bahasa sederhana: input yang tidak diperiksa adalah cara paling umum sebuah sistem dibobol. 2. **detect** memindai rute unggahan dan halaman admin kecil yang menampilkan daftar file yang diunggah. Detect mendeteksi temuan unggahan (handler memercayai jenis MIME dari klien). Halaman admin berjalan di browser, konteks yang dikenali prompt-on-demand (`§VII`), sehingga detect memuat spesialisasi untuk konteks itu dan menampilkan temuan kedua: sebuah titik tempat nama file ditulis ke halaman sebagai markup, bukan teks, sehingga nama yang sengaja dirancang bisa berjalan sebagai script di browser pengunjung. Spesialisasi yang konteksnya tidak ada dalam cakupan ini tidak pernah dimuat, dan setiap spesialisasi yang dilewati dicatat beserta ketiadaannya yang terbaca dari kode. 3. **plan** memberi perbaikan unggahan prioritas kritis, yang dikaitkan dengan prinsip itu: periksa jenis dan ukuran file yang sebenarnya, ganti nama saat disimpan, simpan di tempat kode tidak bisa dijalankan. Perbaikan kedua diberi prioritas tinggi: tampilkan nama file sebagai teks, bukan markup. 4. **harden** menerapkan perbaikan unggahan lebih dulu (prioritas tertinggi) dan mencatatnya sebagai Applied, lalu perbaikan kedua, juga Applied. 5. **verify** membaca setiap titik dan mencocokkan kode dengan catatan. Kontrol unggahan tetap efektif: handler mendeteksi jenis sebenarnya dari isi file, memberlakukan batas ukuran, dan menolak sisanya. Putusan: risiko tertutup. Verify menutup temuan unggahan dari seluruh rantai, dan ringkasan hasil penyariannya masuk ke riwayat. Kegagalan nyatanya menyusul. Misalkan perbaikan kedua dari harden menambahkan helper aman untuk menampilkan teks, tetapi membiarkan pemanggilan lama yang menulis markup tetap bisa dijangkau lewat jalur kode lain. Verify membaca halaman itu, melihat helper yang aman, dan juga melihat bahwa jalur yang tidak aman masih aktif. Kontrolnya ada, tetapi risikonya belum tertutup. Verify menolak melunakkan putusan agar sesuai dengan catatan. Verify mengembalikan "risiko belum tertutup," mencatat celahnya, dan mengarahkan kembali ke harden. Kontrol yang tidak sepenuhnya menangani risiko bukanlah kelulusan. Inilah karakter metodologi ini dalam satu contoh: deteksi yang peka konteks, perbaikan berprioritas yang dikaitkan dengan prinsip, penerapan yang hati-hati, dan verifikasi yang melaporkan kondisi kode yang sebenarnya, apa pun isi catatannya. --- ## XIV. Kapan memakai SDH, dan batasnya SDH jarang terasa berlebihan seperti proses yang berat, karena SDH independen terhadap kondisi dan bisa dituntaskan: SDH bisa diperkecil hingga satu file dan satu kekhawatiran, dan mencapai kondisi tuntas alih-alih meninggalkan beban yang terus ada. Batasnya bukan ukuran proyek, melainkan **kedalaman jaminan**. ```mermaid flowchart TB q1{"Apakah kode melakukan sesuatu yang relevan bagi keamanan?
(input, autentikasi, data, secret, panggilan eksternal)"} q1 -->|tidak| little["SDH hanya menambah sedikit di sini."] q1 -->|ya| q2{"Jalankan SDH. Apakah ada standar kepatuhan,
atau fungsi keamanan khusus?"} q2 -->|tidak| baseline["SDH adalah fondasi yang bisa dipertanggungjawabkan."] q2 -->|ya| carrier["SDH adalah wahana yang terstruktur:
mendukung tinjauan dan audit oleh pakar,
tidak menggantikannya."] ``` **Gambar 7.** Kapan memakai SDH. Percabangannya adalah relevansi keamanan lebih dulu, lalu kedalaman jaminan, tidak pernah ukuran proyek. Titik tempat SDH mencapai batasnya: perilaku yang hanya muncul saat sistem berjalan (verify membaca kode, tidak menjalankan sistem), risiko yang bergantung pada konfigurasi atau lingkungan yang tidak bisa dibaca agen, dan konteks berisiko tinggi yang tetap membutuhkan tinjauan pakar. Dalam setiap kasus ini, SDH tetap memberi nilai sebagai pemeriksaan awal yang terstruktur, tetapi SDH adalah lantai, bukan langit-langit. > **Wawasan kunci** > > **Batasnya:** Batas SDH adalah kedalaman jaminan, bukan ukuran proyek. SDH bisa menjadi fondasi yang bisa dipertanggungjawabkan hampir di mana saja, dan mendukung tinjauan pakar di tempat taruhannya menuntut, tetapi SDH tidak menggantikan pengujian pada sistem yang berjalan maupun penilaian seorang profesional keamanan. --- ## XV. Diskusi: posisi, batas, dan apa yang tidak diklaim SDH SDH bersikap tegas tentang batasnya. ### SDH memperluas, bukan menggantikan SDH tidak menggantikan profesional keamanan atau tool Blue Team khusus. SDH memperluas pengetahuan developer (`§VI`). Klaim yang terukur adalah klaim yang tepat: bila diterapkan dengan baik, SDH **bisa** menutup risiko nyata secara efektif, terutama untuk proyek yang tanpa SDH tidak akan mendapat pemeriksaan keamanan sama sekali. SDH bukan jaminan, dan bukan pengganti tinjauan pakar di tempat taruhannya menuntut hal itu. ### Khusus pertahanan, sejak rancangannya SDH mengaudit, memperkuat, dan memverifikasi. SDH tidak pernah menghasilkan tool ofensif, eksploit, atau teknik penghindaran deteksi untuk merugikan. Konten keamanan dwiguna hanya bisa diterima dalam kerangka yang jelas-jelas defensif dan berizin. Ini batas yang tegas, bukan preferensi. ### Verifikasi bersifat substansial, bukan sandiwara Verify memverifikasi dengan membaca kode dan mencocokkannya dengan catatan, bukan dengan menjalankan sistem. Ini verifikasi statis: verifikasi ini memastikan sebuah kontrol ada dan benar di dalam kode, dan tidak membuktikan bahwa kontrol itu bertahan dari serangan saat runtime. Jadi "tidak bisa dipastikan dari kode" adalah putusan yang sah, bukan kegagalan yang disembunyikan di balik hasil lulus. Jika buktinya tidak ada di kode (bergantung pada konfigurasi, atau pada path yang tidak bisa dibaca agen), SDH mengatakannya alih-alih menebak. ### Determinisme dibatasi, dan disebutkan dengan jelas Sebagian besar SDH bekerja dengan penalaran agen, dan itulah yang memungkinkan kepekaannya terhadap konteks. Determinisme dikhususkan untuk engine deterministik: checker yang bisa dibawa spesialisasi (`§VII`) dan engine pelacakan (`§XI`). Dokumen ini tidak mengaburkan garis itu. Jika sebuah hasil deterministik, itu hasil sebuah program. Jika hasil penalaran, itu adalah pembacaan agen atas kode, dengan pengguna sebagai penentu akhir. ### Biaya dan skala Pemindaian penuh memakan banyak token. Mode manual (`§VI`, `§VIII`) ada sebagian untuk menjaga biaya tetap sebanding dengan kekhawatirannya. ### Pengguna adalah penentu akhir SDH meminta manusia memutuskan antara diganti namanya atau sudah teratasi, dan persetujuan atas suntingan kodenya tetap berada di tempat pengguna sudah mengatur agennya, yaitu di mode izin tempat agen itu dijalankan. Metodologi ini mengusulkan dan memverifikasi. Metodologi ini tidak mengesampingkan keputusan orangnya. ### Keberatan dan tanggapan Seorang skeptis yang adil akan mengajukan beberapa keberatan. Yang substansial layak diajukan dengan kata-kata mereka sendiri. **"Bukankah ini cuma penganalisis statis yang ditempeli LLM?"** Bukan. Penganalisis statis menjalankan setiap aturan yang dimilikinya secara default. SDH lebih dulu mendeteksi apa sistem itu, lalu meraih pengetahuan yang relevan (`§II`, `§VII`), dan SDH _menanamkan_ checker deterministik hanya jika suatu kelas risiko punya prosedur keputusan yang tegas. Penalarannya mengutamakan konteks, determinismenya tepat sasaran. **"Bukankah ini cuma daftar periksa keamanan?"** Bukan. SDH membalik daftar periksa: deteksi didahulukan, dan pengetahuan dimuat sesuai dengan apa yang sebenarnya dilakukan proyek (`§II`, `§VII`). **"Bukankah ini cuma SDD yang diberi label baru untuk keamanan?"** Bukan. SDH meminjam struktur SDD dan membalik kontraknya: otoritas, asumsi kondisi, kondisi akhir, dan siapa yang dilayani semuanya berbeda (`§X`). Mesin yang sama, arah yang berlawanan. **"Bukankah metode yang bernalar dengan AI hanya akan berhalusinasi soal temuan?"** Desainnya membatasi pengarangan alih-alih memercayai model untuk berperilaku baik. Detect hanya mencatat apa yang didukung kode ("mendeteksi, bukan mengarang," `§IV`), verify mencocokkan kode dengan catatan dan boleh menjawab "tidak bisa dipastikan dari kode" (`§XV`), checker deterministik menjadi pijakan untuk kasus yang bisa diputuskan (`§VII`), dan pengguna adalah penentu akhir. Ini tidak membuat agen bebas dari kesalahan, tetapi membuat klaimnya bisa diperiksa. Catatan tentang posisi. SDH didefinisikan di sini secara terlepas dari implementasi referensinya. Lima fase, charter berbasis risiko, prinsip selaraskan-jangan-sekadar-menambah beserta ketertuntasannya, pengetahuan prompt-on-demand, mode preventif, pelacakan identitas berdasarkan nama, dan batas khusus pertahanan, itulah metodologinya. Tim lain bisa mengimplementasikannya di stack lain dan ekosistem agen lain, dan hasilnya tetap SDH. Lagune adalah buktinya, bukan definisinya. --- ## XVI. Jebakan, dan bagaimana SDH menghindarinya secara struktural Metodologi dalam keluarga ini punya sejumlah mode kegagalan yang sudah dikenal. Jawaban SDH untuk sebagian besar di antaranya bersifat struktural, tertanam di dalam alur alih-alih diserahkan pada kedisiplinan. | Jebakan | Kegagalannya | Jawaban struktural SDH | | ------------------------------------ | ------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------- | | Spesifikasi membusuk, backlog usang | Artefak menumpuk entri mati yang tidak dipercaya siapa pun | Selaraskan, jangan sekadar menambah (`§V`): setiap eksekusi memeriksa ulang setiap entri dan menghapus yang sudah teratasi | | Rasa percaya diri palsu, hasil lulus | Kontrol yang ada dianggap sudah menutup risiko | Verify mencocokkan kode dengan catatan, sehingga "risiko belum tertutup" dan "tidak bisa dipastikan" adalah putusan kelas satu (`§IV`, `§XV`) | | Banjir daftar periksa | Item generik menutupi satu risiko yang penting | Peka konteks, bukan generik, dengan prompt-on-demand yang hanya memuat apa yang dibutuhkan cakupan (`§VII`) | | Ketergantungan pada tool | Metode ini terpaku pada satu vendor atau agen | Wahana yang tidak terikat agen: nilai keamanan ditulis sekali, dan penyalurannya ke setiap agen tidak membawa logika keamanan (`§XII`) | | Putaran tanpa akhir | Backlog tidak pernah tertutup, pekerjaan tidak pernah tuntas | Ketertuntasan dan kondisi tuntas (`§V`) | **Tabel 4.** Jebakan yang dikenal dalam keluarga metodologi ini dan jawaban struktural SDH untuk masing-masing. Intinya adalah menyebut jebakannya dan menunjuk mekanismenya: ini bukan peringatan agar berhati-hati, melainkan sifat dari alur itu sendiri. --- ## XVII. Pekerjaan selanjutnya Metodologi ini dan implementasi referensinya punya langkah lanjutan yang jelas. - **Menumbuhkan katalog pengetahuan:** Setiap tambahan mempertahankan bentuk `§VII`: satu file pengetahuan dan satu baris katalog, tanpa perintah baru. Jalur dari sisi pengguna sudah ada di sana: pengguna menyarikan spesialisasinya sendiri saat dibutuhkan. Lebih banyak bahasa, runtime, dan kelas risiko bawaan, masing-masing bergabung ke sebuah kategori, adalah arah dari sisi pengelola, dan spesialisasinya diharapkan terus berkembang. - **Lebih banyak checker deterministik:** Jika suatu kelas risiko punya prosedur keputusan yang tegas, sebuah spesialisasi bisa membawa checker deterministik yang menambatkan penalaran agen pada putusan yang bisa diulang. Memperluasnya ke lebih banyak kelas risiko adalah arah yang wajar. - **Evaluasi empiris:** Pertanyaan terbuka yang paling besar adalah efektivitas yang terukur: kualitas penutupan dan tingkat putusan keliru di basis kode nyata. Studi tentang hasil keamanan SDH adalah pekerjaan selanjutnya, dan klaim di sini dibatasi sesuai dengan itu. --- ## XVIII. Kesimpulan Pengembangan berbantuan AI membuka celah keamanan yang tidak bisa ditutup oleh daftar periksa generik, karena risiko yang penting bersifat spesifik pada apa yang sebenarnya dilakukan sebuah sistem, dan orang yang merilisnya mungkin tidak tahu harus meminta apa. SDH menutup celah itu dengan alur yang peka konteks, khusus pertahanan, dan bisa dituntaskan, tempat pengetahuan keamanan berada di dalam metodologi dan spesialisasinya yang dimuat hanya saat dibutuhkan, sebuah fondasi yang bisa dikembangkan setiap pengguna. SDH mendeteksi konteks nyata sistem, melakukan triase atas risiko yang dibawa konteks itu, menerapkan perbaikan dengan hati-hati, dan memverifikasi masing-masing, lalu menutup apa yang sudah dituntaskannya sehingga setiap temuan mencapai titik akhir. Pertahanan yang sama juga berjalan secara preventif selagi pekerjaan baru dibangun, sehingga apa yang sudah ditutup alur ini tetap tertutup. SDH menyesuaikan diri dengan kondisi pengembangan apa pun di stack apa pun, dan memperluas pengetahuan developer alih-alih menggantikan orang dan tool yang sudah mengerjakan tugas itu. Lagune adalah buktinya, tetapi kontribusinya adalah konvensi itu sendiri. SDH ditawarkan sebagai alur keamanan yang esensial untuk era pengembangan dengan AI, untuk diadopsi, disempurnakan, dan diimplementasikan pihak lain di stack mereka sendiri. --- ## Referensi **[1]** D. B. Piskala, "Spec-Driven Development: From Code to Contract in the Age of AI Coding Assistants," arXiv preprint arXiv:2602.00180v1 [cs.SE], Jan. 2026. (Diajukan ke AIWare 2026.) [Online]. Tersedia: https://arxiv.org/abs/2602.00180 **[2]** GitHub, "Spec Kit: Toolkit for Spec-Driven Development." [Online]. Tersedia: https://github.com/github/spec-kit. Diakses: 2026. **[3]** Fission AI, "OpenSpec: Spec-Driven Development for AI Coding Assistants." [Online]. Tersedia: https://github.com/Fission-AI/OpenSpec. Diakses: 2026. **[4]** B. Chess dan G. McGraw, "Static Analysis for Security," IEEE Security & Privacy, vol. 2, no. 6, pp. 76-79, 2004, doi: 10.1109/MSP.2004.111. **[5]** OWASP Foundation, "Source Code Analysis Tools." [Online]. Tersedia: https://owasp.org/www-community/Source_Code_Analysis_Tools. Diakses: 2026. **[6]** OWASP Foundation, "OWASP Top 10:2021." [Online]. Tersedia: https://owasp.org/Top10/. Diakses: 2026. **[7]** MITRE, "Common Weakness Enumeration (CWE)." [Online]. Tersedia: https://cwe.mitre.org/. Diakses: 2026. **[8]** N. Perry, M. Srivastava, D. Kumar, dan D. Boneh, "Do Users Write More Insecure Code with AI Assistants?," in Proc. ACM SIGSAC Conf. on Computer and Communications Security (CCS '23), 2023, pp. 2785-2799, doi: 10.1145/3576915.3623157. [Online]. Tersedia: https://arxiv.org/abs/2211.03622 **[9]** J. Davis dan kontributor, "safe-regex: Detect Possibly Catastrophic, Exponential-Time Regular Expressions." [Online]. Tersedia: https://github.com/davisjam/safe-regex. Diakses: 2026. **[10]** D. Soshnikov, "regexp-tree: Regular Expressions Processor in JavaScript." [Online]. Tersedia: https://github.com/DmitrySoshnikov/regexp-tree. Diakses: 2026. **[11]** T. Jenkinson, "redos-detector: A CLI and Library to Score How Vulnerable a Regex Pattern Is to ReDoS Attacks." [Online]. Tersedia: https://github.com/tjenkinson/redos-detector. Diakses: 2026. --- ## Lampiran A: Prinsip, kata demi kata 1. **Aman secara bawaan, dalam bahasa sederhana, setara bagi semua:** Setiap default, pesan, dan perbaikan harus aman sejak awal dan bisa dipahami pengguna mana pun, developer atau bukan. Tidak ada tingkatan pengguna yang diistimewakan di atas yang lain. 2. **Peka konteks, bukan generik:** Setiap fase harus dimulai dari konteks yang terdeteksi di fase detect dan bertindak atas apa yang sebenarnya dilakukan sistem. Utamakan rekomendasi yang spesifik untuk konteks itu daripada daftar periksa generik. Pengetahuan keamanan berada di spesifikasi dan spesialisasinya yang dimuat hanya saat dibutuhkan, memperluas apa pun yang dibawa pengguna. 3. **Fleksibel, bukan kaku:** SDH menyesuaikan diri dengan proyek dan pengguna. Prinsip, persyaratan, dan rekomendasi adalah titik awal, bukan kontrak yang kaku. Biarkan pengguna mengubah kata-kata, menghapus, menambah, atau mempersempit cakupan apa pun. Fleksibilitas tidak pernah melemahkan fondasi yang aman secara bawaan, hanya memungkinkan pengguna membentuk cara fondasi itu diterapkan. 4. **Selaraskan, jangan sekadar menambah:** Artefak adalah dokumen hidup, bukan log. Saat sebuah fase dijalankan ulang, selaraskan setiap entri yang ada dengan kondisi terkini: pertahankan yang masih berlaku, tulis ulang yang berubah, dan hapus yang sudah tidak relevan. Penutupan adalah penyelarasan yang sama yang mencapai kesimpulannya. 5. **Khusus pertahanan:** SDH mengaudit, memperkuat, dan memverifikasi. SDH tidak pernah menghasilkan tool ofensif, eksploit untuk tujuan jahat, atau teknik penghindaran deteksi untuk merugikan. Konten keamanan dwiguna hanya bisa diterima dalam kerangka yang jelas-jelas defensif dan berizin. 6. **Spec-first, digerakkan agen, diarahkan untuk keamanan:** Bangun alur kerja dari struktur yang sudah terbukti: templat, perintah, charter yang mengarahkan, dan agen yang menjalankan setiap fase. Implementasikan ulang struktur itu dengan tujuan defensif. --- # Glosarium Lagune: SDH, charter, temuan, dan kontrol keamanan > Definisi sederhana untuk setiap istilah Lagune dan Security-Driven Hardening: SDH, charter, detect, temuan, kontrol, harden, verify, stand down, ketertuntasan, spesialisasi, kategori, dan katalog. Kanonis: https://lagune.ai/id-ID/docs/references/glossary Bahasa: id-ID Asli: https://lagune.ai/docs/references/glossary Terakhir diperbarui: 2026-11-06 Setiap istilah penting dalam Lagune dan metodologi Security-Driven Hardening, didefinisikan sekali dengan bahasa yang sederhana. ### Security-Driven Hardening (SDH) Metodologi yang diterapkan Lagune: konvensi Blue Team yang peka konteks, yang mendeteksi konteks sebuah sistem, melakukan triase atas risiko yang dibawa konteks itu, lalu memandu perbaikannya. Pengetahuan keamanannya ada di spesifikasi dan spesialisasinya yang dimuat hanya saat dibutuhkan, sehingga developer maupun bukan developer dilayani lewat alur yang sama. ### Lagune Implementasi referensi SDH: sembilan perintah agen, masing-masing dengan templat yang diisinya, yang dijalankan agen AI untuk memperkuat keamanan basis kode. Setiap agen menginstalnya lewat installer plugin miliknya sendiri atau lewat [**skills.sh**](https://www.skills.sh/wellwelwel/lagune), seperti yang ditunjukkan [halaman instalasi](https://lagune.ai/id-ID/docs), dan perintah itu menjalankan engine Lagune untuk setiap langkah yang deterministik. ### Charter Lapisan yang mengarahkan semua fase Lagune: sekumpulan prinsip keamanan yang wajib dipatuhi setiap fase sesudahnya. Anggap saja sebagai pemeriksaan saat kompilasi untuk postur keamanan sebuah proyek. Charter disimpan di `.lagune/memory/charter.md`. ### Alur pengembangan Perintah universal `/lagune` yang memperkuat keamanan pekerjaan selagi ditulis. Perintah ini menerima prompt apa pun di tahap mana pun, membangun apa yang Anda minta, lalu memperkuatnya dengan default yang aman sebelum menyerahkannya kembali, dengan arahan charter jika sudah ada. Perintah ini tidak menulis apa pun ke pelacakan Lagune, jadi satu-satunya hasilnya adalah kode yang sudah diperkuat. Bersama charter (sebelumnya) dan alur Blue Team (sesudahnya), inilah cara Lagune melindungi selama proses membangun. ### Alur Blue Team Audit lima fase yang menjadi inti Lagune: charter, detect, plan, harden, verify. Setiap fase dibangun di atas fase sebelumnya. "Blue Team" adalah tradisi keamanan para pihak bertahan, kebalikan dari Red Team yang menyerang. ### Temuan Satu risiko yang terdeteksi. Setiap temuan memuat apa temuan itu, mengapa penting, dan bukti di dalam kode. Temuan adalah satu-satunya unit yang dilacak dan dibawa maju oleh plan, harden, dan verify, dikenali lewat namanya di setiap artefak. ### Kontrol Langkah keamanan yang diterapkan untuk menutup suatu risiko. Harden menerapkan kontrol, verify membuktikan kontrol itu tetap efektif. Lagune tidak pernah melemahkan kontrol demi memenuhi sebuah prompt. ### Detect Fase yang membaca kode dan memetakan apa yang dilakukan sistem serta di mana risikonya. Aturan yang mengarahkannya adalah mendeteksi, bukan mengarang: fase ini hanya mencatat apa yang didukung oleh kode. ### Harden Satu-satunya fase yang menyentuh kode Anda. Fase ini menerapkan perbaikan dari rencana satu per satu dan mencatat masing-masing sebagai Applied, Partial, atau Blocked. Applied belum berarti sudah terbukti. ### Verify Fase yang membuktikan bahwa setiap perbaikan yang diterapkan tetap efektif, dengan membaca kode dan mencocokkannya dengan apa yang dicatat harden. Fase ini mengembalikan salah satu dari tiga putusan: Risk closed, Risk not closed, atau Cannot tell from the code. ### Stand down Saat verify membuktikan sebuah risiko sudah tertutup, temuan itu ditutup: dihapus dari seluruh rantai, dengan konfirmasi Anda, sehingga tidak diproses ulang lagi. ### Ketertuntasan Sifat bahwa pekerjaan keamanan punya titik akhir. Karena temuan yang terbukti tuntas akan ditutup dari seluruh rantai, alurnya bisa tuntas, dan baru dibuka kembali saat kode berubah. SDH bisa dituntaskan, bukan putaran tanpa akhir. ### Engine Paket `lagune` di **npm**, yang dijalankan perintah Lagune lewat `npx` untuk setiap langkah yang deterministik: hook, katalog, dan kategori. ### Spesialisasi Modul pengetahuan keamanan yang terfokus dan tidak terikat bahasa pemrograman, yang dimuat hanya saat dibutuhkan, tidak pernah secara default. Spesialisasi bukan perintah. Muat satu spesialisasi ke prompt mana pun dengan `read catalog ` milik engine, misalnya `npx lagune read catalog regex`. ### Kategori Kelompok bernama berisi spesialisasi bawaan, mulai dari `owasp` hingga kategori per bahasa seperti `javascript`, `python`, `go`, dan `rust`. Kategori yang dipakai sebuah proyek, yang dicatat di `.lagune/configs.json`, menentukan spesialisasi bawaan mana yang masuk ke katalognya. Selama belum ada yang dicatat, proyek hanya memakai `owasp`. ### Katalog Kumpulan spesialisasi yang dipakai sebuah proyek: spesialisasi bawaan dari kategorinya ditambah spesialisasi miliknya sendiri, yang ditulis dengan `/lagune-specialize`. Perintah `read catalog` milik engine menampilkan daftarnya, dan setiap fase mencocokkannya dengan kode. ### Prompt-on-demand Prinsip bahwa pengetahuan keamanan yang relevan dimuat sesuai dengan apa proyek itu sebenarnya, alih-alih menjalankan setiap pemeriksaan secara default. ### Identitas berdasarkan nama Model pelacakan Lagune: nama setiap temuan, yang ditulis sama persis sebagai judul bagian di setiap artefak, menjadi identitasnya di sepanjang rantai. Peta pelacakan (`.lagune/tracking.json`) hanya berisi pelacakan, tidak pernah berisi teks penjelasan. ## Pertanyaan yang sering diajukan ### Apa itu Security-Driven Hardening (SDH)? SDH adalah metodologi keamanan Blue Team yang peka konteks. SDH mendeteksi konteks sebuah sistem, melakukan triase atas risiko yang dibawa konteks itu, lalu memandu perbaikannya, dengan setiap temuan tetap ditulis dalam bahasa yang sederhana. Lagune adalah implementasi referensinya. ### Apa itu charter di Lagune? Charter adalah lapisan yang mengarahkan semua fase Lagune, sekumpulan prinsip keamanan yang wajib dipatuhi setiap fase sesudahnya. Charter disimpan di .lagune/memory/charter.md. ### Apa artinya menutup sebuah temuan (stand down)? Saat verify membuktikan sebuah risiko sudah tertutup, temuan itu ditutup: dihapus dari seluruh rantai dengan konfirmasi Anda, sehingga tidak diproses ulang lagi. --- # Skema konfigurasi > JSON Schema untuk konfigurasi proyek Lagune, agar editor Anda bisa melengkapi otomatis dan memvalidasi file, mengikuti Lagune terbaru atau dikunci ke satu versi. Kanonis: https://lagune.ai/id-ID/docs/references/configs-schema Bahasa: id-ID Asli: https://lagune.ai/docs/references/configs-schema Terakhir diperbarui: 2026-11-06 File `.lagune/configs.json` mencatat [**kategori**](https://lagune.ai/id-ID/docs/categories) yang dipakai proyek, mengindeks [**spesialisasi**](https://lagune.ai/id-ID/docs/catalog) milik proyek itu sendiri, dan menentukan apa saja yang dilewati [**checker**](https://lagune.ai/id-ID/docs/hooks/configure). Dengan JSON Schema-nya, editor Anda bisa melengkapi setiap field secara otomatis dan menandai salah ketik atau kategori yang tidak dikenal saat Anda menyunting file tersebut. ## Skema terbaru Setiap kali **Lagune** menulis file ini dan tidak menemukan `$schema` di dalamnya, **Lagune** mengarahkan file itu ke skema terbaru: ```json { "$schema": "https://lagune.ai/schemas/configs.json", "categories": ["owasp", "javascript"] } ``` Alamat ini selalu mengikuti **Lagune** versi terbaru. File yang ditulis sebelum **Lagune** 0.16.0 akan mendapatkannya pada perubahan berikutnya, dan setiap fase akan mengingatkan hal itu sampai saat tersebut. ## Kunci ke satu versi Setiap rilis **Lagune** sejak 0.16.0 membawa skema sebagaimana adanya di versi itu, diterbitkan di **npm** dan disajikan oleh **jsDelivr**. Untuk mengunci satu versi, tulis versinya setelah `lagune@` di alamat `$schema`: ```json { "$schema": "https://cdn.jsdelivr.net/npm/lagune@0.16.0/schemas/configs.json" } ``` Versi ini menerima rentang semver apa pun: | Versi | Skema | | -------------------- | ----------------------------- | | `0.16.0` | Skema dari 0.16.0 | | `0.16.x` atau `0.16` | Skema dari rilis 0.16 terbaru | | `0.x` atau `0` | Skema dari rilis 0.x terbaru | | `latest` | Skema dari rilis terbaru | ## Pertanyaan yang sering diajukan ### Apakah Lagune membutuhkan skema ini? Tidak. Skema hanya membantu editor Anda, dan Lagune membaca file dengan cara yang sama, dengan atau tanpa $schema. ### Apakah Lagune akan menimpa skema yang sudah saya kunci? Tidak. Lagune hanya menulis $schema jika file belum memilikinya, dan tetap memakai alamat apa pun yang Anda tetapkan. ### Kapan saya perlu mengunci versi? Saat proyek menjalankan versi Lagune tertentu, agar editor Anda memvalidasi file sesuai dengan apa yang diterima versi tersebut. --- # Lagune vs. Deepsec: perbandingan dua pendekatan keamanan berbasis AI > Referensi yang membandingkan Lagune dan Deepsec dari Vercel dari sisi cara kerja, siklus hidup, deteksi, biaya, temuan, dan penutupan. Kanonis: https://lagune.ai/id-ID/docs/references/deepsec Bahasa: id-ID Asli: https://lagune.ai/docs/references/deepsec Terakhir diperbarui: 2026-11-06 [Lagune](https://github.com/wellwelwel/lagune) dan [Deepsec](https://github.com/vercel-labs/deepsec) (`v2.2.1`) adalah dua jawaban defensif untuk masalah yang sama: keamanan di era pengembangan yang dibantu AI. Premis keduanya, awal, tengah, dan akhirnya, serta cara masing-masing tampil di hadapan pengguna sengaja dibuat berbeda, bahkan ketika mekanismenya beririsan. **Tips** Apakah Lagune terinspirasi dari Deepsec? Tidak. Lagune ditulis dari nol dan terinspirasi dari Spec-Driven Development dan Security Hardening. Kedua proyek dikembangkan secara terpisah, dan perbandingan ini ada untuk membantu pengguna memahami perbedaan keduanya. ## Sekilas | Aspek | Lagune | Deepsec | | --------------- | --------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------ | | Jenis | Metodologi (SDH) dengan implementasi referensi | Produk: pemindai kerentanan bertenaga agen | | Pusat gravitasi | Prinsip keamanan dan pengetahuan yang dimuat hanya saat dibutuhkan mengarahkan agen, dengan pijakan hook deterministik | Jaring regex yang lebar memasok investigasi AI yang wajib | | Hasilnya | Kode yang diperkuat, pembuktian, dan rantai temuan yang dilacak | Laporan temuan yang sudah ditriase dan diurutkan menurut tingkat keparahan | | Menyentuh kode | Ya: `harden` mengubah kode Anda | Tidak: hanya analisis statis, menghasilkan temuan dan teks rekomendasi | | Runtime | Berjalan di agen dan model yang sudah Anda pakai, di tingkat apa pun | Menjalankan pipeline model sendiri, secara bawaan memakai model kelas frontier | | Memulai | Satu kali instal plugin atau `npx skills add`, lalu arahkan dengan bahasa sehari-hari, tanpa tool baru yang perlu disiapkan | Siapkan workspace `.deepsec/`, instal dependensi, dan tambahkan kunci model | ## Cara kerjanya Lagune mengutamakan agen (agent-first): agen yang memegang kendali, memuat pengetahuan hanya saat dibutuhkan sesuai jenis kodenya, dan menyerahkan bagian yang bisa diputuskan secara pasti ke hook deterministik. Deepsec mengutamakan determinisme (deterministic-first): pemindaian yang lebar menandai kandidat, lalu kandidat itu menunjukkan kepada model wajib apa yang perlu diselidiki dan dinilai. | Aspek | Lagune | Deepsec | | ------------------- | ---------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------- | | Urutan | Prinsip keamanan dan pengetahuan yang cocok mengarahkan agen, yang menyerahkan ke hook dan menilai sisanya | Matcher menandai kandidat, model menyelidiki dan menilai satu per satu | | Peran deterministik | Hook multibahasa yang mengembalikan putusan atau mengarahkan agen, dipadukan dengan pengetahuan kategori | Matcher yang menandai kandidat untuk dinilai model wajib | | Alur pengembangan | `/lagune` membangun dengan aman langsung saat Anda menulis kode | Meninjau kode, tidak menulisnya | | Alur audit | `charter` → `detect` → `plan` → `harden` → `verify` | `scan` → `process` → `triage` → `revalidate` → `report` | | Tugas AI | Bernalar dari pengetahuan, menerapkan perbaikan, dan membuktikan perbaikan itu bertahan | Menyelidiki setiap kandidat dan melaporkan temuan | ## Siklus hidup Lagune bekerja sebelum, selama, dan setelah kode ditulis. Deepsec meninjau repositori setelah kodenya ada. | Momen | Lagune | Deepsec | | ------------------------ | ------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------ | | Sebelum kode ada | `charter` menyusun kebijakan keamanan dari tujuan yang dinyatakan | Berangkat dari kode yang sudah ada: `init` membutuhkan direktori | | Saat membangun | `/lagune` membangun dengan aman secara bawaan, langsung di alur, tanpa meninggalkan artefak | Meninjau setelah membangun, bukan selama prosesnya | | Pada kode yang sudah ada | `detect` → `plan` → `harden` → `verify` | `scan` → `process`, alur intinya | | Peninjauan berkelanjutan | Jalankan ulang fase per cakupan, tanpa gerbang CI siap pakai | Pemindaian ulang inkremental, `process --diff` sebagai gerbang keluar CI | ## Lapisan deteksi Kedua lapisan deterministik itu berlawanan sifatnya: yang satu memutuskan, yang lain menandai. | Aspek | Lagune | Deepsec | | ------------- | ------------------------------------------------------------------------ | -------------------------------------------------------------------- | | Pengelompokan | Hook dan spesialisasi, dikelompokkan dalam kategori | Matcher per pola atau framework | | Output | Putusan literal (finding / review / advisory) ditambah label klasifikasi | Kandidat tanpa putusan (slug, baris, potongan kode, pola yang cocok) | | Penyetelan | Presisi: peka komentar, dengan pengaman placeholder dan jendela | Recall: jaring lebar, AI memangkas positif palsu sesudahnya | | Kedalaman | Lebih dalam pada kelas yang dicakup keduanya | Lebih luas, kurang dalam pada kelas yang dicakup keduanya | | Positif palsu | Ditekan sejak sumbernya, lalu dinilai sesuai konteks | Sengaja dihasilkan berlebih, lalu dikurangi lewat tahap `revalidate` | ## Pengetahuan dan penilaian Keduanya membawa pengetahuan keamanan yang tidak bisa dijangkau regex. Bedanya ada pada tempat pengetahuan itu berada dan siapa yang bisa membentuknya. | Aspek | Lagune | Deepsec | | ------------------ | ----------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | | Bentuk | Modul markdown yang bisa diedit, beberapa didukung hook deterministik | Prompt singkat dan sorotan per teknologi, bersandar pada pengetahuan model itu sendiri | | Pemilihan | Dicocokkan dengan kode, dimuat hanya saat konteksnya ada | Disisipkan ke setiap batch AI, ditambah sorotan untuk teknologi yang terdeteksi | | Siapa yang menulis | Pengguna mengedit modul dan menambah modul baru dengan `specialize` | Maintainer memegang prompt, pengguna mengisi `INFO.md` | | Letak penilaian | Hook memutuskan lapisan dasarnya, agen menilai sisanya dari pengetahuan | Terpusat: satu prosesor AI menilai setiap kandidat | | Pemakaian ulang | Satu modul memandu `detect` sekaligus `verify` | Satu prompt menggerakkan satu-satunya tahap `process` | ## Temuan dan penutupan Perbedaan terbesar keduanya ada pada nasib sebuah temuan setelah diselesaikan. | Aspek | Lagune | Deepsec | | ----------------- | ----------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- | | Tingkat keparahan | Skor CVSS v4.0, disesuaikan dengan eksposur dan taruhannya | Tingkat keparahan dari AI, ditambah triase P0 / P1 / P2 atas kemungkinan eksploitasi dan dampaknya | | Putusan | Risk closed, Risk not closed, atau Cannot tell from the code | true-positive, false-positive, fixed, uncertain, accepted-risk, duplicate | | Persistensi | Rantai kerja diselaraskan dengan kondisi terkini, temuan yang ditutup disarikan menjadi riwayat | Catatan per file yang hanya terus ditambah, tidak ada yang dihapus | | Kondisi akhir | Bisa dituntaskan: temuan yang terbukti ditutup, dan siklus pun tuntas | Setiap temuan disimpan selamanya, disembunyikan dari tampilan setelah diselesaikan | | Detail riwayat | Ringkasan singkat tentang risikonya | Jejak putusan lengkap, termasuk cara perbaikannya | ## Biaya | Aspek | Lagune | Deepsec | | --------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Lapisan dasar deterministik | Gratis: hook berjalan tanpa AI dan tanpa kunci, dan sudah menghasilkan putusan | Gratis: `scan` berjalan tanpa AI, tetapi tidak menghasilkan putusan sendiri | | Tagihan umum | Sudah termasuk dalam agen yang Anda jalankan, bisa $0 dengan model lokal, sesuai harga paket yang sudah Anda pakai, atau per iterasi untuk penggunaan berbasis API | [Kira-kira $25 hingga $1.200 per eksekusi untuk 100 hingga 2.000 file, dan lebih besar lagi dalam skala besar](https://github.com/vercel-labs/deepsec/blob/f75a16803ec5250938bacfe41571d929e8564f45/docs/getting-started.md#run-the-ai-investigation) | | Jalur termurah | Model apa pun, termasuk model lokal gratis, bisa menuntaskan siklus | Ada tier berbayar yang lebih murah, tetapi temuan tetap memerlukan tahap AI berbayar | ## Ekstensibilitas dan tata kelola Masing-masing membuka lapisan yang ditutup oleh yang lain. | Aspek | Lagune | Deepsec | | ------------------------- | ------------------------------------------------------- | ------------------------------------------------------- | | Yang bisa Anda perluas | Edit modul, atau tambahkan yang baru lewat `specialize` | Tambahkan matcher, agen, notifier, dan kepemilikan | | Lapisan kebijakan | Prinsip keamanan mengatur setiap fase dan diberi versi | Konfigurasi bersifat operasional (matcher, model, path) | | Override berdasarkan nama | Modul yang disempurnakan menggantikan modul bawaan | Saat slug matcher bentrok, matcher Anda yang menang | ## Antarmuka Deepsec menghasilkan deliverable untuk organisasi keamanan. Lagune menampilkan tampilan langsung bagi siapa pun yang menjalankannya. | Aspek | Lagune | Deepsec | | ---------------------------- | --------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- | | Antarmuka untuk manusia | Dasbor lokal langsung untuk seluruh rantai, dalam bahasa sehari-hari | File laporan, ekspor, metrik, dan komentar PR, ditambah situs dokumentasi | | Akuntabilitas | Menunjukkan file dan spesialisasi yang diterapkan | Mengarahkan ke penanggung jawab yang disarankan: petugas on-call, manajer, atau committer | | Pembuktian yang bisa diulang | `prove` menulis tes yang bisa dijalankan dan advisori keamanan untuk pengungkapan | Sengaja tetap statis, tidak pernah menjalankan target | | Pertahanan diri tool | Memperkuat API tulis lokal di dasbor | Memperkuat eksekusi AI miliknya terhadap kode target yang tidak tepercaya | ## Skala dan penerapan | Aspek | Lagune | Deepsec | | ---------- | --------------------------------------------------------------------------------------------- | ------------------------------------------------------------ | | Instalasi | Sembilan perintah dari plugin agen Anda atau **skills** CLI, tanpa file yang dibuat di proyek | Workspace `.deepsec/` dengan paket dan dependensinya sendiri | | Arah skala | Bisa dibatasi ke bagian mana pun, sebuah konteks, dari satu file hingga seluruh proyek | Memindai seluruh repositori, hingga monorepo besar | | Distribusi | Hanya lokal, satu-satunya server terikat ke loopback | Opsional disebar ke VM worker Vercel Sandbox | ## Pengalaman pengguna Cara masing-masing menyambut orang yang menjalankannya: apa yang dibutuhkan saat pertama kali dijalankan, dan bagaimana operator mengarahkannya. ### Langkah awal Lagune berjalan lewat agen yang sudah terbuka. Deepsec lebih dulu menyiapkan workspace dan akses model miliknya sendiri. | Aspek | Lagune | Deepsec | | ---------------------------- | ------------------------------------------------------------------------------- | --------------------------------------------------------------------------------- | | Perintah pertama | Instal plugin atau `npx skills add wellwelwel/lagune`, lalu `/lagune-*` di agen | `npx deepsec init`, lalu `cd .deepsec`, `pnpm install`, `scan`, `process` | | Kredensial untuk menjalankan | Tanpa kunci terpisah, memakai agen Anda saat ini | Kunci model (misalnya AI Gateway, token OIDC Vercel 12 jam, atau token Anthropic) | ### Mengarahkannya Keduanya menerima arahan. Lagune membaca bentuk input di tiap fase. Deepsec mempersempit kumpulan file yang dicakup oleh investigasi yang sama. | Aspek | Lagune | Deepsec | | ----------------- | ------------------------------------------------------------------------------------ | -------------------------------------------------------------- | | Seluruh proyek | Fase tanpa input memindai seluruh cakupan | `scan` dan `process` memindai seluruh repositori | | Sebagian | Fase apa pun bisa dibatasi ke file atau direktori tertentu | `--files`, `--files-from`, atau `--diff` mempersempit eksekusi | | Kekhawatiran | Fase bisa dibatasi ke kekhawatiran yang Anda deskripsikan | Prompt investigasinya tetap | | Rentang prioritas | `harden` dan `verify` bisa dibatasi ke tingkat kritis, tinggi, sedang, atau rendah | Temuan diberi label setelah eksekusi | | Satu nilai | Hook langsung memberi skor satu potongan kode, pola, atau URL (`--pattern`, `--url`) | Unit kerjanya adalah file | ## Pertanyaan yang sering diajukan ### Apa perbedaan Lagune dan Deepsec? Lagune mengutamakan agen dan bekerja sebelum, selama, dan setelah kode ditulis: menetapkan kebijakan sebelum kode ada, memperkuat keamanan langsung saat membangun, serta mengaudit, memperkuat, dan memverifikasi kode yang sudah ditulis. Deepsec mengutamakan determinisme: pemindaian regex yang lebar memasok investigasi wajib oleh model kelas frontier, yang meninjau kode yang sudah ada dan melaporkan temuan tanpa mengubahnya. ### Apakah saya bisa menjalankan salah satunya secara gratis? Seluruh alur Lagune bisa berjalan dengan biaya $0 di model lokal gratis, dan hook deterministiknya menghasilkan putusan tanpa AI sama sekali. Scan Deepsec gratis, tetapi tidak menghasilkan putusan, jadi setiap temuan memerlukan tahap AI berbayarnya. ### Apakah salah satunya mengubah kode saya? Lagune mengubahnya: harden menerapkan perbaikan ke kode Anda. Deepsec tidak: Deepsec hanya melakukan analisis statis, menghasilkan temuan dan teks rekomendasi yang diterapkan secara terpisah oleh orang atau agen. --- # Sumber OWASP > Asal pengetahuan spesialisasi OWASP bawaan, dipetakan ke halaman serangan dan Cheat Sheet OWASP yang kanonis. Kanonis: https://lagune.ai/id-ID/docs/references/owasp-sources Bahasa: id-ID Asli: https://lagune.ai/docs/references/owasp-sources Terakhir diperbarui: 2026-11-06 Dokumen ini memetakan setiap **serangan** (`www-community`) dan **Cheat Sheet** (`CheatSheetSeries`) OWASP ke sebuah kategori keamanan, masing-masing dengan tautan ke halaman publik kanonisnya. Dalam satu kategori, item yang setara berbagi satu baris daftar periksa: serangan dan cheat sheet yang menangani risiko yang sama dicantumkan bersama, dipisahkan koma. Item tanpa padanan langsung berdiri di barisnya sendiri. - Kredit sepenuhnya milik OWASP. Serangan ada di `https://owasp.org/www-community/attacks/` dan cheat sheet di `https://cheatsheetseries.owasp.org/cheatsheets/.html`. --- ## 1. Injection (umum) - [x] [Code Injection](https://owasp.org/www-community/attacks/Code_Injection), [Injection Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Injection_Prevention_Cheat_Sheet.html), [Injection Prevention in Java](https://cheatsheetseries.owasp.org/cheatsheets/Injection_Prevention_in_Java_Cheat_Sheet.html) (interpreter) - [x] [Direct Dynamic Code Evaluation (Eval Injection)](https://owasp.org/www-community/attacks/Direct_Dynamic_Code_Evaluation_Eval_Injection) (interpreter) - [x] [Function Injection](https://owasp.org/www-community/attacks/Function_Injection) (interpreter) - [x] [Resource Injection](https://owasp.org/www-community/attacks/Resource_Injection) (network) - [x] [Special Element Injection](https://owasp.org/www-community/attacks/Special_Element_Injection) (interpreter) - [x] [Custom Special Character Injection](https://owasp.org/www-community/attacks/Custom_Special_Character_Injection) (interpreter) - [x] [Comment Injection Attack](https://owasp.org/www-community/attacks/Comment_Injection_Attack) (interpreter) - [x] [Parameter Delimiter](https://owasp.org/www-community/attacks/Parameter_Delimiter) (interpreter) - [x] [Server-Side Includes (SSI) Injection](https://owasp.org/www-community/attacks/Server-Side_Includes_%28SSI%29_Injection) (interpreter) - [x] [Input Validation](https://cheatsheetseries.owasp.org/cheatsheets/Input_Validation_Cheat_Sheet.html), [Bean Validation](https://cheatsheetseries.owasp.org/cheatsheets/Bean_Validation_Cheat_Sheet.html) (interpreter) --- ## 2. Injection SQL dan basis data - [x] [SQL Injection](https://owasp.org/www-community/attacks/SQL_Injection), [SQL Injection Prevention](https://cheatsheetseries.owasp.org/cheatsheets/SQL_Injection_Prevention_Cheat_Sheet.html), [Query Parameterization](https://cheatsheetseries.owasp.org/cheatsheets/Query_Parameterization_Cheat_Sheet.html) (sql) - [x] [Blind SQL Injection](https://owasp.org/www-community/attacks/Blind_SQL_Injection) (sql) - [x] [SQL Injection Bypassing WAF](https://owasp.org/www-community/attacks/SQL_Injection_Bypassing_WAF) (sql) - [x] [RSQL Injection](https://owasp.org/www-community/attacks/RSQL_Injection) (interpreter) - [x] [Database Security](https://cheatsheetseries.owasp.org/cheatsheets/Database_Security_Cheat_Sheet.html) (sql) - [x] [NoSQL Security](https://cheatsheetseries.owasp.org/cheatsheets/NoSQL_Security_Cheat_Sheet.html) (interpreter) --- ## 3. Injection perintah sistem operasi - [x] [Command Injection](https://owasp.org/www-community/attacks/Command_Injection), [OS Command Injection Defense](https://cheatsheetseries.owasp.org/cheatsheets/OS_Command_Injection_Defense_Cheat_Sheet.html) (interpreter) --- ## 4. Injection LDAP, XPath, dan XML - [x] [LDAP Injection](https://owasp.org/www-community/attacks/LDAP_Injection), [LDAP Injection Prevention](https://cheatsheetseries.owasp.org/cheatsheets/LDAP_Injection_Prevention_Cheat_Sheet.html) (interpreter) - [x] [XPATH Injection](https://owasp.org/www-community/attacks/XPATH_Injection) (interpreter) - [x] [Blind XPath Injection](https://owasp.org/www-community/attacks/Blind_XPath_Injection) (interpreter) - [x] [XML External Entity (XXE) Prevention](https://cheatsheetseries.owasp.org/cheatsheets/XML_External_Entity_Prevention_Cheat_Sheet.html), [XML Security](https://cheatsheetseries.owasp.org/cheatsheets/XML_Security_Cheat_Sheet.html) (xml) --- ## 5. Cross-Site Scripting (XSS) - [x] [Cross Site Scripting (XSS)](https://owasp.org/www-community/attacks/Cross-site-Scripting-%28XSS%29), [Cross Site Scripting Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Cross_Site_Scripting_Prevention_Cheat_Sheet.html), [XSS Filter Evasion](https://cheatsheetseries.owasp.org/cheatsheets/XSS_Filter_Evasion_Cheat_Sheet.html) (browser) - [x] [DOM Based XSS](https://owasp.org/www-community/attacks/DOM_Based_XSS), [DOM based XSS Prevention](https://cheatsheetseries.owasp.org/cheatsheets/DOM_based_XSS_Prevention_Cheat_Sheet.html), [DOM Clobbering Prevention](https://cheatsheetseries.owasp.org/cheatsheets/DOM_Clobbering_Prevention_Cheat_Sheet.html) (browser) - [x] [Reflected DOM Injection](https://owasp.org/www-community/attacks/Reflected_DOM_Injection) (browser) - [x] [XSS in Converting File Content to Text](https://owasp.org/www-community/attacks/XSS_in_Converting_File_Content_to_Text) (browser) - [x] [XSS in subtitle](https://owasp.org/www-community/attacks/Xss_in_subtitle) (browser) - [x] [Cross Frame Scripting](https://owasp.org/www-community/attacks/Cross_Frame_Scripting) (browser) - [x] [Cross Site Tracing](https://owasp.org/www-community/attacks/Cross_Site_Tracing) (browser) - [x] [Content Security Policy](https://cheatsheetseries.owasp.org/cheatsheets/Content_Security_Policy_Cheat_Sheet.html) (browser) --- ## 6. Cross-Site Request Forgery (CSRF) dan clickjacking - [x] [Cross Site Request Forgery (CSRF)](https://owasp.org/www-community/attacks/cross-site-request-forgery), [XSRF](https://owasp.org/www-community/attacks/XSRF), [Cross-Site Request Forgery Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Cross-Site_Request_Forgery_Prevention_Cheat_Sheet.html) (http-request) - [x] [Clickjacking](https://owasp.org/www-community/attacks/Clickjacking), [Clickjacking Defense](https://cheatsheetseries.owasp.org/cheatsheets/Clickjacking_Defense_Cheat_Sheet.html) (browser) - [x] [Cross Site History Manipulation (XSHM)](https://owasp.org/www-community/attacks/Cross_Site_History_Manipulation_%28XSHM%29) (browser) - [x] [Form action hijacking](https://owasp.org/www-community/attacks/Form_action_hijacking) (network) - [x] [Reverse Tabnabbing](https://owasp.org/www-community/attacks/Reverse_Tabnabbing) (browser) --- ## 7. Pengalihan dan penerusan - [x] [Open Redirect](https://owasp.org/www-community/attacks/open_redirect), [Unvalidated Redirects and Forwards](https://cheatsheetseries.owasp.org/cheatsheets/Unvalidated_Redirects_and_Forwards_Cheat_Sheet.html) (network) - [x] [Execution After Redirect (EAR)](https://owasp.org/www-community/attacks/Execution_After_Redirect_%28EAR%29) (browser) --- ## 8. Kontrol akses dan otorisasi - [x] [Insecure Direct Object Reference (IDOR)](https://owasp.org/www-community/attacks/insecure_direct_object_reference), [Insecure Direct Object Reference Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Insecure_Direct_Object_Reference_Prevention_Cheat_Sheet.html) (access-control) - [x] [Forced browsing](https://owasp.org/www-community/attacks/Forced_browsing) (access-control) - [x] [Web Parameter Tampering](https://owasp.org/www-community/attacks/Web_Parameter_Tampering) (access-control) - [x] [Setting Manipulation](https://owasp.org/www-community/attacks/Setting_Manipulation) (access-control) - [x] [Authorization](https://cheatsheetseries.owasp.org/cheatsheets/Authorization_Cheat_Sheet.html) (access-control) - [x] [Transaction Authorization](https://cheatsheetseries.owasp.org/cheatsheets/Transaction_Authorization_Cheat_Sheet.html) (access-control) - [x] [Mass Assignment](https://cheatsheetseries.owasp.org/cheatsheets/Mass_Assignment_Cheat_Sheet.html) (access-control) - [x] [Multi-Tenant Application Security](https://cheatsheetseries.owasp.org/cheatsheets/Multi_Tenant_Security_Cheat_Sheet.html) (access-control) --- ## 9. Autentikasi dan kredensial - [x] [Brute Force Attack](https://owasp.org/www-community/attacks/Brute_force_attack), [Password Spraying Attack](https://owasp.org/www-community/attacks/Password_Spraying_Attack), [Bot Management and Anti-Automation](https://cheatsheetseries.owasp.org/cheatsheets/Bot_Management_and_Anti-Automation_Cheat_Sheet.html) (credential-endpoint) - [x] [Credential stuffing](https://owasp.org/www-community/attacks/Credential_stuffing), [Credential Stuffing Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Credential_Stuffing_Prevention_Cheat_Sheet.html) (credential-endpoint) - [x] [Qrljacking](https://owasp.org/www-community/attacks/Qrljacking) (federation) - [x] [Authentication](https://cheatsheetseries.owasp.org/cheatsheets/Authentication_Cheat_Sheet.html), [Multifactor Authentication](https://cheatsheetseries.owasp.org/cheatsheets/Multifactor_Authentication_Cheat_Sheet.html) (access-control) - [x] [Password Storage](https://cheatsheetseries.owasp.org/cheatsheets/Password_Storage_Cheat_Sheet.html) (access-control) - [x] [Forgot Password](https://cheatsheetseries.owasp.org/cheatsheets/Forgot_Password_Cheat_Sheet.html), [Choosing and Using Security Questions](https://cheatsheetseries.owasp.org/cheatsheets/Choosing_and_Using_Security_Questions_Cheat_Sheet.html) (access-control) - [x] [Email Validation and Verification in Identity Systems](https://cheatsheetseries.owasp.org/cheatsheets/Email_Validation_and_Verification_Cheat_Sheet.html) (access-control) --- ## 10. Manajemen sesi - [x] [Session fixation](https://owasp.org/www-community/attacks/Session_fixation), [Session hijacking attack](https://owasp.org/www-community/attacks/Session_hijacking_attack), [Session Prediction](https://owasp.org/www-community/attacks/Session_Prediction), [Session Management](https://cheatsheetseries.owasp.org/cheatsheets/Session_Management_Cheat_Sheet.html) (access-control) - [x] [Cookie Theft Mitigation](https://cheatsheetseries.owasp.org/cheatsheets/Cookie_Theft_Mitigation_Cheat_Sheet.html) (access-control) --- ## 11. Federasi identitas (OAuth, SAML, dan JWT) - [x] [OAuth 2.0 Protocol](https://cheatsheetseries.owasp.org/cheatsheets/OAuth2_Cheat_Sheet.html) (federation) - [x] [SAML Security](https://cheatsheetseries.owasp.org/cheatsheets/SAML_Security_Cheat_Sheet.html) (federation) - [x] [JSON Web Token for Java](https://cheatsheetseries.owasp.org/cheatsheets/JSON_Web_Token_for_Java_Cheat_Sheet.html) (federation) --- ## 12. Kriptografi dan keamanan transport - [x] [Cryptanalysis](https://owasp.org/www-community/attacks/Cryptanalysis), [Cryptographic Storage](https://cheatsheetseries.owasp.org/cheatsheets/Cryptographic_Storage_Cheat_Sheet.html), [Key Management](https://cheatsheetseries.owasp.org/cheatsheets/Key_Management_Cheat_Sheet.html) (crypto) - [x] [Manipulator-in-the-Middle (MITM)](https://owasp.org/www-community/attacks/Man-in-the-middle_attack), [Transport Layer Security](https://cheatsheetseries.owasp.org/cheatsheets/Transport_Layer_Security_Cheat_Sheet.html) (transport) - [x] [HTTP Strict Transport Security](https://cheatsheetseries.owasp.org/cheatsheets/HTTP_Strict_Transport_Security_Cheat_Sheet.html) (transport) - [x] [Pinning](https://cheatsheetseries.owasp.org/cheatsheets/Pinning_Cheat_Sheet.html) (transport) --- ## 13. Server-Side Request Forgery (SSRF) - [x] [Server Side Request Forgery](https://owasp.org/www-community/attacks/Server_Side_Request_Forgery), [Server-Side Request Forgery Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Server_Side_Request_Forgery_Prevention_Cheat_Sheet.html) (network) --- ## 14. Path traversal dan penanganan file - [x] [Path Traversal](https://owasp.org/www-community/attacks/Path_Traversal) (path) - [x] [Binary Planting](https://owasp.org/www-community/attacks/Binary_planting) (path) - [x] [Windows ::DATA Alternate Data Stream](https://owasp.org/www-community/attacks/Windows_DATA_alternate_data_stream) (path) - [x] [Embedding Null Code](https://owasp.org/www-community/attacks/Embedding_Null_Code) (path) - [x] [File Upload](https://cheatsheetseries.owasp.org/cheatsheets/File_Upload_Cheat_Sheet.html) (upload) --- ## 15. Penyalahgunaan protokol HTTP (header, cache, dan splitting) - [x] [HTTP Response Splitting](https://owasp.org/www-community/attacks/HTTP_Response_Splitting), [Cross-User Defacement](https://owasp.org/www-community/attacks/Cross-User_Defacement) (interpreter) - [x] [HTTP Security Response Headers](https://cheatsheetseries.owasp.org/cheatsheets/HTTP_Headers_Cheat_Sheet.html) (dibagi ke: browser, transport, http-request, access-control) - [x] [Cache Poisoning](https://owasp.org/www-community/attacks/Cache_Poisoning) (interpreter) - [x] [IP Spoofing via HTTP Headers](https://owasp.org/www-community/attacks/ip_spoofing_via_http_headers) (http-request) --- ## 16. Encoding dan content spoofing - [x] [Unicode Encoding](https://owasp.org/www-community/attacks/Unicode_Encoding) (interpreter) - [x] [Double Encoding](https://owasp.org/www-community/Double_Encoding) (interpreter) - [x] [Content Spoofing](https://owasp.org/www-community/attacks/Content_Spoofing) (browser) --- ## 17. Injection CSV dan spreadsheet - [x] [CSV Injection](https://owasp.org/www-community/attacks/CSV_Injection) (csv) --- ## 18. CORS (Cross-Origin Resource Sharing) - [x] [CORS OriginHeaderScrutiny](https://owasp.org/www-community/attacks/CORS_OriginHeaderScrutiny) (http-request) - [x] [CORS RequestPreflightScrutiny](https://owasp.org/www-community/attacks/CORS_RequestPreflightScrutiny) (http-request) --- ## 19. Denial of service - [x] [Regular expression Denial of Service (ReDoS)](https://owasp.org/www-community/attacks/Regular_expression_Denial_of_Service_-_ReDoS) (regex) --- ## 20. Keamanan memori dan kode native - [x] [Buffer Overflow Attack](https://owasp.org/www-community/attacks/Buffer_overflow_attack), [Buffer Overflow via Environment Variables](https://owasp.org/www-community/attacks/Buffer_Overflow_via_Environment_Variables) (c-cpp) - [x] [Format string attack](https://owasp.org/www-community/attacks/Format_string_attack) (c-cpp) --- ## 21. Kode mobile dan eksekusi kode tidak tepercaya - [x] [Mobile code invoking untrusted mobile code](https://owasp.org/www-community/attacks/Mobile_code_invoking_untrusted_mobile_code) (interpreter) - [x] [Mobile code non-final public field](https://owasp.org/www-community/attacks/Mobile_code_non-final_public_field) (java) - [x] [Mobile code object hijack](https://owasp.org/www-community/attacks/Mobile_code_object_hijack) (java) --- ## 22. Deserialisasi - [x] [Deserialization](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html) (dibagi ke: python, ruby, php, java, dotnet) --- ## 23. Malware dan ancaman sisi klien - [x] [Man-in-the-browser attack](https://owasp.org/www-community/attacks/Man-in-the-browser_attack), [Browser Extension Security Vulnerabilities](https://cheatsheetseries.owasp.org/cheatsheets/Browser_Extension_Vulnerabilities_Cheat_Sheet.html) (browser) - [x] [Third Party JavaScript Management](https://cheatsheetseries.owasp.org/cheatsheets/Third_Party_Javascript_Management_Cheat_Sheet.html) (browser) --- ## 24. Logging, repudiasi, dan penanganan error - [x] [Log Injection](https://owasp.org/www-community/attacks/Log_Injection), [Logging](https://cheatsheetseries.owasp.org/cheatsheets/Logging_Cheat_Sheet.html), [Application Logging Vocabulary](https://cheatsheetseries.owasp.org/cheatsheets/Logging_Vocabulary_Cheat_Sheet.html) (interpreter) - [x] [Repudiation Attack](https://owasp.org/www-community/attacks/Repudiation_Attack) (interpreter) --- ## 25. Logika bisnis dan penyalahgunaan fungsionalitas Logika bisnis dan penyalahgunaan fungsionalitas tidak punya satu permukaan kode yang bisa dipertahankan oleh spesialisasi per permukaan: pertahanannya adalah desain yang spesifik untuk tiap aplikasi, penalaran yang sama yang mendasari threat modeling proyek. Dipindahkan ke "Di luar cakupan". --- ## 26. Keamanan AI, LLM, dan agen - [x] [Prompt Injection](https://owasp.org/www-community/attacks/prompt-injection), [LLM Prompt Injection Prevention](https://cheatsheetseries.owasp.org/cheatsheets/LLM_Prompt_Injection_Prevention_Cheat_Sheet.html) (llm) - [x] [MCP Tool Poisoning](https://owasp.org/www-community/attacks/MCP_Tool_Poisoning), [MCP (Model Context Protocol) Security](https://cheatsheetseries.owasp.org/cheatsheets/MCP_Security_Cheat_Sheet.html) (llm) - [x] [HITL Dialog Forging (Lies-in-the-Loop)](https://owasp.org/www-community/attacks/lies-in-the-loop) (llm) - [x] [AI Agent Security](https://cheatsheetseries.owasp.org/cheatsheets/AI_Agent_Security_Cheat_Sheet.html), [Secure Coding with AI](https://cheatsheetseries.owasp.org/cheatsheets/Secure_Coding_with_AI_Cheat_Sheet.html) (llm) - [x] [Retrieval-Augmented Generation (RAG) Security](https://cheatsheetseries.owasp.org/cheatsheets/RAG_Security_Cheat_Sheet.html) (llm) - [x] [Secure AI/ML Model Ops](https://cheatsheetseries.owasp.org/cheatsheets/Secure_AI_Model_Ops_Cheat_Sheet.html) (llm) - [x] [AML and Sanctions Compliance for AI Agent Payments](https://cheatsheetseries.owasp.org/cheatsheets/AML_Sanctions_AI_Agent_Payments_Cheat_Sheet.html) (llm) --- ## 27. Prototype pollution dan cross-site leaks - [x] [Prototype Pollution Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Prototype_Pollution_Prevention_Cheat_Sheet.html) (javascript) - [x] [Cross-site leaks (XS-Leaks)](https://cheatsheetseries.owasp.org/cheatsheets/XS_Leaks_Cheat_Sheet.html) (browser) --- ## 28. Framework dan platform bahasa - [x] [Django Security](https://cheatsheetseries.owasp.org/cheatsheets/Django_Security_Cheat_Sheet.html), [Django REST Framework](https://cheatsheetseries.owasp.org/cheatsheets/Django_REST_Framework_Cheat_Sheet.html) (python) - [x] [Ruby on Rails](https://cheatsheetseries.owasp.org/cheatsheets/Ruby_on_Rails_Cheat_Sheet.html) (ruby) - [x] [Laravel](https://cheatsheetseries.owasp.org/cheatsheets/Laravel_Cheat_Sheet.html) (php) - [x] [Symfony](https://cheatsheetseries.owasp.org/cheatsheets/Symfony_Cheat_Sheet.html) (php) - [x] [Java Security](https://cheatsheetseries.owasp.org/cheatsheets/Java_Security_Cheat_Sheet.html) (java) - [x] [DotNet Security](https://cheatsheetseries.owasp.org/cheatsheets/DotNet_Security_Cheat_Sheet.html) (dotnet) - [x] [NodeJS Security](https://cheatsheetseries.owasp.org/cheatsheets/Nodejs_Security_Cheat_Sheet.html) (javascript) - [x] [PHP Configuration](https://cheatsheetseries.owasp.org/cheatsheets/PHP_Configuration_Cheat_Sheet.html) (php) --- ## 29. Front-end web dan browser - [x] [HTML5 Security](https://cheatsheetseries.owasp.org/cheatsheets/HTML5_Security_Cheat_Sheet.html) (browser) - [x] [AJAX Security](https://cheatsheetseries.owasp.org/cheatsheets/AJAX_Security_Cheat_Sheet.html) (browser) - [x] [Securing Cascading Style Sheets](https://cheatsheetseries.owasp.org/cheatsheets/Securing_Cascading_Style_Sheets_Cheat_Sheet.html) (dibagi ke: access-control, browser) --- ## 30. API dan layanan - [x] [GraphQL](https://cheatsheetseries.owasp.org/cheatsheets/GraphQL_Cheat_Sheet.html) (api-endpoint) - [x] [gRPC Security](https://cheatsheetseries.owasp.org/cheatsheets/gRPC_Security_Cheat_Sheet.html) (api-endpoint) - [x] [WebSocket Security](https://cheatsheetseries.owasp.org/cheatsheets/WebSocket_Security_Cheat_Sheet.html) (api-endpoint) --- ## 31. Cloud, container, dan infrastruktur Konfigurasi container dan workload adalah config-as-code yang dikirim developer bersama aplikasinya (`Dockerfile`, Compose, `securityContext` milik Pod), permukaan nyata yang diperbaiki oleh `harden` dan dibuktikan oleh `verify`, jadi masuk dalam cakupan. Administrasi cluster (RBAC, etcd, API server, admission, segmentasi jaringan) adalah ranah operator dan tetap di luar cakupan. - [x] [Docker Security](https://cheatsheetseries.owasp.org/cheatsheets/Docker_Security_Cheat_Sheet.html), [Node.js Docker](https://cheatsheetseries.owasp.org/cheatsheets/NodeJS_Docker_Cheat_Sheet.html) (container) - [x] [Kubernetes Security](https://cheatsheetseries.owasp.org/cheatsheets/Kubernetes_Security_Cheat_Sheet.html) (container: bagian workload dan Pod. Administrasi cluster tetap di luar cakupan) - [x] [Serverless / FaaS Security](https://cheatsheetseries.owasp.org/cheatsheets/Serverless_FaaS_Security_Cheat_Sheet.html) (serverless) --- ## 32. Rantai pasok dan CI/CD - [x] [NPM Security](https://cheatsheetseries.owasp.org/cheatsheets/NPM_Security_Cheat_Sheet.html) (interpreter) - [x] [Dependency Graph & SBOM Best Practices](https://cheatsheetseries.owasp.org/cheatsheets/Dependency_Graph_SBOM_Cheat_Sheet.html), [Vulnerable Dependency Management](https://cheatsheetseries.owasp.org/cheatsheets/Vulnerable_Dependency_Management_Cheat_Sheet.html) (interpreter) --- ## 33. Secret dan konfigurasi Manajemen secret bersifat operasional: vault, CI/CD, konfigurasi cloud, rotasi. Satu-satunya sisi di level kode (secret yang hardcoded di kode sumber) adalah pemindaian deterministik, bukan spesialisasi risiko. Dipindahkan ke "Di luar cakupan". --- ## 34. Proses, desain, dan tata kelola Perlindungan privasi pengguna adalah urusan kebijakan dan desain (minimalisasi data, transparansi, retensi), bukan permukaan kode yang dipertahankan sebuah spesialisasi. Dipindahkan ke "Di luar cakupan". --- ## 35. Pembayaran dan kepatuhan - [x] [Secure Integration of Third-Party Payment Gateways](https://cheatsheetseries.owasp.org/cheatsheets/Third_Party_Payment_Gateway_Integration_Cheat_Sheet.html) (payment) --- ## 36. Sistem embedded, IoT, dan domain khusus Keamanan otomotif dan drone adalah domain sistem embedded (CAN bus, firmware OTA, integritas sensor dan radio, akses fisik), bukan kode sumber aplikasi web atau API yang diaudit Lagune. Dipindahkan ke "Di luar cakupan". --- ## Di luar cakupan (tanpa permukaan kode) Item berikut bukan wilayah spesialisasi dan tidak punya kotak centang: semuanya berupa tata kelola, proses, hardening operasional, atau penggunaan framework, tanpa satu permukaan kode yang bisa dipertahankan oleh spesialisasi per permukaan. Nilai keamanannya nyata, tetapi letaknya di proses dan arsitektur (atau, untuk framework, di skill bahasa itu sendiri), bukan di pertahanan yang dibawa katalog ini. Dicantumkan sebagai referensi, bukan sebagai pekerjaan. - [Authorization Regression Testing](https://cheatsheetseries.owasp.org/cheatsheets/Authorization_Regression_Testing_Cheat_Sheet.html), [Authorization Testing Automation](https://cheatsheetseries.owasp.org/cheatsheets/Authorization_Testing_Automation_Cheat_Sheet.html) - [JAAS](https://cheatsheetseries.owasp.org/cheatsheets/JAAS_Cheat_Sheet.html) - [Denial of Service](https://owasp.org/www-community/attacks/Denial_of_Service), [Denial of Service](https://cheatsheetseries.owasp.org/cheatsheets/Denial_of_Service_Cheat_Sheet.html) - [HTTP/2 Reset Attack](https://owasp.org/www-community/attacks/HTTP2_Reset_Attack) - [Traffic flood](https://owasp.org/www-community/attacks/Traffic_flood) - [Web Service Amplification Attack](https://owasp.org/www-community/attacks/web_service_amplificaiton) (amplifikasi SOAP dan WS-Addressing, varian DoS operasional tanpa permukaan kode) - [Cash Overflow](https://owasp.org/www-community/attacks/Cash_Overflow) - [Spyware](https://owasp.org/www-community/attacks/Spyware), [Trojan Horse](https://owasp.org/www-community/attacks/Trojan_Horse) (malware di sisi pengguna akhir, bukan permukaan kode di proyek yang diaudit. Sisi penyebarannya lewat browser ada di `browser`) - [REST Security](https://cheatsheetseries.owasp.org/cheatsheets/REST_Security_Cheat_Sheet.html), [REST Assessment](https://cheatsheetseries.owasp.org/cheatsheets/REST_Assessment_Cheat_Sheet.html) - [Web Service Security](https://cheatsheetseries.owasp.org/cheatsheets/Web_Service_Security_Cheat_Sheet.html) - [Cloud Architecture Security](https://cheatsheetseries.owasp.org/cheatsheets/Secure_Cloud_Architecture_Cheat_Sheet.html) (desain dan trade-off: IAM versus signed URL, VPC publik dan privat, batas kepercayaan, tanggung jawab bersama. Berbeda dengan `container`, tidak ada konfigurasi konkret yang bisa diperiksa sebuah spesialisasi) - [Infrastructure as Code Security](https://cheatsheetseries.owasp.org/cheatsheets/Infrastructure_as_Code_Security_Cheat_Sheet.html) (meski namanya begitu, isinya adalah proses SDLC dan tooling untuk _mengelola_ IaC: plugin IDE, analisis statis, pemindaian image, CI/CD, penandatanganan. Tidak ada pola tidak aman yang diubah ke bentuk aman di dalam file Terraform atau CloudFormation) - [Kubernetes Security](https://cheatsheetseries.owasp.org/cheatsheets/Kubernetes_Security_Cheat_Sheet.html) (_hanya bagian administrasi cluster_: RBAC, etcd, API server, admission. Bagian workload dan Pod masuk cakupan di bawah `container`) - [Network Segmentation](https://cheatsheetseries.owasp.org/cheatsheets/Network_Segmentation_Cheat_Sheet.html) (arsitektur jaringan dan kebijakan firewall) - [Subdomain Takeover Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Subdomain_Takeover_Prevention_Cheat_Sheet.html) (siklus hidup dan pemantauan DNS, bukan kode) - [Secrets Management](https://cheatsheetseries.owasp.org/cheatsheets/Secrets_Management_Cheat_Sheet.html) (vault, CI/CD, rotasi. Sisi secret yang hardcoded adalah pemindaian deterministik, bukan spesialisasi risiko) - [C-Based Toolchain Hardening](https://cheatsheetseries.owasp.org/cheatsheets/C-Based_Toolchain_Hardening_Cheat_Sheet.html) (flag compiler, linker, dan build, tanpa sink di kode sumber) - [Microservices Security](https://cheatsheetseries.owasp.org/cheatsheets/Microservices_Security_Cheat_Sheet.html), [Microservices based Security Arch Doc](https://cheatsheetseries.owasp.org/cheatsheets/Microservices_based_Security_Arch_Doc_Cheat_Sheet.html) - [Zero Trust Architecture](https://cheatsheetseries.owasp.org/cheatsheets/Zero_Trust_Architecture_Cheat_Sheet.html) - [CI/CD Security](https://cheatsheetseries.owasp.org/cheatsheets/CI_CD_Security_Cheat_Sheet.html), [GitHub Actions Security](https://cheatsheetseries.owasp.org/cheatsheets/GitHub_Actions_Security_Cheat_Sheet.html) - [Software Supply Chain Security](https://cheatsheetseries.owasp.org/cheatsheets/Software_Supply_Chain_Security_Cheat_Sheet.html) - [Error Handling](https://cheatsheetseries.owasp.org/cheatsheets/Error_Handling_Cheat_Sheet.html), [Full Path Disclosure](https://owasp.org/www-community/attacks/Full_Path_Disclosure) (konfigurasi error handler global per stack. Kebocorannya adalah pengungkapan yang sama yang sudah diatur oleh penanganan error) - [Abuse of Functionality](https://owasp.org/www-community/attacks/Abuse_of_Functionality), [Business Logic Security](https://cheatsheetseries.owasp.org/cheatsheets/Business_Logic_Security_Cheat_Sheet.html), [Abuse Case _(historical)_](https://cheatsheetseries.owasp.org/cheatsheets/Abuse_Case_Cheat_Sheet.html) (desain yang spesifik untuk tiap aplikasi, tanpa satu sink di kode) - [User Privacy Protection](https://cheatsheetseries.owasp.org/cheatsheets/User_Privacy_Protection_Cheat_Sheet.html) (minimalisasi data, transparansi, kebijakan retensi) - [Top 10 Automotive Security Vulnerabilities](https://cheatsheetseries.owasp.org/cheatsheets/Automotive_Security_Cheat_Sheet.html), [Drone Security](https://cheatsheetseries.owasp.org/cheatsheets/Drone_Security_Cheat_Sheet.html) (domain sistem embedded: CAN bus, firmware OTA, integritas sensor dan radio, bukan kode sumber web atau API) - [Mobile Application Security](https://cheatsheetseries.owasp.org/cheatsheets/Mobile_Application_Security_Cheat_Sheet.html) (hardening platform Android dan iOS: penyimpanan, biometrik, pinning, PII. Tidak punya satu permukaan kode, dan sisi pemuatan kode tidak tepercaya dipindahkan ke `interpreter`) - [Threat Modeling](https://cheatsheetseries.owasp.org/cheatsheets/Threat_Modeling_Cheat_Sheet.html), [Threat Modeling _(community page)_](https://owasp.org/www-community/Threat_Modeling) - [Attack Surface Analysis](https://cheatsheetseries.owasp.org/cheatsheets/Attack_Surface_Analysis_Cheat_Sheet.html) - [Secure Product Design](https://cheatsheetseries.owasp.org/cheatsheets/Secure_Product_Design_Cheat_Sheet.html) - [Secure Code Review](https://cheatsheetseries.owasp.org/cheatsheets/Secure_Code_Review_Cheat_Sheet.html) - [Virtual Patching](https://cheatsheetseries.owasp.org/cheatsheets/Virtual_Patching_Cheat_Sheet.html) - [Vulnerability Disclosure](https://cheatsheetseries.owasp.org/cheatsheets/Vulnerability_Disclosure_Cheat_Sheet.html) - [Legacy Application Management](https://cheatsheetseries.owasp.org/cheatsheets/Legacy_Application_Management_Cheat_Sheet.html) - [Security Terminology](https://cheatsheetseries.owasp.org/cheatsheets/Security_Terminology_Cheat_Sheet.html) --- # /lagune-repair: perbaiki pelacakan temuan yang rusak > Perbaiki rantai saat file yang diganti namanya atau dipindahkan mengacaukan pelacakan Lagune. Kanonis: https://lagune.ai/id-ID/docs/commands/repair Bahasa: id-ID Asli: https://lagune.ai/docs/commands/repair Terakhir diperbarui: 2026-11-06 🧰 Perbaiki rantai saat file yang diganti namanya atau dipindahkan mengacaukannya. **Pemeliharaan internal, bukan fase keamanan** Repair bukan fase keenam dalam alur linear. Tugasnya menjaga pelacakan tetap koheren. ```prompt # Tidak menerima input: selalu memperbaiki seluruh rantai /lagune-repair ``` ## Cara kerjanya Setiap temuan detect adalah satu item yang dilacak dan dibawa terus oleh plan, harden, dan verify, yang masing-masing menindaklanjutinya dan melaporkannya kembali dengan namanya. Nama itu, yang ditulis persis sama sebagai judul bagian di setiap artefak, menjadi identitasnya dari awal sampai akhir. Satu-satunya hal yang mudah berubah yang disimpan pelacakan adalah path file yang ditunjuk item tersebut. Path itu tidak disimpan di tempat lain, jadi file yang diganti namanya atau dipindahkan hanya bisa memutus tautannya di sana, tidak pernah di dua salinan yang saling berbeda. Saat itu terjadi, repair memperbaiki peta (`.lagune/tracking.json`) agar identitas item tetap bertahan setelah penggantian nama. Repair membaca artefak dan peta pelacakan, membaca kode sumber Anda hanya untuk mengetahui path baru dari file yang diganti namanya, dan tidak pernah menulis konten keamanan. Dalam proses yang sama, repair memeriksa setiap artefak memori terhadap templatnya dan melaporkan apa yang menyimpang, sambil menunjukkan fase yang bertugas memperbaiki setiap penyimpangan. **Tips** - Repair tidak menyentuh kode Anda maupun artefak berbentuk prosa, hanya pelacakan. - Anda jarang perlu menjalankannya secara manual. Saat sebuah fase mendapati rantainya tidak konsisten, fase itu menjalankan repair untuk Anda lalu melanjutkan pekerjaannya. - Pelacakan yang dikelolanya ada di `.lagune/tracking.json`, state internal yang tidak pernah Anda edit secara manual. --- # Migrate: pindahkan proyek Lagune berbasis manifest ke skill dan plugin > Pindahkan proyek Lagune berbasis manifest ke Lagune berbasis skill, dengan tetap mempertahankan charter, artefak, pelacakan, dan spesialisasi milik Anda sendiri. Kanonis: https://lagune.ai/id-ID/docs/commands/migrate Bahasa: id-ID Asli: https://lagune.ai/docs/commands/migrate Terakhir diperbarui: 2026-11-06 🔀 Pindahkan proyek **Lagune** berbasis manifest ke **Lagune** berbasis skill, dengan tetap mempertahankan semua yang sudah Anda tulis. **Pemberitahuan usang** Proyek dengan manifest tetap berfungsi seperti apa adanya sampai `v1.x`: `npx lagune` meneruskan `init`, `pull`, `update`, `add`, `remove`, `list`, dan dasbor ke `lagune@0.15.0`, versi terakhir yang berbasis manifest. ## Cara migrasi 1. Pastikan pekerjaan Anda saat ini sudah di-commit, lalu jalankan migrate dari root proyek: ```bash npx lagune migrate ``` 2. Commit hanya apa yang diubahnya, agar migrasi tetap menjadi satu perubahan yang bisa ditinjau. 3. Instal perintah untuk agen Anda, seperti yang ditunjukkan di [halaman instalasi](https://lagune.ai/id-ID/docs). 4. Jika proyek sudah punya artefak detect, plan, atau harden, minta [`/lagune-repair`](https://lagune.ai/id-ID/docs/commands/repair) untuk menyelaraskan referensi lama di dalamnya dan di spesialisasi milik Anda sendiri: ```prompt /lagune-repair Selaraskan spesialisasi yang diterapkan (sebelumnya disebut sub-skill) di artefak dalam `.lagune/memory/` (`detect.md`, `plan.md`, dan `harden.md`) dengan nama yang tercantum di katalog baru, lalu tulis ulang setiap panggilan yang dilakukan spesialisasiku sendiri di `.lagune/catalog/` ke hook lama di `.lagune/hooks/` menjadi panggilan ke tool `lagune_read` atau `lagune_write`. ``` ## Apa yang berubah | Sebelum | Sesudah | | ------------------------------------------------------------------------ | --------------------------------------------------------------------------------------- | | `.lagune/templates/`, `.lagune/hooks/`, dan `.lagune/specializations.md` | Dihapus: setiap skill membawa templatnya sendiri, dan engine menjalankan hook | | Salinan spesialisasi bawaan di `.lagune/skills/` | Dihapus: engine menyediakan spesialisasi bawaan | | Spesialisasi milik Anda sendiri di `.lagune/skills/` | Dipindahkan ke `.lagune/catalog/` | | `.lagune/skills.json`, indeks spesialisasi milik Anda sendiri | Digabungkan ke `.lagune/configs.json` | | Kategori di manifest | Dicatat di `.lagune/configs.json` | | Perintah agen yang lama, seperti `/lagune.detect` | Dihapus: [menginstal **Lagune**](https://lagune.ai/id-ID/docs) membawa perintah baru, seperti `/lagune-detect` | | Blok **Lagune** di `.gitignore` | Dihapus, bersama file-nya jika tidak berisi apa pun lagi | | `.lagune/proofs/`, yang diabaikan oleh blok itu | Dijauhkan dari commit oleh `.gitignore` miliknya sendiri | | `.lagune/manifest.json` | Dihapus, paling akhir | Pekerjaan keamanan Anda tetap seperti semula: charter, artefak yang dihasilkan setiap fase, dan peta pelacakan beserta path yang ditunjuk setiap temuan. ## Pertanyaan yang sering diajukan ### Apakah saya wajib migrasi? Ya. Proyek berbasis manifest sudah usang dan hanya tetap berfungsi sampai v1.x, jadi jalankan npx lagune migrate untuk memindahkan proyek Anda. ### Apa saja yang dipertahankan migrate? Charter Anda, setiap artefak fase, peta pelacakan, kategori Anda, dan spesialisasi milik Anda sendiri. Spesialisasi dipindahkan ke .lagune/catalog/, dan indeksnya digabungkan bersama kategori Anda di .lagune/configs.json. ### Kapan saya perlu menginstal perintah baru? Setelah migrate, seperti yang ditunjukkan halaman instalasi untuk agen Anda. Menginstal lebih dulu juga bisa, karena migrate mempertahankan /lagune yang baru. ### Rekan tim saya sudah migrasi. Apa yang perlu saya jalankan? Lakukan pull atas perubahan migrasinya, lalu jalankan npx lagune migrate sekali. Perintah ini menghapus sisa Lagune berbasis manifest di clone Anda, yang memang tidak pernah dibawa oleh version control, dan menjauhkan pembuktian Anda dari commit.