# Lagune > Her kod tabanı için Security-Driven Hardening Lagune, açık kaynak ve yalnızca savunma odaklı bir Security-Driven Hardening (SDH) iş akışıdır. Yapay zeka ajanınızın, hangi dilde olursa olsun her kod tabanını her aşamada sıkılaştırmasına yardımcı olur: charter, siz geliştirmeye başlamadan güvenlik kurallarını belirler, evrensel /lagune komutu işi yazılırken sıkılaştırır, beş fazlı Blue Team akışı da sisteminizin gerçekte ne yaptığını tespit edip o bağlam için önemli olan düzeltmeleri yürütür. Komutları skills CLI aracıyla ajanınıza kurulur ve API anahtarı gerektirmez. --- # Kurulum: her yapay zeka ajanı için güvenlik sıkılaştırması > Lagune'yi her projeye kurun, ajanınız destekliyorsa eklenti olarak, desteklemiyorsa skills CLI aracıyla, ardından projenize uyan güvenlik uzmanlıklarını seçin. Kanonik URL: https://lagune.ai/tr-TR/docs Dil: tr-TR Orijinal: https://lagune.ai/docs Son güncelleme: 2026-11-03 **Lagune**, yapay zeka ajanınızın bir projeyi daha güvenli hale getirmesine yardım eder. Ona kodunuzu gösterirsiniz, ajan sisteminizin gerçekte ne yaptığını çıkarır ve ardından o sistem için önemli olan güvenlik çalışmasında size yol gösterir. **Lagune**, [Security-Driven Hardening (SDH)](https://lagune.ai/tr-TR/docs/references/paper) metodolojisinin ilk projesidir. **Açık kaynağı destekleyin** **Lagune**'yi sevdiniz mi? [**GitHub**'da bize bir ⭐ verin](https://github.com/wellwelwel/lagune) ## Ajanınızı seçin - [Claude Code](https://lagune.ai/tr-TR/docs/install/claude-code): Anthropic'in ajan tabanlı kodlama aracı - [Codex](https://lagune.ai/tr-TR/docs/install/codex): OpenAI'ın kodlama ajanı - [Cursor](https://lagune.ai/tr-TR/docs/install/cursor): Yapay zeka destekli kod editörü - [GitHub Copilot](https://lagune.ai/tr-TR/docs/install/github-copilot-cli): GitHub'ın yapay zeka destekli eşli programlama asistanı - [Gemini CLI](https://lagune.ai/tr-TR/docs/install/gemini-cli): Google'ın açık kaynak terminal ajanı - [Antigravity](https://lagune.ai/tr-TR/docs/install/antigravity-cli): Google'ın ajan tabanlı geliştirme platformu - [OpenCode](https://lagune.ai/tr-TR/docs/install/opencode): Açık kaynak kodlama ajanı - [Devin for Terminal](https://lagune.ai/tr-TR/docs/install/devin-cli): Cognition'ın terminal ajanı - [Factory Droid](https://lagune.ai/tr-TR/docs/install/factory-droid): Factory'nin yazılım geliştirme ajanı - [Grok Build](https://lagune.ai/tr-TR/docs/install/grok-build): xAI'ın kodlama ajanı - [Qwen Code](https://lagune.ai/tr-TR/docs/install/qwen-code): Qwen'in terminal kodlama ajanı - [Kimi Code](https://lagune.ai/tr-TR/docs/install/kimi-code): Moonshot AI'ın kodlama ajanı - [Muse Code](https://lagune.ai/tr-TR/docs/install/muse-code): Meta'nın kodlama ajanı - [Pi](https://lagune.ai/tr-TR/docs/install/pi): Minimal bir terminal kodlama ajanı - [Hermes Agent](https://lagune.ai/tr-TR/docs/install/hermes-agent): Nous Research imzalı açık kaynak ajan - [Evrensel](https://lagune.ai/tr-TR/docs/install/universal): Cline, Kiro CLI, Windsurf, Zed ve 66 ajan daha **Bilgi** - **Lagune** arka planda **Node.js** üzerinde çalışır, ama siz istediğiniz dili kullanırsınız. - Tamamen çevrimdışı çalışmak için **Lagune**'yi projenize `npm i -D lagune@0.16.0` ile kurun. ## Kategoriler **Lagune**'nin güvenlik bilgisi, [**kategoriler**](https://lagune.ai/tr-TR/docs/categories) halinde gruplanan [**uzmanlıklar**](https://lagune.ai/tr-TR/docs/catalog) olarak gelir. - **OWASP** (`owasp`): OWASP'ın takip ettiği uygulama güvenliği risklerine karşı sıkılaştırır: enjeksiyon, bozuk erişim kontrolü, kimlik doğrulama ve kriptografi hataları - **Altyapı** (`infra`): Konteyner, iş yükü ve serverless yapılandırmasını sıkılaştırır: Dockerfile, Compose, Pod güvenliği, FaaS IAM ve tetikleyicileri - **Yapay zeka / LLM** (`ai`): Yapay zeka ve LLM entegrasyonlarını prompt injection'a ve güvensiz araç, ajan, retrieval ve MCP bağlantılarına karşı sıkılaştırır - **Lovable** (`lovable`): Yapay zekayla üretilmiş Supabase uygulamalarını (Lovable ve benzerleri) sıkılaştırır: RLS boşlukları, sızdırılmış service_role anahtarları ve güvensiz varsayılanlar - **JavaScript** (`javascript`): JavaScript'i ve çalışma ortamlarını eval ve child_process kaynaklı RCE'ye, path traversal'a ve prototype pollution'a karşı sıkılaştırır - **Python** (`python`): Python kodunu pickle ve YAML ile seri durumdan çıkarma kaynaklı RCE'ye, str.format ile string traversal'a ve class pollution'a karşı sıkılaştırır - **Rust** (`rust`): Rust kodunu sağlam olmayan unsafe API'lere, hatalı transmute kullanımına, tamsayı taşmasına ve FFI sınırındaki tanımsız davranışa karşı sıkılaştırır - **Java** (`java`): Java kodunu, uzaktan kod çalıştırmayla sonuçlanan ObjectInputStream seri durumdan çıkarma gadget zincirlerine karşı sıkılaştırır - **Ruby** (`ruby`): Ruby kodunu, uzaktan kod çalıştırmaya varan Marshal.load ve YAML seri durumdan çıkarma gadget zincirlerine karşı sıkılaştırır - **PHP** (`php`): PHP kodunu type juggling ile kimlik doğrulama atlatmaya, object injection gadget zincirlerine ve güvensiz varsayılan yapılandırmalara karşı sıkılaştırır - **Go** (`go`): Go kodunu typed nil arayüz hatalarına, goroutine'ler arasındaki data race'lere ve güvenlik açısından kritik yollardaki güvensiz eşzamanlılığa karşı sıkılaştırır - **C / C++** (`c-cpp`): C ve C++ kodunu, kod çalıştırmaya imkan veren format string hatalarına, arabellek taşmalarına ve sınır dışı yazmalara karşı sıkılaştırır - **.NET** (`dotnet`): .NET ve C# kodunu, BinaryFormatter ile seri durumdan çıkarma kaynaklı RCE'ye ve XSS'e varan kodlayıcı atlatmalarına karşı sıkılaştırır Seçtiğiniz kategorilerin anahtarlarıyla `npx lagune write add --categories` komutunu çalıştırın. **İpucu** Bir proje `owasp` ile başlar ve [`/lagune-charter`](https://lagune.ai/tr-TR/docs/commands/charter) komutu, projeyi okuyarak gerekçelendirebildiği kategorileri ekler. ## Gereksinimler Sisteminizde [**Node.js (LTS)**](https://nodejs.org/en/download/package-manager) kurulu olmalıdır. ## Rozet kullanın ✨ **Lagune** kullanıyor musunuz? **README** dosyanıza bir rozet ekleyin: **İki tonlu** ![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) ``` **Düz renk** ![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) ``` ## Sırada ne var **Lagune**'nin [**becerilerinin**](https://lagune.ai/tr-TR/docs/get-started/commands) her birinin ne yaptığını görün. ## Sıkça sorulan sorular ### Lagune nedir? Lagune, yapay zeka ajanınızın her kod tabanını sıkılaştırmasına yardım eden, açık kaynaklı ve yalnızca savunma odaklı bir güvenlik iş akışıdır. Ona kodunuzu gösterirsiniz, sisteminizin gerçekte ne yaptığını tespit eder, ardından o bağlam için önemli olan güvenlik düzeltmelerinde yol gösterir. ### Lagune nasıl kurulur? Ajanınızı seçin: Claude Code, GitHub Copilot CLI, Muse Code, Antigravity CLI, Cursor, Kimi Code, OpenCode, Codex CLI, Factory Droid, Grok Build, Devin CLI ve Hermes Agent, Lagune'yi eklenti olarak kurar, Gemini CLI ve Qwen Code uzantı olarak, Pi paket olarak kurar, diğer tüm ajanlar ise npx skills add wellwelwel/lagune ile kurar. Lagune yeni projelerde de mevcut projelerde de çalışır. ### Lagune için API anahtarı gerekir mi? Hayır. Kendi yapay zeka ajanınız üzerinden çalışır, bu yüzden hiçbir API anahtarı gerekmez. ### Gereksinimler nelerdir? Sisteminizde Node.js (LTS) kurulu olmalıdır. ### Lagune hangi programlama dillerini destekler? Hepsini. Lagune arka planda Node.js üzerinde çalışır, ama hangi programlama dilinde yazılmış olursa olsun projeleri denetler ve sıkılaştırır. ### Lagune projeme ne ekler? Projenizin güvenlik durumunu tutan, yazma yapan ilk komutun oluşturduğu bir .lagune/ dizini. skills CLI aracı ayrıca slash komutlarını projeye, ajanınızın onları okuduğu yere kurar, eklenti ise onları ajanın içinde tutar. ### Lagune nasıl güncellenir? Kurduğunuz şekilde. Her ajanın kurulum sayfası Lagune'nin orada nasıl güncelleneceğini gösterir, skills CLI aracı ise onu npx skills update ile günceller. Güvenlik ilkeleriniz, faz artefaktlarınız ve kendi uzmanlıklarınız olduğu gibi kalır. ### Bir proje hangi uzmanlıkları kullanır? Kategorilerinin yerleşik uzmanlıklarını ve kendi uzmanlıklarını. charter fazı, projeyi okuyarak gerekçelendirebildiği kategorileri kaydeder, npx lagune write add --categories ise onları değiştirir. ### Projemi güvenli hale getirmeden önce geliştirmeyi bitirmem gerekir mi? Hayır. /lagune komutu, iş yazılırken onu sıkılaştırır: her prompt kabul eder, istediğinizi geliştirir ve güvenlik ilkelerinin rehberliğinde güvenli varsayılanlarla sıkılaştırır. Beş fazlı Blue Team akışı ise zaten var olanı denetler. ### Lagune mevcut bir projeyi denetleyebilir mi? Evet. Beş fazlı Blue Team akışı zaten var olanı denetler: charter güvenlik kurallarınızı belirler, detect sistemin ne yaptığını ve risklerin nerede olduğunu çıkarır, plan her bulguyu puanlayıp bir düzeltmeyle eşleştirir, harden düzeltmeleri uygular, verify ise işe yaradıklarını kanıtlayıp onları kapatır. ### Lagune kullanmakla ajandan güvenlik açıklarını ve güvenlik kusurlarını çıkarmasını istemek arasındaki fark nedir? Kendi başına okuyan bir ajan, güvenlik açığına benzeyeni bulur ve kontrole benzeyeni atlar. Engellenen adreslerin bir listesi, riski birisi zaten halletmiş gibi görünür, bu yüzden kimse adreslerin çoğunu kaçırdığını kontrol etmez ve kod yayına çıkar. Lagune bu varsayılanı tersine çevirir: kodda zaten bulunan bir koruma, kontrol edilene kadar kanıtlanmamış sayılır, katalogdaki her uzmanlık açık bir karar alır ve verify, bir kontrolün var olup olmadığını değil, riskin ortadan kalkıp kalkmadığını sorar. Her bulgu ayrıca çalıştırmalar boyunca takip edilen tek bir öğe olarak kalır, böylece kapandığı kanıtlanıp takipten çıkarılabilir. Sıradan bir istek ise size her seferinde, karşılaştıracak hiçbir şey bırakmayan farklı bir rapor verir. ### Lagune ile geliştirmekle ajandan güvenli kod yazmasını istemek arasındaki fark nedir? Güvenli kod istemek, güvenlinin tanımını ajana bırakır ve neyi isteyeceğinizi bildiğinizi varsayar. Gereksinim çoğu zaman, ikiniz de görmeden, isteğinizin içinde zaten vardır: bir kullanıcının erişebildiği kursları gösteren bir sayfa istemek bir yetkilendirme kuralı koyar ve hiç yazılmayan bir kontrol, kodda fark edilecek hiçbir şey bırakmaz. /lagune komutu, ilk satır yazılmadan önce güvenlik ilkelerinizi ve geliştirilmek üzere olan şeye uyan uzmanlıkları yükler, ardından sonucu kullandığı savunmaya göre yeniden okur. Güvenli yol, güvensiz olandan nadiren daha pahalıdır, bu yüzden sonucu belirleyen hangisine uzanılacağını bilmektir ve en başta gelen de tam olarak budur. ### Lagune DAST (Dynamic Application Security Testing) çalıştırır mı, ya da çalışan uygulamamı test eder mi? Hayır. Lagune kodu okur, sisteminizi asla çalıştırmaz ve ona özel hazırlanmış istekler göndermez. Verify, bir kontrolün kaynak kodda var ve doğru olduğunu teyit eder. Bu, kontrolün canlı bir hedefe yapılan saldırıya dayanıp dayanmadığından farklı bir sorudur, bu yüzden "Cannot tell from the code" sessiz bir onay yerine meşru bir karardır. DAST çalışma zamanı sorusunu, Lagune ise kaynak kod sorusunu yanıtlar, yani biri diğerinin yerini tutmaz. İsteğe bağlı prove komutu bile bu çizgiyi korur: testleri saldırı payload'unu değil, güvenli davranışı doğrular. ### Lagune bir pentest (sızma testi) yerine geçer mi? Hayır, kesinlikle hayır! Pentest, bir uzmanın canlı sisteminiz üzerinde kendi muhakemesini kullandığı, bulguları birbirine zincirlediği ve hiçbir yüzey kuralının tarif etmediği iş mantığını yokladığı yetkili bir çalışmadır. Bir pentest'in bulguları, detect fazına verdiğiniz endişeler olarak Lagune Blue Team akışına girebilir, böylece bir uzmanın raporladıkları planlanır, sıkılaştırılır ve doğrulanır. ## Güvenlik politikası Lütfen [SECURITY.md](https://github.com/wellwelwel/lagune/blob/main/SECURITY.md) dosyasına göz atın. ## Lisans **Lagune**, [Apache License 2.0](https://github.com/wellwelwel/lagune/blob/main/LICENSE) ile lisanslanmıştır. Telif hakkı © 2026-günümüz [Weslley Araújo](https://github.com/wellwelwel) ve [katkıda bulunanlar](https://github.com/wellwelwel/lagune/graphs/contributors). --- # Antigravity CLI için Lagune eklentisi kurulumu > Lagune'yi Antigravity CLI için eklenti olarak kurun, güncel tutun ve motoruna baştan izin verin. Kanonik URL: https://lagune.ai/tr-TR/docs/install/antigravity-cli Dil: tr-TR Orijinal: https://lagune.ai/docs/install/antigravity-cli Son güncelleme: 2026-11-03 Eklentiyi terminalden kurun: ```bash agy plugin install https://github.com/wellwelwel/lagune/tree/plugin-antigravity ``` ## Güncelleme **Lagune**'yi güncellemek için yeniden kurun: ```bash agy plugin install https://github.com/wellwelwel/lagune/tree/plugin-antigravity ``` ## Komutlar Komutları eklentinin adıyla birlikte yazın, örneğin `/lagune:lagune-charter` yazarak `/lagune-charter` komutunu çalıştırın. --- **İzinler** Motor iki araçla çalışır: `lagune_read` yalnızca projenizi okur, `lagune_write` ise yalnızca `.lagune/` klasörüne yazar. Bir oturumun ilk mesajı olarak gönderilen komut bu araçlar yüklenmeden önce çalıştığı için onların yerine **npx** kullanır. Araçlara ve **npx**'e baştan izin vermek için bu kuralları `~/.gemini/antigravity-cli/settings.json` dosyasına ekleyin: ```json { "permissions": { "allow": [ "mcp(lagune_lagune/lagune_read)", "mcp(lagune_lagune/lagune_write)", "command(regex:npx --yes lagune@[0-9.]+)" ] } } ``` ## Sıkça sorulan sorular ### Antigravity CLI için Lagune nasıl kurulur? agy plugin install https://github.com/wellwelwel/lagune/tree/plugin-antigravity komutunu çalıştırın. ### Antigravity CLI kullanırken Lagune nasıl güncellenir? agy plugin install https://github.com/wellwelwel/lagune/tree/plugin-antigravity komutunu yeniden çalıştırın. ### Antigravity CLI kullanırken Lagune komutları nasıl çalıştırılır? Eklentinin adıyla birlikte yazın, örneğin /lagune:lagune-charter. ### Antigravity CLI, Lagune'yi izin istemeden çalıştırabilir mi? Evet. Antigravity CLI ayarlarında mcp(lagune_lagune/lagune_read), mcp(lagune_lagune/lagune_write) ve command(regex:npx --yes lagune@[0-9.]+) için izin verin. npx kuralı, bir oturumun ilk mesajı olarak gönderilen komutu kapsar. --- # Claude Code için Lagune eklentisi kurulumu > Lagune'yi Claude Code için eklenti olarak terminalden, uzantıdan veya masaüstü uygulamasından kurun, güncel tutun ve motoruna baştan izin verin. Kanonik URL: https://lagune.ai/tr-TR/docs/install/claude-code Dil: tr-TR Orijinal: https://lagune.ai/docs/install/claude-code Son güncelleme: 2026-11-03 **Terminal** Eklentiyi terminalden kurun: ```bash claude plugin install lagune --marketplace wellwelwel/lagune ``` Ya da bir **Claude Code** oturumundan kurun: ```text /plugin marketplace add wellwelwel/lagune /plugin install lagune@lagune ``` **Uzantı** - `/plugin` yazıp **Manage plugins** seçeneğini seçin. - **Marketplaces** sekmesinde `wellwelwel/lagune` pazar yerini ekleyin. - **Plugins** sekmesinde `lagune` eklentisini kurun. **Masaüstü** - **Lagune**'yi terminalden veya uzantıdan kurun, uzantıda **Install for you** seçeneğini seçin. - Kendiniz için kurduğunuz eklentileri yükleyen masaüstü uygulamasında yeni bir oturum başlatın. ## Güncelleme **Terminal** **Lagune**'yi güncellemek için şunu çalıştırın: ```bash claude plugin marketplace update lagune claude plugin update lagune@lagune ``` Otomatik olarak güncel kalması için `lagune` pazar yerinde, `/plugin` altındaki **Enable auto-update** seçeneğini seçin. **Uzantı** - `/plugin` yazıp **Manage plugins** seçeneğini seçin. - **Marketplaces** sekmesini açın. - `lagune` yanındaki yenileme simgesini seçin. **Masaüstü** - **Lagune**'yi terminalden veya uzantıdan güncelleyin. - Masaüstü uygulamasında yeni bir oturum başlatın. ## Komutlar Komutları adlarıyla, örneğin `/lagune-charter` şeklinde ya da eklentinin adıyla birlikte, örneğin `/lagune:lagune-charter` şeklinde yazın. --- **İzinler** Motor iki araçla çalışır: `lagune_read` yalnızca projenizi okur, `lagune_write` ise yalnızca `.lagune/` klasörüne yazar. Bunlara baştan izin vermek için bu kuralları tek bir proje için `.claude/settings.json` dosyasına, tüm projeleriniz için `~/.claude/settings.json` dosyasına ekleyin: ```json { "permissions": { "allow": [ "mcp__plugin_lagune_lagune__lagune_read", "mcp__plugin_lagune_lagune__lagune_write" ] } } ``` Motor, **skills.sh** ile kurulumda olduğu gibi **npx** üzerinden çalıştığında `Bash(npx --yes lagune@*)` için izin verin. Korumalı alan açıksa `registry.npmjs.org` adresini de `sandbox.network.allowedDomains` listesine ekleyin. ## Sıkça sorulan sorular ### Claude Code için Lagune nasıl kurulur? claude plugin install lagune --marketplace wellwelwel/lagune komutunu çalıştırın. Bir oturumda veya uzantıda, eklenti yöneticisinden wellwelwel/lagune pazar yerini ekleyip lagune eklentisini kurun. Masaüstü uygulaması, eklentiyi terminalde veya uzantıda kendiniz için kurduğunuzda onu yükler. ### Claude Code kullanırken Lagune nasıl güncellenir? claude plugin marketplace update lagune ve ardından claude plugin update lagune@lagune komutlarını çalıştırın ya da /plugin altında lagune pazar yeri için Enable auto-update seçeneğini seçin. Uzantıda /plugin üzerinden Manage plugins bölümünü açın ve lagune pazar yerinin yanındaki yenileme simgesini seçin. Masaüstü uygulaması güncellemeyi bir sonraki oturumda yükler. ### Claude Code kullanırken Lagune komutları nasıl çalıştırılır? Adlarıyla, örneğin /lagune-charter şeklinde ya da eklentinin adıyla birlikte, örneğin /lagune:lagune-charter şeklinde yazın. ### Claude Code, Lagune'yi izin istemeden çalıştırabilir mi? Evet. Claude Code ayarlarınızda mcp__plugin_lagune_lagune__lagune_read ve mcp__plugin_lagune_lagune__lagune_write için izin verin, motor npx üzerinden çalıştığında Bash(npx --yes lagune@*) için de izin verin. --- # Codex CLI için Lagune eklentisi kurulumu > Lagune'yi Codex CLI için eklenti olarak kurun, güncel tutun ve motorunu korumalı alan içinde çalıştırın. Kanonik URL: https://lagune.ai/tr-TR/docs/install/codex Dil: tr-TR Orijinal: https://lagune.ai/docs/install/codex Son güncelleme: 2026-11-03 Eklentiyi terminalden kurun: ```bash codex plugin marketplace add wellwelwel/lagune codex plugin add lagune@lagune ``` ## Güncelleme **Lagune**'yi güncellemek için şunu çalıştırın: ```bash codex plugin marketplace upgrade lagune ``` ## Komutlar `$` yazın, ardından eklentinin adıyla birlikte komutu ve girdinizi yazın, örneğin `$lagune:lagune-charter` yazarak `/lagune-charter` komutunu çalıştırın. `$` yazmak komutları listeler, birini seçmek de tam adını ekler. --- **İzinler** **Codex** korumalı alanının ağ erişimi yoktur. Motoru kendi terminalinizden projenize kurun, bir kez ve her güncellemeden sonra: ```bash npm i -D lagune@0.16.0 ``` ## Sıkça sorulan sorular ### Codex CLI için Lagune nasıl kurulur? codex plugin marketplace add wellwelwel/lagune ve ardından codex plugin add lagune@lagune komutlarını çalıştırın. ### Codex CLI kullanırken Lagune nasıl güncellenir? codex plugin marketplace upgrade lagune komutunu çalıştırın. ### Codex CLI kullanırken Lagune komutları nasıl çalıştırılır? $ yazın, ardından eklentinin adıyla birlikte komutu ve girdinizi yazın, örneğin $lagune:lagune-charter. ### Lagune, Codex korumalı alanı içinde çalışır mı? Evet, motoru kendi terminalinizden npm i -D lagune@0.16.0 ile projenize kurduğunuzda çalışır. Bunu bir kez ve her güncellemeden sonra yapın. --- # Cursor için Lagune eklentisi kurulumu > Lagune'yi Cursor ve Cursor CLI için eklenti olarak kurun, güncel tutun ve motoruna baştan izin verin. Kanonik URL: https://lagune.ai/tr-TR/docs/install/cursor Dil: tr-TR Orijinal: https://lagune.ai/docs/install/cursor Son güncelleme: 2026-11-03 **Cursor** - **Customize** bölümünü açın. - **From GitHub Repository** seçeneğini seçin ve `https://github.com/wellwelwel/lagune` adresini girin. - **Lagune** üzerinde **Install** seçeneğini seçin ve proje ya da kullanıcı kapsamını belirleyin. **Cursor CLI** - Pazar yerini terminalden ekleyin: ```bash agent plugin marketplace add https://github.com/wellwelwel/lagune --git-ref plugin-cursor ``` - `/plugins` komutunu bir `agent` oturumunda yazın. - **Lagune**'yi kurun. **Lagune** zaten **Claude Code** için kuruluysa **Cursor CLI** onu oradan yükler. ## Güncelleme **Cursor** - **Customize** bölümünü açın. - `lagune` pazar yerinde **Refresh** seçeneğini seçin. **Cursor CLI** - Pazar yerini terminalden kaldırıp yeniden ekleyin: ```bash agent plugin marketplace remove lagune agent plugin marketplace add https://github.com/wellwelwel/lagune --git-ref plugin-cursor ``` - `/plugins` komutunu bir `agent` oturumunda yazın. - **Lagune**'yi yeniden kurun. ## Komutlar Komutları adlarıyla yazın, örneğin `/lagune-charter`. --- **İzinler** **Cursor** içinde komutlar motoru, varsayılan Auto-review modunun sormadan izin verdiği **npx** üzerinden çalıştırır. **Cursor CLI** içinde motor iki araçla çalışır: `lagune_read` yalnızca projenizi okur, `lagune_write` ise yalnızca `.lagune/` klasörüne yazar. Bunlara baştan izin vermek için bu kuralları tek bir proje için `.cursor/cli.json` dosyasına, tüm projeleriniz için `~/.cursor/cli-config.json` dosyasına ekleyin: ```json { "permissions": { "allow": [ "Mcp(plugin-lagune-lagune:lagune_read)", "Mcp(plugin-lagune-lagune:lagune_write)" ] } } ``` Motor, **skills.sh** ile kurulumda olduğu gibi **npx** üzerinden çalıştığında `Shell(npx:--yes lagune@*)` için izin verin. ## Sıkça sorulan sorular ### Cursor için Lagune nasıl kurulur? Cursor içinde Customize bölümünü açın, From GitHub Repository seçeneğini seçin, https://github.com/wellwelwel/lagune adresini girin ve Lagune'yi kurun. Cursor CLI içinde agent plugin marketplace add https://github.com/wellwelwel/lagune --git-ref plugin-cursor komutunu çalıştırın, ardından Lagune'yi /plugins üzerinden kurun. ### Cursor kullanırken Lagune nasıl güncellenir? Cursor içinde Customize bölümündeki lagune pazar yerinde Refresh seçeneğini seçin. Cursor CLI içinde lagune pazar yerini kaldırıp yeniden ekleyin, ardından Lagune'yi /plugins üzerinden yeniden kurun. ### Cursor kullanırken Lagune komutları nasıl çalıştırılır? Adlarıyla yazın, örneğin /lagune-charter. ### Cursor, Lagune'yi izin istemeden çalıştırabilir mi? Evet. Cursor içindeki varsayılan Auto-review modu buna zaten izin verir. Cursor CLI içinde Mcp(plugin-lagune-lagune:lagune_read) ve Mcp(plugin-lagune-lagune:lagune_write) için izin verin, motor npx üzerinden çalıştığında Shell(npx:--yes lagune@*) için de izin verin. --- # Devin CLI için Lagune eklentisi kurulumu > Lagune'yi Devin CLI için eklenti olarak kurun ve güncel tutun. Kanonik URL: https://lagune.ai/tr-TR/docs/install/devin-cli Dil: tr-TR Orijinal: https://lagune.ai/docs/install/devin-cli Son güncelleme: 2026-11-03 **Devin** hesabınıza giriş yapın, ardından eklentiyi terminalden kurun: ```bash devin auth login devin plugins install wellwelwel/lagune ``` ## Güncelleme **Lagune**'yi güncellemek için şunu çalıştırın: ```bash devin plugins update lagune ``` ## Komutlar Komutları eklentinin adıyla birlikte yazın, örneğin `/lagune:lagune-charter` yazarak `/lagune-charter` komutunu çalıştırın. `/` menüsü de onları listeler. ## Sıkça sorulan sorular ### Devin CLI için Lagune nasıl kurulur? devin auth login ile giriş yapın, ardından devin plugins install wellwelwel/lagune komutunu çalıştırın. ### Devin CLI kullanırken Lagune nasıl güncellenir? devin plugins update lagune komutunu çalıştırın. ### Devin CLI kullanırken Lagune komutları nasıl çalıştırılır? Eklentinin adıyla birlikte yazın, örneğin /lagune:lagune-charter. / menüsü de onları listeler. --- # Factory Droid için Lagune eklentisi kurulumu > Lagune'yi Factory Droid için eklenti olarak kurun, güncel tutun ve motorunun araçlarına izin verin. Kanonik URL: https://lagune.ai/tr-TR/docs/install/factory-droid Dil: tr-TR Orijinal: https://lagune.ai/docs/install/factory-droid Son güncelleme: 2026-11-03 Eklentiyi terminalden kurun: ```bash droid plugin marketplace add wellwelwel/lagune droid plugin install lagune@lagune ``` ## Güncelleme **Lagune**'yi güncellemek için şunu çalıştırın: ```bash droid plugin marketplace update lagune droid plugin update lagune@lagune ``` ## Komutlar Komutları adlarıyla yazın, örneğin `/lagune-charter`. --- **İzinler** Motor iki araçla çalışır: `lagune_read` yalnızca projenizi okur, `lagune_write` ise yalnızca `.lagune/` klasörüne yazar. **Factory Droid** sorduğunda her biri için her zaman izin vermeyi seçin. `lagune` pazar yerinin yeni bir commit'ini eşitledikten sonra (bunu açılışta yapabilir) yeniden sorar. ## Sıkça sorulan sorular ### Factory Droid için Lagune nasıl kurulur? droid plugin marketplace add wellwelwel/lagune ve ardından droid plugin install lagune@lagune komutlarını çalıştırın. ### Factory Droid kullanırken Lagune nasıl güncellenir? droid plugin marketplace update lagune ve ardından droid plugin update lagune@lagune komutlarını çalıştırın. ### Factory Droid kullanırken Lagune komutları nasıl çalıştırılır? Adlarıyla yazın, örneğin /lagune-charter. ### Factory Droid, Lagune'yi izin istemeden çalıştırabilir mi? Evet. Factory Droid sorduğunda lagune_read ve lagune_write için her zaman izin vermeyi seçin. lagune pazar yerinin yeni bir commit'ini eşitledikten sonra yeniden sorar. --- # Gemini CLI için Lagune uzantısı kurulumu > Lagune'yi Gemini CLI için uzantı olarak kurun, güncel tutun ve motoruna baştan izin verin. Kanonik URL: https://lagune.ai/tr-TR/docs/install/gemini-cli Dil: tr-TR Orijinal: https://lagune.ai/docs/install/gemini-cli Son güncelleme: 2026-11-03 Uzantıyı terminalden kurun: ```bash gemini extensions install https://github.com/wellwelwel/lagune ``` ## Güncelleme **Lagune**'yi güncellemek için şunu çalıştırın: ```bash gemini extensions update lagune ``` Otomatik olarak güncel kalması için `--auto-update` ile kurun. ## Komutlar Komutları uzantının adıyla birlikte yazın, örneğin `/lagune:lagune-charter` yazarak `/lagune-charter` komutunu çalıştırın. --- **İzinler** Motor iki araçla çalışır: `lagune_read` yalnızca projenizi okur, `lagune_write` ise yalnızca `.lagune/` klasörüne yazar. **Gemini CLI** bunları yalnızca güvenilir bir klasörde başlatır. Bunlara baştan izin vermek için bu kuralı `~/.gemini/policies/lagune.toml` olarak kaydedin: ```toml [[rule]] mcpName = "lagune" toolName = ["lagune_read", "lagune_write"] decision = "allow" priority = 100 ``` Motor, **skills.sh** ile kurulumda olduğu gibi **npx** üzerinden çalıştığında bu kuralı aynı dosyaya ekleyin: ```toml [[rule]] toolName = "run_shell_command" commandRegex = 'npx --yes lagune@\d+\.\d+\.\d+\s' decision = "allow" priority = 100 ``` ## Sıkça sorulan sorular ### Gemini CLI için Lagune nasıl kurulur? gemini extensions install https://github.com/wellwelwel/lagune komutunu çalıştırın. ### Gemini CLI kullanırken Lagune nasıl güncellenir? gemini extensions update lagune komutunu çalıştırın ya da uzantıyı --auto-update ile kurun. ### Gemini CLI kullanırken Lagune komutları nasıl çalıştırılır? Uzantının adıyla birlikte yazın, örneğin /lagune:lagune-charter. ### Gemini CLI, Lagune'yi izin istemeden çalıştırabilir mi? Evet. lagune sunucusunun lagune_read ve lagune_write araçlarına izin veren bir politika kuralı ekleyin. Motor npx üzerinden çalıştığında run_shell_command için npx --yes lagune@ ve bir sürüm numarasıyla başlayan komutlara izin veren bir kural daha ekleyin. --- # GitHub Copilot CLI için Lagune eklentisi kurulumu > Lagune'yi GitHub Copilot CLI için eklenti olarak kurun ve güncel tutun. Kanonik URL: https://lagune.ai/tr-TR/docs/install/github-copilot-cli Dil: tr-TR Orijinal: https://lagune.ai/docs/install/github-copilot-cli Son güncelleme: 2026-11-03 Eklentiyi terminalden kurun: ```bash copilot plugin marketplace add wellwelwel/lagune copilot plugin install lagune@lagune ``` Bir editörde **GitHub Copilot** için **Lagune**'yi [**skills.sh**](https://lagune.ai/tr-TR/docs/install/universal) ile kurun. ## Güncelleme **Lagune**'yi güncellemek için şunu çalıştırın: ```bash copilot plugin marketplace update lagune copilot plugin update lagune@lagune ``` ## Komutlar Komutları adlarıyla yazın, örneğin `/lagune-charter`. ## Sıkça sorulan sorular ### GitHub Copilot CLI için Lagune nasıl kurulur? copilot plugin marketplace add wellwelwel/lagune ve ardından copilot plugin install lagune@lagune komutlarını çalıştırın. ### GitHub Copilot CLI kullanırken Lagune nasıl güncellenir? copilot plugin marketplace update lagune ve ardından copilot plugin update lagune@lagune komutlarını çalıştırın. ### GitHub Copilot CLI kullanırken Lagune komutları nasıl çalıştırılır? Adlarıyla yazın, örneğin /lagune-charter. ### Lagune'yi VS Code içinde GitHub Copilot ile kullanabilir miyim? Evet. VS Code veya başka bir editörde Lagune'yi eklenti yerine skills.sh ile kurun. --- # Grok Build için Lagune eklentisi kurulumu > Lagune'yi Grok Build için eklenti olarak kurun, güncel tutun ve motoruna baştan izin verin. Kanonik URL: https://lagune.ai/tr-TR/docs/install/grok-build Dil: tr-TR Orijinal: https://lagune.ai/docs/install/grok-build Son güncelleme: 2026-11-03 Eklentiyi terminalden kurun: ```bash grok plugin install wellwelwel/lagune@plugin-grok --trust ``` ## Güncelleme **Lagune**'yi güncellemek için şunu çalıştırın: ```bash grok plugin update lagune ``` ## Komutlar Komutları adlarıyla, örneğin `/lagune-charter` şeklinde ya da eklentinin adıyla birlikte, örneğin `/lagune:lagune-charter` şeklinde yazın. --- **İzinler** Motor iki araçla çalışır: `lagune_read` yalnızca projenizi okur, `lagune_write` ise yalnızca `.lagune/` klasörüne yazar. Bunlara baştan izin vermek için bu kuralları `~/.grok/config.toml` dosyasına ekleyin: ```toml [permission] allow = ["MCPTool(lagune__lagune_read)", "MCPTool(lagune__lagune_write)"] ``` Motor, **skills.sh** ile kurulumda olduğu gibi **npx** üzerinden çalıştığında `Bash(npx --yes lagune@*)` için izin verin. ## Sıkça sorulan sorular ### Grok Build için Lagune nasıl kurulur? grok plugin install wellwelwel/lagune@plugin-grok --trust komutunu çalıştırın. ### Grok Build kullanırken Lagune nasıl güncellenir? grok plugin update lagune komutunu çalıştırın. ### Grok Build kullanırken Lagune komutları nasıl çalıştırılır? Adlarıyla, örneğin /lagune-charter şeklinde ya da eklentinin adıyla birlikte, örneğin /lagune:lagune-charter şeklinde yazın. ### Grok Build, Lagune'yi izin istemeden çalıştırabilir mi? Evet. Grok Build yapılandırmasında MCPTool(lagune__lagune_read) ve MCPTool(lagune__lagune_write) için izin verin, motor npx üzerinden çalıştığında Bash(npx --yes lagune@*) için de izin verin. --- # Hermes Agent için Lagune eklentisi kurulumu > Lagune'yi Hermes Agent için eklenti olarak kurun ve güncel tutun. Kanonik URL: https://lagune.ai/tr-TR/docs/install/hermes-agent Dil: tr-TR Orijinal: https://lagune.ai/docs/install/hermes-agent Son güncelleme: 2026-11-03 Eklentiyi terminalden kurun: ```bash hermes plugins install wellwelwel/lagune --enable ``` - **Hermes Agent** kataloğu dışından bir eklentiyi onaylamanızı istediğinde **onaylayın**. - Deponun **Node.js** bağımlılıklarını kurmayı önerdiğinde **reddedin**. ## Güncelleme **Lagune**'yi güncellemek için şunu çalıştırın: ```bash hermes plugins update lagune ``` ## Komutlar Komutları eklentinin adıyla birlikte yazın, örneğin `/lagune:lagune-charter` yazarak `/lagune-charter` komutunu, `/lagune:lagune` yazarak `/lagune` komutunu çalıştırın. ## Sıkça sorulan sorular ### Hermes Agent için Lagune nasıl kurulur? hermes plugins install wellwelwel/lagune --enable komutunu çalıştırın. İstendiğinde eklentiyi onaylayın, deponun Node.js bağımlılıklarını kurmayı ise reddedin. ### Hermes Agent kullanırken Lagune nasıl güncellenir? hermes plugins update lagune komutunu çalıştırın. ### Hermes Agent kullanırken Lagune komutları nasıl çalıştırılır? Eklentinin adıyla birlikte yazın, örneğin /lagune:lagune-charter ve /lagune:lagune. --- # Kimi Code için Lagune eklentisi kurulumu > Lagune'yi Kimi Code için eklenti olarak kurun ve güncel tutun. Kanonik URL: https://lagune.ai/tr-TR/docs/install/kimi-code Dil: tr-TR Orijinal: https://lagune.ai/docs/install/kimi-code Son güncelleme: 2026-11-03 Eklentiyi bir **Kimi Code** oturumundan kurun, **Trust and install** seçeneğini seçin, ardından eklentiyi yüklemek için yeni bir oturum başlatın: ```text /plugins install https://github.com/wellwelwel/lagune /new ``` ## Güncelleme **Lagune**'yi güncellemek için yeniden kurun: ```text /plugins install https://github.com/wellwelwel/lagune /new ``` ## Komutlar Komutları eklentinin adıyla birlikte yazın, örneğin `/lagune:lagune-charter` yazarak `/lagune-charter` komutunu çalıştırın. `/` menüsü onları `/skill:lagune:lagune-charter` biçiminde listeler ve bu biçim de çalışır. ## Sıkça sorulan sorular ### Kimi Code için Lagune nasıl kurulur? Bir Kimi Code oturumunda /plugins install https://github.com/wellwelwel/lagune komutunu çalıştırın, Trust and install seçeneğini seçin, ardından /new komutunu çalıştırın. ### Kimi Code kullanırken Lagune nasıl güncellenir? /plugins install https://github.com/wellwelwel/lagune komutunu yeniden, ardından /new komutunu çalıştırın. ### Kimi Code kullanırken Lagune komutları nasıl çalıştırılır? Eklentinin adıyla birlikte, örneğin /lagune:lagune-charter şeklinde ya da / menüsünün listelediği gibi, örneğin /skill:lagune:lagune-charter şeklinde yazın. --- # Muse Code için Lagune eklentisi kurulumu > Lagune'yi Muse Code için eklenti olarak kurun, güncel tutun ve motorunu korumalı alan içinde çalıştırın. Kanonik URL: https://lagune.ai/tr-TR/docs/install/muse-code Dil: tr-TR Orijinal: https://lagune.ai/docs/install/muse-code Son güncelleme: 2026-11-03 Eklentiyi terminalden kurun: ```bash muse plugins marketplace add lagune wellwelwel/lagune muse plugins install lagune@lagune ``` ## Güncelleme **Lagune**'yi güncellemek için pazar yerini yenileyin ve eklentiyi yeniden kurun: ```bash muse plugins marketplace update lagune muse plugins remove lagune muse plugins install lagune@lagune ``` ## Komutlar Komutları adlarıyla, örneğin `/lagune-charter` şeklinde ya da eklentinin adıyla birlikte, örneğin `/lagune:lagune-charter` şeklinde yazın. --- **İzinler** **Muse Code** korumalı alanı motoru indiremez. Motoru kendi terminalinizden projenize kurun, bir kez ve her güncellemeden sonra: ```bash npm i -D lagune@0.16.0 ``` ## Sıkça sorulan sorular ### Muse Code için Lagune nasıl kurulur? muse plugins marketplace add lagune wellwelwel/lagune ve ardından muse plugins install lagune@lagune komutlarını çalıştırın. ### Muse Code kullanırken Lagune nasıl güncellenir? muse plugins marketplace update lagune komutunu çalıştırın, ardından muse plugins remove lagune ve muse plugins install lagune@lagune ile yeniden kurun. ### Muse Code kullanırken Lagune komutları nasıl çalıştırılır? Adlarıyla, örneğin /lagune-charter şeklinde ya da eklentinin adıyla birlikte, örneğin /lagune:lagune-charter şeklinde yazın. ### Lagune, Muse Code korumalı alanı içinde çalışır mı? Evet, motoru kendi terminalinizden npm i -D lagune@0.16.0 ile projenize kurduğunuzda çalışır. Bunu bir kez ve her güncellemeden sonra yapın. --- # OpenCode için Lagune eklentisi kurulumu > Lagune'yi OpenCode 1.x ve 2.x için eklenti olarak kurun ve güncel tutun. Kanonik URL: https://lagune.ai/tr-TR/docs/install/opencode Dil: tr-TR Orijinal: https://lagune.ai/docs/install/opencode Son güncelleme: 2026-11-03 **OpenCode 2.x** Eklentiyi terminalden kurun: ```bash opencode plugin add lagune ``` Ya da `plugins` listesine eklemek için `opencode.json` dosyasını düzenleyin: ```json { "plugins": ["lagune"] } ``` **OpenCode 1.x** Eklentiyi terminalden projenize kurun ya da tüm projeleriniz için kurmak üzere `-g` ekleyin: ```bash opencode plugin lagune ``` Ya da `plugin` listesine eklemek için `opencode.json` dosyasını düzenleyin: ```json { "plugin": ["lagune"] } ``` ## Güncelleme **OpenCode 2.x** **Lagune**'yi güncellemek için şunu çalıştırın: ```bash opencode plugin update lagune opencode reload ``` **OpenCode 1.x** **Lagune**'yi güncellemek için yeni sürümü eskisinin üzerine kurun, tüm projeleriniz için kurduysanız `-g` ekleyin: ```bash opencode plugin lagune@0.16.0 --force ``` ## Komutlar **OpenCode 2.x** `@` yazıp komutu seçin, örneğin `@lagune-charter`, ardından girdinizi aynı mesaja yazın. **OpenCode 1.x** Komutları adlarıyla yazın, örneğin `/lagune-charter`. Komutlar `/skills` altında listelenir, `/` menüsünde değil. --- **İzinler** Motor iki araçla çalışır: `lagune_read` yalnızca projenizi okur, `lagune_write` ise yalnızca `.lagune/` klasörüne yazar. **OpenCode** bunları sormadan çalıştırır. ## Sıkça sorulan sorular ### OpenCode için Lagune nasıl kurulur? OpenCode 2.x sürümünde opencode plugin add lagune komutunu çalıştırın. OpenCode 1.x sürümünde opencode plugin lagune komutunu çalıştırın, tüm projeleriniz için kurmak üzere -g ekleyin. ### OpenCode kullanırken Lagune nasıl güncellenir? OpenCode 2.x sürümünde opencode plugin update lagune ve ardından opencode reload komutlarını çalıştırın. OpenCode 1.x sürümünde opencode plugin lagune@0.16.0 --force komutunu çalıştırın. ### OpenCode kullanırken Lagune komutları nasıl çalıştırılır? OpenCode 2.x sürümünde @ yazıp komutu seçin, örneğin @lagune-charter, ardından girdinizi aynı mesaja yazın. OpenCode 1.x sürümünde komutları adlarıyla yazın, örneğin /lagune-charter, ya da /skills altında bulun. ### OpenCode, Lagune çalışmadan önce izin ister mi? Hayır. OpenCode, motorun iki aracı olan lagune_read ve lagune_write araçlarını sormadan çalıştırır. --- # Pi için Lagune paketi kurulumu > Lagune'yi Pi için npm'den veya GitHub'dan paket olarak kurun ve güncel tutun. Kanonik URL: https://lagune.ai/tr-TR/docs/install/pi Dil: tr-TR Orijinal: https://lagune.ai/docs/install/pi Son güncelleme: 2026-11-03 **npm** Paketi terminalden kurun: ```bash pi install npm:lagune ``` **GitHub** Motoru **npx** üzerinden çalıştıran en son commit'i **GitHub** üzerinden kurun: ```bash pi install git:github.com/wellwelwel/lagune ``` ## Güncelleme **npm** **Lagune**'yi güncellemek için şunu çalıştırın: ```bash pi update npm:lagune ``` **GitHub** **Lagune**'yi güncellemek için şunu çalıştırın: ```bash pi update git:github.com/wellwelwel/lagune ``` `pi update --extensions` kurduğunuz tüm paketleri günceller, tek başına `pi update` ise yalnızca **Pi** uygulamasını günceller. ## Komutlar Komutları `skill:` önekiyle yazın, örneğin `/skill:lagune-charter` yazarak `/lagune-charter` komutunu çalıştırın. ## Sıkça sorulan sorular ### Pi için Lagune nasıl kurulur? pi install npm:lagune komutunu ya da GitHub'daki en son commit için pi install git:github.com/wellwelwel/lagune komutunu çalıştırın. ### Pi kullanırken Lagune nasıl güncellenir? pi update npm:lagune komutunu ya da GitHub kurulumu için pi update git:github.com/wellwelwel/lagune komutunu çalıştırın. pi update --extensions kurduğunuz tüm paketleri günceller. ### Pi kullanırken Lagune komutları nasıl çalıştırılır? skill: önekiyle yazın, örneğin /skill:lagune-charter. --- # Qwen Code için Lagune uzantısı kurulumu > Lagune'yi Qwen Code için uzantı olarak kurun, güncel tutun ve motoruna baştan izin verin. Kanonik URL: https://lagune.ai/tr-TR/docs/install/qwen-code Dil: tr-TR Orijinal: https://lagune.ai/docs/install/qwen-code Son güncelleme: 2026-11-03 Uzantıyı terminalden kurun: ```bash qwen extensions install lagune ``` ## Güncelleme **Lagune**'yi güncellemek için şunu çalıştırın: ```bash qwen extensions update lagune ``` Otomatik olarak güncel kalması için `--auto-update` ile kurun. ## Komutlar Komutları uzantının adıyla birlikte yazın, örneğin `/lagune:lagune-charter` yazarak `/lagune-charter` komutunu çalıştırın. --- **İzinler** Motor iki araçla çalışır: `lagune_read` yalnızca projenizi okur, `lagune_write` ise yalnızca `.lagune/` klasörüne yazar. Bunlara baştan izin vermek için bu kuralları tek bir proje için `.qwen/settings.json` dosyasına, tüm projeleriniz için `~/.qwen/settings.json` dosyasına ekleyin: ```json { "permissions": { "allow": ["mcp__lagune__lagune_read", "mcp__lagune__lagune_write"] } } ``` Motor, **skills.sh** ile kurulumda olduğu gibi **npx** üzerinden çalıştığında `Shell(npx --yes lagune@*)` için izin verin. ## Sıkça sorulan sorular ### Qwen Code için Lagune nasıl kurulur? qwen extensions install lagune komutunu çalıştırın. ### Qwen Code kullanırken Lagune nasıl güncellenir? qwen extensions update lagune komutunu çalıştırın ya da uzantıyı --auto-update ile kurun. ### Qwen Code kullanırken Lagune komutları nasıl çalıştırılır? Uzantının adıyla birlikte yazın, örneğin /lagune:lagune-charter. ### Qwen Code, Lagune'yi izin istemeden çalıştırabilir mi? Evet. Qwen Code ayarlarında mcp__lagune__lagune_read ve mcp__lagune__lagune_write için izin verin, motor npx üzerinden çalıştığında Shell(npx --yes lagune@*) için de izin verin. --- # skills.sh ile her ajana Lagune kurulumu > Lagune'yi skills CLI aracıyla her yapay zeka ajanına kurun ve güncel tutun. Kanonik URL: https://lagune.ai/tr-TR/docs/install/universal Dil: tr-TR Orijinal: https://lagune.ai/docs/install/universal Son güncelleme: 2026-11-03 **Terminal** **Lagune** komutlarını [**skills.sh**](https://www.skills.sh/wellwelwel/lagune) ile terminalden kurun: ```bash npx skills add wellwelwel/lagune ``` **Prompt** Bu prompt'u ajanınıza yapıştırın: ```md `npx --yes skills add wellwelwel/lagune` komutunu çalıştır ve oluşturulan beceri talimatlarını hemen uygula. Çıktının tamamını oku, gerekirse önce geçici bir dosyaya yönlendir. Göreli yolları, sağladığı destek dosyaları dizinine göre çözümle. ``` ## Güncelleme **Terminal** **Lagune**'yi güncellemek için şunu çalıştırın: ```bash npx skills update ``` **Prompt** **Lagune**'yi güncellemek için bu prompt'u ajanınıza yapıştırın: ```md `npx --yes skills update -y` komutunu çalıştır ve çıktının tamamını oku, gerekirse önce geçici bir dosyaya yönlendir. ``` --- **Her ajan için tek yol** **Lagune**'yi ya **skills.sh** ile ya da **eklentisiyle** kurun, asla ikisiyle birden kurmayın. **İzinler** Komutlar motoru `npx --yes lagune@0.16.0` olarak çalıştırır ve [her ajanın kurulum sayfası](https://lagune.ai/tr-TR/docs) buna baştan izin veren kuralı gösterir. Ağ erişimi olmayan bir korumalı alanda motoru kendi terminalinizden projenize kurun, bir kez ve her güncellemeden sonra: ```bash npm i -D lagune@0.16.0 ``` ## Sıkça sorulan sorular ### Her yapay zeka ajanına Lagune nasıl kurulur? Projenizde npx skills add wellwelwel/lagune komutunu çalıştırın ya da kurulum prompt'unu ajanınıza yapıştırın. ### skills CLI ile kurulan Lagune nasıl güncellenir? npx skills update komutunu çalıştırın ya da güncelleme prompt'unu ajanınıza yapıştırın. ### Lagune hem skills CLI hem de bir eklentiyle kurulabilir mi? Hayır. İkisiyle birden kurulursa ajan her komutu iki kez listeler ya da bir kopyayı kullanıp diğerini gizler. --- # Yapay zeka ajanları için güvenlik becerileri > Yapay zeka ajanınızın Lagune ile kazandığı beceriler: mevcut bir projeyi denetleyin ya da yeni işi geliştirirken güvenli hale getirin, hepsi charter'ın yönetiminde. Kanonik URL: https://lagune.ai/tr-TR/docs/get-started/commands Dil: tr-TR Orijinal: https://lagune.ai/docs/get-started/commands Son güncelleme: 2026-11-03 **Lagune** [kurulduktan](https://lagune.ai/tr-TR/docs) sonra **yapay zeka** ajanınız bir dizi beceri kazanır. Bunları kullanmanın iki yolu vardır ve ikisi de **charter**'ın yönetimindedir: yeni işi geliştirirken güvenli hale getirmek ya da bir proje üzerinde tam denetimi çalıştırmak. **⌨️ Oluşturma ve geliştirme** İşinizi güvenli hale getirmeden önce bitirmeniz gerekmez. **Şu anda** yazdığınız iş için [**`/lagune`**](https://lagune.ai/tr-TR/docs/commands/lagune) komutunu kullanın: | Beceri | Sizin için ne yapar | | --------------------------------------------- | ------------------------------------------------------------------------------------------ | | [**/lagune-charter**](https://lagune.ai/tr-TR/docs/commands/charter) | Projenizin güvenlik kurallarını belirler, `/lagune` komutunun üzerine inşa ettiği temeldir | | [**/lagune**](https://lagune.ai/tr-TR/docs/commands/lagune) | İstediğinizi geliştirir ve charter'ın rehberliğinde, yazılırken sıkılaştırır | **İstediğiniz zaman kullanın** [**`/lagune`**](https://lagune.ai/tr-TR/docs/commands/lagune) komutu, her çalıştığında charter kurallarınıza uyar. Her prompt'u kabul eder, istediğinizi geliştirir ve sonra değil, ilerledikçe güvenli varsayılanlarla sıkılaştırır. --- #### Özel beceriler | Beceri | Ne yapar | | --------------------------------------------------- | ----------------------------------------------------------------------------------------------- | | [**/lagune-specialize**](https://lagune.ai/tr-TR/docs/commands/specialize) | Makalelerden, exploit'lerden ya da konulardan **Lagune**'ye yeni bir güvenlik uzmanlığı öğretir | **🔬 Denetim: Blue Team akışı** Tam **Blue Team akışı**: bir projenin ne yaptığını okuyun, risklerini çıkarın ve onları kapatın. Her adım bir öncekinin üzerine kurulur, bu yüzden listeyi yukarıdan aşağıya izlemeniz yeterlidir: | # | Beceri | Sizin için ne yapar | | --- | --------------------------------------------- | ----------------------------------------------------------------------------------------------------- | | 1 | [**/lagune-charter**](https://lagune.ai/tr-TR/docs/commands/charter) | Projenizin güvenlik kurallarını belirler, sizin için önerir ya da söylediklerinize göre şekillendirir | | 2 | [**/lagune-detect**](https://lagune.ai/tr-TR/docs/commands/detect) | Kodunuzu okur, sisteminizin ne yaptığını ve risklerin nerede olduğunu çıkarır | | 3 | [**/lagune-plan**](https://lagune.ai/tr-TR/docs/commands/plan) | detect fazının bulduklarını, her bulgu için bir düzeltme içeren bir savunma planına çevirir | | 4 | [**/lagune-harden**](https://lagune.ai/tr-TR/docs/commands/harden) | Planın düzeltmelerini kodunuza güvenli bir şekilde ve tek tek uygular | | 5 | [**/lagune-verify**](https://lagune.ai/tr-TR/docs/commands/verify) | Uygulanan her düzeltmenin işe yaradığını kanıtlar ve yarayanları kapatır | --- #### Özel beceriler | Beceri | Ne yapar | | --------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | | [**/lagune-specialize**](https://lagune.ai/tr-TR/docs/commands/specialize) | Makalelerden, exploit'lerden ya da konulardan **Lagune**'ye yeni bir güvenlik uzmanlığı öğretir | | [**/lagune-prove**](https://lagune.ai/tr-TR/docs/commands/prove) | Tespit edilen her bulguyu, sorumlu ifşa için çalıştırılabilir ve yalnızca savunma odaklı bir ispata çevirir | --- #### Dahili beceriler | Beceri | Ne yapar | | ------------------------------------------- | ------------------------------------- | | [**/lagune-repair**](https://lagune.ai/tr-TR/docs/commands/repair) | **Lagune**'nin dahili takibini onarır | **İpucu** Güvenlik bir maliyet değil, bir yatırımdır: en başta koyduğunuzu, hiç yaşamadığınız olaylarda kat kat geri kazanırsınız 🙋🏻‍♂️ ## Sıkça sorulan sorular ### Lagune hangi becerileri ekler? İşi geliştirirken sıkılaştırmak için /lagune ve beş fazlı Blue Team denetim akışı: /lagune-charter, /lagune-detect, /lagune-plan, /lagune-harden, /lagune-verify. Bunlara ek olarak /lagune-specialize ve /lagune-prove. ### Lagune Blue Team akışı nedir? Beş fazlı bir denetim: charter (kuralları belirler), detect (riskleri çıkarır), plan (puanlar ve düzeltmeleri planlar), harden (düzeltmeleri uygular), verify (işe yaradıklarını kanıtlar ve onları kapatır). ### /lagune ile denetim akışı arasındaki fark nedir? /lagune yeni işi siz yazarken, izlenecek bir akış olmadan güvenli hale getirir. Denetim akışı ise beş fazı mevcut bir proje üzerinde sırayla çalıştırır. --- # Gösterge paneli > Projenizin charter'ını, bulgularını ve kataloğunu tek komutla açılan canlı ve yerel bir görünümde izleyin. Kanonik URL: https://lagune.ai/tr-TR/docs/get-started/dashboard Dil: tr-TR Orijinal: https://lagune.ai/docs/get-started/dashboard Son güncelleme: 2026-11-03 `.lagune/` klasörünün etkileşimli, canlı bir görünümü için **Lagune**'yi alt komut vermeden doğrudan çalıştırın. Bir gösterge paneli sunar ve onu rastgele bir portta açar: ```bash npx lagune ``` - [x] **Live reload** - [x] **Özel** ve **yerel** - [x] İlk charter'dan itibaren `.lagune/` klasöründe ne varsa gösterir - [x] Projenin kategorilerini doğrudan tarayıcınızdan **yönetin** - [x] `node_modules` ya da `package.json` dosyasına gerek yoktur 📦 ![Lagune gösterge panelinde charter](https://lagune.ai/img/dashboard/02.webp) ![Lagune gösterge panelinde bulgular](https://lagune.ai/img/dashboard/03.webp) ![Lagune gösterge panelinde yan görevler](https://lagune.ai/img/dashboard/04.webp) ![Lagune gösterge panelinde bulgu ayrıntısı](https://lagune.ai/img/dashboard/05.webp) ![Lagune gösterge panelinde katalog](https://lagune.ai/img/dashboard/06.webp) **İpucu** - 🚪 Özel bir port belirtmek için `--port` seçeneğini kullanın. - ⏏️ Durdurmak için `Ctrl+C` tuşlarına basın. ## Sıkça sorulan sorular ### Lagune gösterge panelini nasıl açarım? Projenizin kök dizininde npx lagune komutunu alt komut olmadan çalıştırın. .lagune/ klasörünün canlı bir görünümünü rastgele bir portta sunar ve tarayıcınızda açar. ### Gösterge paneli özel mi? Evet. Yalnızca kendi makinenizde, başka hiçbir bilgisayarın erişemeyeceği yerel bir adreste çalışır. ### Projemi gösterge panelinden değiştirebilir miyim? Yalnızca kategorilerini, tarayıcınızdan. Panelin gösterdiği diğer her şey salt okunurdur. --- # /lagune: yapay zeka yazarken kodu güvenli hale getirin > İstediğinizi geliştirir ve charter rehberliğinde, izlenecek bir akış olmadan, yazılırken sıkılaştırır. Kanonik URL: https://lagune.ai/tr-TR/docs/commands/lagune Dil: tr-TR Orijinal: https://lagune.ai/docs/commands/lagune Son güncelleme: 2026-11-03 ⌨️ İstediğiniz işi yapın, yazılırken güvenli hale gelsin. **`/lagune`** her aşamada her prompt'u kabul eder, istediğinizi geliştirir ve size geri vermeden önce güvenli varsayılanlarla sıkılaştırır. ## Kullanım Herhangi bir prompt'ta **`/lagune`** komutunu belirtin ve işi her zamanki gibi anlatın. **📘 Ajan talimatları** ```md # Ajanlar için proje talimatlarım ## Güvenlik - Kod geliştirdiğinde ya da değiştirdiğinde her seferinde `/lagune` becerisini kullan, böylece güvenliği varsayılan olarak iyileştirsin. ``` - Örneğin: **AGENTS.md**, **CLAUDE.md**, **.github/copilot-instructions.md**, **.cursorrules** vb. **💬 Bir özellik** ```prompt /lagune kullanıcıların profillerine özel bir fotoğraf yükleyebilmesini sağla. ``` **💬 Bir düzeltme** ```prompt /lagune kullanıcı formu gönderdiğinde hiçbir şey olmuyor. Sebebi ne olabilir, araştır ve düzelt. ``` **💬 Bir refactor** ```prompt /lagune payload mantığını ayrıştır ve iyileştir ``` **Charter isteğe bağlı, ama onunla daha iyi** **`/lagune`** charter olsun ya da olmasın çalışır. Charter varsa, projenizin kendi kuralları her geliştirmeyi şekillendirir. Kuralları bir kez [`/lagune-charter`](https://lagune.ai/tr-TR/docs/commands/charter) ile belirleyin. ## Nasıl çalışır İşi, Lagune'ye hiçbir şey yazmadan üç adımda ele alır: 1. Varsa charter'ınızı yükler ve onun ilkeleri tüm geliştirmeyi yönetir. Henüz charter'ınız yoksa, varsayılan olarak güvenli bir temel çizgiye döner. 2. Projenizin [kataloğunu](https://lagune.ai/tr-TR/docs/catalog) listeler ve yalnızca işinizin dokunduğu uzmanlıkları yükler. Bunlar, denetim akışının kullandığı talep üzerine bilginin aynısıdır. 3. Savunmayı kod yazılırken uygular, ardından işi geri vermeden önce kontrollerin gerçekten işe yaradığını doğrulamak için kendi sonucunu yeniden okur. Sonuç, projenizde ilk satırdan itibaren güvenli, çalışan koddur. **İstediğiniz zaman kullanın** detect yok, plan yok, sonradan temizlik yok. **`/lagune`**, sıfırdan bir iskelete de olgun bir kod tabanındaki bir değişikliğe de aynı şekilde uyar ve işi sonra değil, ilerledikçe sıkılaştırır. ## Ne yapmaz - `.lagune` dizinine hiçbir şey yazmaz, ne artefakt ne de takip. Ürettiği tek şey, istediğiniz sıkılaştırılmış koddur. - Bir prompt'u karşılamak için bir kuralı gevşetmez. İstediğiniz şey bir charter ilkesini çiğneyecekse, onu doğrudan güvensiz şekilde geliştirmek yerine durur ve önce size söyler. ## Sıkça sorulan sorular ### /lagune ne yapar? Her aşamada her prompt'u kabul eder, istediğinizi geliştirir ve geri vermeden önce güvenli varsayılanlarla sıkılaştırır. Savunma sonra değil, kod yazılırken uygulanır. ### /lagune kullanmak için charter'a ihtiyacım var mı? Hayır. Charter olsun ya da olmasın çalışır. Charter varsa, projenizin kendi kuralları her geliştirmeyi şekillendirir. Yoksa, varsayılan olarak güvenli bir temel çizgiye döner. ### /lagune ile Blue Team akışı arasındaki fark nedir? /lagune yeni işi siz yazarken, izlenecek bir akış olmadan güvenli hale getirir. Blue Team akışı ise beş denetim fazını mevcut bir proje üzerinde sırayla çalıştırır. ### /lagune bulguları takip eder mi ya da artefakt yazar mı? Hayır. .lagune dizinine hiçbir şey yazmaz, ne artefakt ne de takip. Ürettiği tek şey, istediğiniz sıkılaştırılmış koddur. ### Ajanımın /lagune komutunu otomatik kullanmasını nasıl sağlarım? Ajanınızın talimat dosyasına (AGENTS.md, CLAUDE.md, .cursorrules ve benzerleri), kod geliştirdiğinde ya da değiştirdiğinde her seferinde /lagune becerisini kullanmasını söyleyen bir talimat ekleyin. --- # /lagune-charter: güvenlik ilkelerinizi belirleyin > Projenizin güvenlik ilkelerini, yani sonraki her fazın uyduğu kuralları belirleyin ve projeyi okuyarak gerekçelendirilen uzmanlık kategorilerini kaydedin. Kanonik URL: https://lagune.ai/tr-TR/docs/commands/charter Dil: tr-TR Orijinal: https://lagune.ai/docs/commands/charter Son güncelleme: 2026-11-03 🧬 **Lagune**'ye projenizin ne olduğunu anlatın, o da bunu güvenlik kurallarınıza dönüştürsün (ya da hiçbir açıklama olmadan kuralları yalnızca projeden çıkarsın). Charter, yönetici katmandır: sonraki her fazın uyması gereken, güvenliği öne alan ilkeler bütünü. Onu, projenizin güvenlik duruşu için derleme zamanı denetimi gibi düşünün. ## Kullanım **Anlatın** ```prompt /lagune-charter Projem video oyunu satan bir online mağaza. Müşteriler ürünleri sepete ekliyor ve kredi kartıyla ya da havaleyle ödüyor. Siparişlerini ve her birinin durumunu görebiliyorlar. ``` **Lagune önersin** ```prompt /lagune-charter ``` > _Bir ödeme kütüphanesi, bir oturum açma yapılandırması ve bir müşteriye bağlı bir sipariş modeli görüyorum. Bir şey satan bir online mağazaya benziyor. Müşteriler ödeme yapıyor ve kendi siparişlerini takip ediyor..._ ☁️ ## Neleri çıkarır **Lagune**, açıklamanızı ya da **PRD**'nizi yön olarak alır ve bunun güvenlik açısından ne anlama geldiğini çıkarır, ardından sizin belirttiklerinizin ötesine geçmek için projeyi okur. Örneğin: - Siparişleri tutan bir sepet, bir **veritabanı** olduğu anlamına gelir: - örn. `"Veriler nerede duruyor?"`, `"Onlara kim erişebiliyor?"`, `"Veri sızıyor mu?"`. - Kendi siparişlerini görebilen müşteriler, bir tür **oturum açma ya da erişim kontrolü** olduğu anlamına gelir: - örn. `"Bir müşteri başka bir müşterinin siparişlerine erişebilir mi?"`, `"Oturumlar korunuyor mu?"`. - Kart ve havale ile ödeme almak, **paranın ve hassas verilerin işin içinde olduğu** anlamına gelir: - örn. `"Kart verileri saklanıyor mu?"`, `"Ödemeler doğrulanıyor mu?"`. Açıklamanız ve proje birbirini tamamlar: açıklamanız niyeti belirlerken bağımlılıkları, README dosyasını ve yapılandırmayı okumak, sizin bahsetmediklerinizi ortaya çıkarır. Önemli bir şey hâlâ belirsizse, **Lagune** tahmin yürütmek yerine kısa ve sade bir soru sorar. Buradan yola çıkarak **Lagune**, proje için ona özel bir güvenlik kuralları seti oluşturur. Bu kuralları ihtiyaç duyduğunuzda gözden geçirip düzenleyebilirsiniz. **En iyi şekilde yararlanın** - Proje için kendi güvenlik kurallarınızı da tanımlayabilirsiniz. - Ne kadar ilgili ayrıntı verirseniz, nihai rapor o kadar iyi olur: - Projeyi, nasıl çalıştığını ve arka planda neler olduğunu açıklayın. - Son kullanıcı kim? Kullanıcılar neleri yapabilir, neleri yapamaz? - Davranışsal ayrıntılar, teknik ayrıntılar kadar değerlidir. - Charter belleği `.lagune/memory/charter.md` dosyasında durur. ## Kaydettiği kategoriler Sonraki fazların talep üzerine yüklediği güvenlik bilgisi olan uzmanlıklar, projenizin [kataloğuna](https://lagune.ai/tr-TR/docs/catalog) [kategoriye](https://lagune.ai/tr-TR/docs/categories) göre katılır. Projenizde kayıtlı bir kategori olmadığı sürece charter, projeyi okuyarak gerekçelendirebildiği her kategoriyi kaydeder (örneğin projenizin dili, bir LLM'e yapılan çağrılar ya da container'lar) ve bunları özetinde adlarıyla belirtir. Kategoriler kaydedildikten sonra charter onlara dokunmaz ve yalnızca projenizin henüz kullanmadığı bir kategoriyi adıyla belirtir. Onları istediğiniz zaman kendiniz değiştirin: ```bash npx lagune write add --categories python npx lagune write remove --categories python ``` ## Sırada ne var Kurallar belirlendikten sonra sisteminizin gerçekte ne yaptığını çıkarın: [`/lagune-detect`](https://lagune.ai/tr-TR/docs/commands/detect). ## Sıkça sorulan sorular ### Lagune'de charter nedir? Charter, Lagune'nin yönetici katmanıdır: sonraki her fazın uyması gereken, güvenliği öne alan ilkeler bütünü. Onu, projenizin güvenlik duruşu için derleme zamanı denetimi gibi düşünün. ### Charter nerede saklanır? .lagune/memory/charter.md dosyasında. ### Kendi charter kurallarımı yazabilir miyim? Evet. Lagune, açıklamanızdan ve kodunuzdan yola çıkarak kurallar önerir, siz de onları yeniden ifade edebilir, çıkarabilir, ekleyebilir ya da kapsamlarını daraltabilirsiniz. ### Uzmanlık kategorilerimi charter mı seçer? Yalnızca hiçbiri kayıtlı değilken. O durumda projeyi okuyarak gerekçelendirebildiği her kategoriyi kaydeder, örneğin dilinizi ya da bir LLM'e yapılan çağrıları. Kategoriler kaydedildikten sonra onları asla değiştirmez. --- # /lagune-detect: sisteminizin ve risklerinin haritasını çıkarın > Kodunuzu okuyun, sisteminizin ne yaptığını ve risklerin nerede olduğunu belirleyin. Kanonik URL: https://lagune.ai/tr-TR/docs/commands/detect Dil: tr-TR Orijinal: https://lagune.ai/docs/commands/detect Son güncelleme: 2026-11-03 🔬 Sisteminizin gerçekte ne yaptığını ve risklerin nerede olduğunu öğrenin. Detect kodu okur ve yalnızca gerçekten bulduğunu, sonraki fazların ihtiyaç duyduğu kanıtlarla birlikte kaydeder. Temel kuralı uydurmak değil, tespit etmektir. ## Kullanım **Tam tarama** ```prompt /lagune-detect ``` **Yolları belirt** ```prompt /lagune-detect src/routes/ src/auth.ts ``` **Bir endişeyi anlat** ```prompt /lagune-detect müşteri verilerinin asla açığa çıkmadığından emin ol ``` ## Neleri çıkarır **Lagune** kodu okur ve bulduklarının haritasını çıkarır. Her bulgu, ne olduğunu, neden önemli olduğunu ve kanıtını taşır. Örneğin: - **Dosya yükleme**, sistem kullanıcılardan dosya kabul ediyor: - _Neden önemli:_ görsel kılığına girmiş bir dosya, kötü amaçlı kod gizleyebilir. - _Kanıt:_ `POST /upload` işleyicisi, dosyanın gerçek türünü kontrol etmeden istemcinin gönderdiği MIME türüne güveniyor. - **Oturum açma ve oturumlar**, kullanıcılar hesaplarına ulaşmak için giriş yapıyor: - _Neden önemli:_ zayıf oturum yönetimi, bir hesabın başka biri tarafından ele geçirilmesine yol açar. - _Kanıt:_ oturumların hiçbir son kullanma süresi belirlenmeden açıldığı oturum oluşturma mantığı. Bu sırada detect, projenizin [kataloğundaki](https://lagune.ai/tr-TR/docs/catalog) her uzmanlık için koda karşı bir karar verir, bağlamı mevcut olanları uygular ve onları harden ile verify fazlarının yeniden kullandığı liste olan **Applied specializations** altında kaydeder. Böylece sisteminizin ne yaptığının ve risklerin nerede durduğunun, sonraki adımların üzerinde çalışmasına hazır net bir haritası elinizde olur. **İpucu** - Yeniden çalıştırmak haritayı günceller: çözülen bulgular düşer, yenileri eklenir. - Tespit haritası `.lagune/memory/detect.md` dosyasında durur. ## Sırada ne var Haritayı bir plana dönüştürün: [`/lagune-plan`](https://lagune.ai/tr-TR/docs/commands/plan). ## Sıkça sorulan sorular ### /lagune-detect ne yapar? Kodunuzu okur, sisteminizin ne yaptığını ve risklerin nerede olduğunu çıkarır ve yalnızca gerçekten bulduğunu kaydeder. Kuralı uydurmak değil, tespit etmektir. ### Lagune'de bulgu nedir? Bulgu, tespit edilen tek bir risktir. Ne olduğunu, neden önemli olduğunu ve koddaki kanıtını taşır. plan, harden ve verify fazlarının ileriye taşıdığı takip edilen birimdir. ### Tespit haritası nerede saklanır? .lagune/memory/detect.md dosyasında. ### Detect hangi uzmanlıkları kullanır? Projenizin kataloğundaki her uzmanlık, koda karşı bir karar alır. Detect, bağlamı mevcut olanları uygular ve onları Applied specializations altında kaydeder. --- # /lagune-plan: bulguları puanlayın ve düzeltmeleri planlayın > detect fazının bulduklarını bir savunma planına dönüştürün, her bulguyu bir kategori ve CVSS v4.0 puanıyla değerlendirin ve bir düzeltmeyle eşleştirin. Kanonik URL: https://lagune.ai/tr-TR/docs/commands/plan Dil: tr-TR Orijinal: https://lagune.ai/docs/commands/plan Son güncelleme: 2026-11-03 🛡️ detect fazının bulduklarını bir savunma planına dönüştürün: her bulguyu bir kategori ve CVSS v4.0 puanıyla değerlendirin, ardından uygulanacak düzeltmeyle eşleştirin. ## Kullanım **Her şeyi planla** ```prompt /lagune-plan ``` **Yolları belirt** ```prompt /lagune-plan src/routes/upload.ts ``` **Bir endişeye odaklan** ```prompt /lagune-plan hassas verilerin nereden sızabileceği ``` ## Nasıl çalışır Bu faz detect fazının devamıdır. Detect, sisteminizin ne yaptığını ve her parçanın taşıdığı riski zaten buldu, bu yüzden plan riski tekrarlamaz, ne kadar ciddi olduğunu puanlar ve ne yapılacağına karar verir. Plan kodu asla okumaz, bu da her düzeltmeyi detect fazının gerçekten tespit ettiği bir şeye işaret etmeye zorlar. Her bulguyu CVSS v4.0 yöntemiyle puanlar: bir kategori, detect ve charter fazlarının kaydettiklerinden çıkarılıp [`cvss` hook'u](https://lagune.ai/tr-TR/docs/hooks/cvss) tarafından puanlanan bir CVSS v4.0 vektörü ve bu puanın denk geldiği öncelik aralığı. Her düzeltme ayrıca koruduğu charter ilkesini de taşır. Örneğin: - **Dosya yükleme** (Öncelik: **Critical**) - _Kategori:_ kısıtlanmamış dosya yükleme (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, Critical). - _Neden bu öncelik:_ yükleme alanına herkes internet üzerinden erişebilir ve müşteri dosyalarını saklayan sunucuda çalışır. - _Koruduğu ilke:_ III. Doğrulanana kadar tüm girdiler güvenilmezdir. - _Düzeltme:_ dosyanın gerçek türünü ve boyutunu kontrol edin, kaydederken yeniden adlandırın ve yüklemeleri kod olarak çalıştırılamayacakları bir yerde saklayın. Böylece her biri bir bulguya bağlı ve sonraki fazın uygulamasına hazır, puanlanmış ve önceliklendirilmiş bir düzeltme listeniz olur. Puan tahmin edilmez, hesaplanır: vektör, projenin maruziyetini ve riskteki değerleri Environmental metrikleri olarak taşır ve herkes onu FIRST ya da NVD hesaplayıcısına yapıştırıp aynı puanı yeniden elde edebilir. **İpucu** - Tamamen detect fazının üzerine kurulur. Bir dosyanın ya da endişenin haritası hiç çıkarılmadıysa, önce onun için `/lagune-detect` komutunu çalıştırmanızı söyler. - Yeniden çalıştırmak planı günceller: tamamlanan düzeltmeler düşer, yenileri eklenir. - Savunma planı `.lagune/memory/plan.md` dosyasında durur. **detect fazına bağlıdır** Plan yalnızca [`/lagune-detect`](https://lagune.ai/tr-TR/docs/commands/detect) komutunun zaten çıkardığı harita üzerinden çalışır, bu yüzden önce detect fazını çalıştırın. ## Sırada ne var Planı uygulayın: [`/lagune-harden`](https://lagune.ai/tr-TR/docs/commands/harden). ## Sıkça sorulan sorular ### Lagune güvenlik açıklarını nasıl önceliklendirir? /lagune-plan her bulguyu bir kategori ve cvss hook'unun hesapladığı bir CVSS v4.0 puanıyla değerlendirir, ardından uygulanacak düzeltmeyle eşleştirir. ### Lagune CVSS v4.0 kullanıyor mu? Evet. Her bulgu, cvss hook'unun FIRST hesaplayıcısıyla aynı aritmetikle hesapladığı bir CVSS v4.0 vektörü ve puanı alır, böylece herkes vektörü oraya yapıştırıp puanı yeniden elde edebilir. ### Plan kodumu okur mu? Hayır. Plan kodu asla okumaz, bu da her düzeltmeyi detect fazının gerçekten tespit ettiği bir şeye işaret etmeye zorlar. --- # /lagune-harden: güvenlik düzeltmelerini kodunuza uygulayın > Plandaki düzeltmeleri kodunuza güvenli bir şekilde ve tek tek uygulayın. Kanonik URL: https://lagune.ai/tr-TR/docs/commands/harden Dil: tr-TR Orijinal: https://lagune.ai/docs/commands/harden Son güncelleme: 2026-11-03 🔧 Plandaki düzeltmeleri kodunuza güvenli bir şekilde ve tek tek uygulayın. ## Kullanım **Tümünü uygula** ```prompt /lagune-harden ``` **Yolları belirt** ```prompt /lagune-harden src/routes/upload.ts ``` **Önceliğe göre** ```prompt /lagune-harden Critical ve High ``` ## Nasıl çalışır Her düzeltmeye plan zaten karar verdiği için harden fazı yalnızca onu uygular. Kodunuza dokunan tek faz olduğundan dikkatli ilerler: her değişiklik kolayca incelenebilsin diye düzeltmeleri tek tek uygular ve bir düzeltmeyi sığdırmak için bir kontrolü asla zayıflatmaz. Örneğin dosya yükleme düzeltmesi: - **Dosya yükleme** (Status: **Applied**) - _Ne değişti:_ dosyanın gerçek türünü ve boyutunu kontrol eder, beklenmeyen her şeyi reddeder, kaydederken adını değiştirir ve dosyayı kod olarak çalıştırılamayacağı bir yerde saklar. - _Nerede:_ `handleUpload` fonksiyonu ve çağırdığı depolama yardımcısı. Bir düzeltme tamamen uygulanamazsa harden güvenle yapabildiğini yapar, kalanı **Partial** ya da **Blocked** olarak işaretler ve açık bırakır. **Uygulanmış olmak doğrulanmış olmak değildir** Applied, henüz kanıtlandığı anlamına gelmez. Bunun için [verify](https://lagune.ai/tr-TR/docs/commands/verify) vardır. **İpucu** - Tamamen plana dayanır. Bir düzeltme ya da dosya hiç planlanmadıysa önce onun için `/lagune-plan` komutunu çalıştırmanızı söyler. - Yeniden çalıştırmak kaydı uzlaştırır: geri alınan değişiklikler çıkar, yeni uygulanan düzeltmeler eklenir. - Sıkılaştırma kaydı `.lagune/memory/harden.md` dosyasında tutulur. **Plana dayanır ve kodunuzu değiştirir** Harden fazı [`/lagune-plan`](https://lagune.ai/tr-TR/docs/commands/plan) komutuna dayanır. Kodunuzu değiştiren tek fazdır. ## Sırada ne var Her düzeltmenin işe yaradığını kanıtlayın: [`/lagune-verify`](https://lagune.ai/tr-TR/docs/commands/verify). ## Sıkça sorulan sorular ### /lagune-harden kodumu değiştirir mi? Evet. Kodunuza dokunan tek fazdır ve plandaki düzeltmeleri tek tek uygular. ### Applied, Partial ve Blocked ne anlama geliyor? Bunlar Lagune'nin her düzeltme için kaydettiği durumlardır. Applied düzeltmenin yapıldığını, Partial yalnızca bir kısmının yapıldığını, Blocked ise uygulanamadığını gösterir. Applied, henüz kanıtlandığı anlamına gelmez. ### Lagune düzeltmeleri bana sormadan mı uygular? Bir düzenlemenin onayınızı gerektirip gerektirmediğine Lagune değil, ajanınız ve onu çalıştırdığınız izin modu karar verir. Lagune kendine ait bir onay adımı eklemez. Yine de bir düzeltmeyi karşılamak için bir kontrolü asla zayıflatmaz ve bir düzeltme charter'daki bir kuralla çelişecekse önce durup size haber verir. --- # /lagune-verify: güvenlik kontrollerinin işe yaradığını kanıtlayın > Uygulanan her düzeltmenin işe yaradığını kanıtlayın, ardından kanıtlananları kapatın. Kanonik URL: https://lagune.ai/tr-TR/docs/commands/verify Dil: tr-TR Orijinal: https://lagune.ai/docs/commands/verify Son güncelleme: 2026-11-03 ⚖️ Kodu okuyup harden fazının kaydettikleriyle karşılaştırarak uygulanan her düzeltmenin işe yaradığını kanıtlayın, ardından kanıtlananları kapatın. ## Kullanım **Tümünü doğrula** ```prompt /lagune-verify ``` **Yolları belirt** ```prompt /lagune-verify src/routes/upload.ts ``` **Önceliğe göre** ```prompt /lagune-verify Critical ve High ``` ## Nasıl çalışır Harden fazının kaydettiği her noktada kodu okur ve kodun iddiayla gerçekten örtüştüğünü doğrular. İspat, bu karşılaştırmanın ta kendisidir: kod ile kayıt yan yana. Her kontrol üç karardan birini alır: | Karar | Anlamı | | ---------------------------- | ----------------------------------------------------------- | | ✅ Risk closed | Kod, kaydın iddia ettiğini tam olarak yapıyor. | | ❌ Risk not closed | Kontrol hâlâ açık. Verify sizi harden fazına geri gönderir. | | ❓ Cannot tell from the code | Kanıt yalnızca koda bakarak görülemiyor. | Kapandığı kanıtlanan bir risk, onayınızla zincirden takipten çıkarılır. Örneğin: - **Dosya yükleme** (Verdict: **✅ Risk closed**) - _Nasıl kanıtlandı:_ yükleme işleyicisi okundu ve kaydın iddia ettiği gibi dosyanın gerçek türünü içeriğinden tespit ettiği, bir boyut sınırı uyguladığı ve başka her şeyi reddettiği görüldü. - _Kanıt:_ gerçek dosya türünü içerikten tespit eden `handleUpload` fonksiyonu. Risk kapanmadıysa verify bunu açıkça söyler ve düzeltme hâlâ açık olduğu için sizi [`/lagune-harden`](https://lagune.ai/tr-TR/docs/commands/harden) komutuna geri gönderir. **İpucu** - Tamamen sıkılaştırma kaydına dayanır. - Kodunuzu yalnızca değerlendirmek için okur ve bir kararı geçirmek için bir kontrolü asla zayıflatmaz ya da kodu yeniden yazmaz. - Yeniden çalıştırmak kararları uzlaştırır: güncelliğini yitirenler çıkar ve artık kapalı olmayan bir risk yeniden işaretlenir. - Bir riskin kapandığı kanıtlandığında bir kez sorar, ardından o bulguyu tüm zincirden (detect, plan, harden ve takip) temizler. - Kendine ait bir rapor yazmaz: her karar, `.lagune/memory/harden.md` dosyasında ilgili kontrolün bloğunda tutulur ve harden bir sonraki çalışmada onu okur. **Harden fazına dayanır** Verify, [`/lagune-harden`](https://lagune.ai/tr-TR/docs/commands/harden) komutuna dayanır. ## Döngü kapanır Kapsamdaki her şey takipten çıkarıldığında döngü durgun hâle gelir. Yalnızca kod değiştiğinde yeniden açılır. Güvenlik kapatılabilir, bu yüzden akışın bir son durumu vardır, sonsuz bir döngü değildir. ## Sıkça sorulan sorular ### Lagune bir düzeltmeyi nasıl doğrular? /lagune-verify kodu okur, harden fazının kaydettikleriyle karşılaştırır ve üç karardan birini verir: Risk closed, Risk not closed ya da Cannot tell from the code. ### Takipten çıkarmak ne demek? Verify bir riskin kapandığını kanıtladığında bulgu takipten çıkarılır: onayınızla tüm zincirden kaldırılır, böylece yeniden işlenmez. ### Güvenlik çalışması gerçekten bitebilir mi? Evet. SDH'de güvenlik kapatılabilir: kapandığı kanıtlanan bir bulgu takipten çıkarılır, bu yüzden akışın bir son durumu vardır, sonsuz bir döngü değildir. --- # Kategoriler > Bir Lagune projesinin kullanabileceği, OWASP'tan JavaScript, Python, Go ve Rust gibi dillere özgü sıkılaştırmaya uzanan uzmanlık kategorileri ve bunların nasıl değiştirileceği. Kanonik URL: https://lagune.ai/tr-TR/docs/categories Dil: tr-TR Orijinal: https://lagune.ai/docs/categories Son güncelleme: 2026-11-03 **Lagune**, yerleşik [**uzmanlıklarını**](https://lagune.ai/tr-TR/docs/catalog) **13 kategoride** gruplar. Bir projenin kullandığı kategoriler, hangi yerleşik uzmanlıkların projenin [**kataloğuna**](https://lagune.ai/tr-TR/docs/catalog) katılacağını belirler ve ikiye ayrılır: sistemin ne yaptığı ve hangi dille yazıldığı. Hiçbir kategori kaydedilmemişken proje yalnızca `owasp` kullanır. [`/lagune-charter`](https://lagune.ai/tr-TR/docs/commands/charter) komutu, projeyi okumasının desteklediği her kategoriyi kaydeder ve siz de bunları istediğiniz zaman kendiniz değiştirebilirsiniz. ## Sistemin ne yaptığı | Kategori | Anahtar | Neyi sıkılaştırır | | ---------------- | --------- | ------------------------------------------------------------------------------------------------------------------------------------------------- | | OWASP | `owasp` | OWASP'ın takip ettiği uygulama güvenliği riskleri: enjeksiyon, bozuk erişim kontrolü, kimlik doğrulama ve kriptografi hataları | | Altyapı | `infra` | Konteyner, iş yükü ve serverless yapılandırması: Dockerfile, Compose, Pod güvenliği, FaaS IAM ve tetikleyicileri | | Yapay zeka / LLM | `ai` | Yapay zeka ve LLM entegrasyonları, prompt injection'a ve güvensiz araç, ajan, veri getirme ve MCP bağlantılarına karşı | | Lovable | `lovable` | Yapay zekayla üretilmiş Supabase uygulamaları (Lovable ve benzerleri): RLS boşlukları, sızan `service_role` anahtarları ve güvensiz varsayılanlar | ## Hangi dille yazıldığı | Kategori | Anahtar | Neyi sıkılaştırır | | ---------- | ------------ | ---------------------------------------------------------------------------------------------------------------------- | | JavaScript | `javascript` | Çalışma ortamlarının tamamında `eval` ve `child_process` ile RCE, path traversal ve prototype pollution | | Python | `python` | `pickle` ve YAML seri durumdan çıkarma ile RCE, `str.format` ile dize traversal'ı ve class pollution | | Rust | `rust` | Sağlam olmayan `unsafe` API'ler, hatalı `transmute` kullanımı, tamsayı taşması ve FFI sınırında tanımsız davranış | | C / C++ | `c-cpp` | Kod çalıştırmaya olanak tanıyan biçim dizesi hataları, arabellek taşmaları ve sınır dışı yazmalar | | PHP | `php` | Type juggling ile kimlik doğrulama atlatma, nesne enjeksiyonu gadget zincirleri ve güvensiz varsayılan yapılandırmalar | | Go | `go` | Typed nil arayüz hataları, goroutine data races ve güvenlik yollarında güvensiz eşzamanlılık | | Java | `java` | Uzaktan kod çalıştırmayla sonuçlanan `ObjectInputStream` seri durumdan çıkarma gadget zincirleri | | Ruby | `ruby` | Uzaktan kod çalıştırmaya ulaşan `Marshal.load` ve YAML seri durumdan çıkarma gadget zincirleri | | .NET / C# | `dotnet` | `BinaryFormatter` seri durumdan çıkarma ile RCE ve XSS'e ulaşan kodlayıcı atlatmaları | **İpucu** **Lagune** dilden bağımsızdır: tüm akış projeniz hangi dille yazılmış olursa olsun onu okur ve bu kategoriler yalnızca tek bir dile özgü tuzaklarda derinlik katar. ## İstediğiniz zaman ekleyin ve kaldırın Bir kategori bir bağlılık değil, bir başlangıç noktasıdır. Projeye şu anda uyanı kullanın ve istediğiniz zaman anahtarıyla, `write add` ve `write remove` ile değiştirin. Değer verilmeyen `--categories`, terminalde etkileşimli bir seçici açar (seçmek ya da bırakmak için boşluk, onaylamak için enter, atlamak için boş bırakın). Terminal dışında kategorileri onun ardından verin. **Ekle** ```bash npx lagune write add --categories # interactive npx lagune write add --categories owasp npx lagune write add --categories owasp rust ``` **Kaldır** ```bash npx lagune write remove --categories # interactive npx lagune write remove --categories owasp npx lagune write remove --categories owasp rust ``` İlk `write add` ya da `write remove` komutu `owasp` ile başlar, bu yüzden tüm kategorileri kaldırmak varsayılanı değil, boş bir listeyi bırakır. Her değişiklik `.lagune/configs.json` dosyasına yazılır, böylece tüm ekip aynı kümeyle çalışır. ## Bir projenin ne kullandığını görün `read list --categories` komutu her kategoriyi ve projenin onu kullanıp kullanmadığını gösterir: ```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. ``` Her kategorinin hangi uzmanlıkları taşıdığını görmek için [**Katalog**](https://lagune.ai/tr-TR/docs/catalog) sayfasına bakın. [`/lagune-specialize`](https://lagune.ai/tr-TR/docs/commands/specialize) ile yazdığınız kendi uzmanlıklarınız, kategoriler ne olursa olsun kataloğa katılır. ## Sıkça sorulan sorular ### Nasıl kategori eklerim? Kategorinin anahtarını --categories seçeneğine verin, örneğin npx lagune write add --categories javascript. Hiçbir kategori kaydedilmemişken charter da projeyi okumasının desteklediği kategorileri kaydeder. ### Birden fazla kategori kullanabilir miyim? Evet. Onları aynı satırda art arda yazın. ### Bir proje hangi kategoriyi kullanmalı? Varsayılan olan owasp ile başlayın, ardından dilinize ya da yığınınıza uygun kategoriyi ekleyin. Uzmanlıklar yalnızca talep üzerine yüklenir, bu yüzden bir faz onun uzmanlıklarından birine ihtiyaç duyana kadar bir kategorinin hiçbir maliyeti yoktur. --- # Katalog: talep üzerine yüklenen güvenlik uzmanlıkları > Projenizin kataloğundaki uzmanlıkların nasıl yüklendiği: bir faz tarafından talep üzerine ya da doğrudan sizin tarafınızdan. Kanonik URL: https://lagune.ai/tr-TR/docs/catalog Dil: tr-TR Orijinal: https://lagune.ai/docs/catalog Son güncelleme: 2026-11-03 🧠 **Lagune**'nin uzmanlıkları, yalnızca talep üzerine yüklenen, asla varsayılan olarak yüklenmeyen, dilden bağımsız ve odaklı güvenlik bilgisi modülleridir. Komut değildirler. Projenizin kataloğu, projenin kullandığı kümedir: [kategorilerinin](https://lagune.ai/tr-TR/docs/categories) yerleşik uzmanlıkları ile projenin kendi uzmanlıkları. Detect ve verify fazları çalışırken onlara başvurur, siz de herhangi birini istediğiniz zaman doğrudan yükleyebilirsiniz. **Genel bakış** *Etkileşimli katalog özeti web sayfasındadır. Tüm yerleşik uzmanlıklar aşağıdaki tabloda yer alır.* **Nasıl çalışır** ## Kendiniz çalıştırın Bir uzmanlığı doğrudan kullanmak için ajanınızdan onu `read catalog ` ile yüklemesini isteyin ve görevi aynı prompt içinde yazın. Bilgi böylece istediğiniz şey üzerinde çalışır. Bu, **Lagune** akışıyla ilgisi olmayan bir prompt dahil her prompt'ta işe yarar. Örneğin **Python** ile güvenli bir **RegExp** koleksiyonu oluşturmak için doğrudan, serbest biçimli bir prompt: ```prompt `npx lagune read catalog regex` ile regex uzmanlığını yükle, ardından @src/utils/regex.py içinde e-posta adreslerini ve kullanıcı adlarını doğrulayan bir düzenli ifade koleksiyonu oluştur. ``` Bu, her **RegExp**'i **ReDoS**'a karşı test etmek için deterministik bir hook kullanır, güvenli olanları tutar ve şuna benzer bir şey üretir: ```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 ``` **ReDoS denetleyicisini deneyin** Bir kalıbı [**devina.io/redos-checker**](https://devina.io/redos-checker) adresinde kendiniz test edin. ## Yerleşik uzmanlıklar Yerleşik uzmanlıklar [**kategoriler**](https://lagune.ai/tr-TR/docs/categories) hâlinde gruplanır. **Lagune** ile birlikte gelen küme şudur: | Uzmanlık | Kategori | Odak | | --------------------- | --------------------------- | --------------------------------------------------------------------------------------------------------------- | | `regex` | `owasp` | **ReDoS:** özel hazırlanmış girdide patlayan kalıplar. | | `network` | `owasp` | **SSRF ve yönlendirmeler:** kullanıcının verdiği istek ya da yönlendirme hedefleri. | | `interpreter` | `owasp`, `lovable` | **Kod enjeksiyonu:** `eval`, dinamik include, ada göre çağırma. | | `sql` | `owasp` | **İlişkisel veritabanları:** enjeksiyon, ham ORM çağrıları, yetkiler, motorun erişimi. | | `path` | `owasp` | **Dosya sistemi yolları:** traversal, null bayt, NTFS akışları, dosya yerleştirme. | | `upload` | `owasp` | **Dosya yükleme:** tür ve imza, kötü amaçlı içerik, depolama, sınırlar. | | `access-control` | `owasp`, `lovable` | **Kimlik doğrulama, yetkilendirme, oturum:** IDOR, mass assignment, kiracılar, oturumlar. | | `credential-endpoint` | `owasp`, `lovable` | **Tahmin ve botlar:** brute force, password spraying, credential stuffing, hız sınırlama. | | `federation` | `owasp` | **Token güveni:** OAuth/OIDC, SAML, JWT doğrulama, QR ile oturum açma. | | `http-request` | `owasp` | **İstek kaynağı:** CSRF, hatalı CORS yapılandırması, sahte istemci IP'si. | | `transport` | `owasp` | **Kanal güvenliği:** TLS yapılandırması, HTTPS ve düz metin, HSTS, pinning. | | `crypto` | `owasp`, `lovable` | **Saklanan verinin şifrelenmesi:** zayıf ya da özel yapım algoritmalar, CSPRNG, anahtar yönetimi. | | `secrets` | `owasp`, `lovable` | **Koda gömülü kimlik bilgileri:** kaynak kodda düz metin olarak duran anahtarlar, token'lar, parolalar. | | `api-endpoint` | `owasp` | **REST dışı yüzeyler:** GraphQL, gRPC, WebSocket yetkilendirmesi, DoS, şema. | | `payment` | `owasp`, `lovable` | **Ödeme akışı:** ödeme altyapısını sunucu tarafında doğrulama, imzalı geri çağrılar, idempotency. | | `xml` | `owasp` | **XML ayrıştırma:** XXE, harici varlıklar, billion laughs genişlemesi. | | `csv` | `owasp` | **Formül enjeksiyonu:** `=`/`+`/`-`/`@` ile başlayan tablo hücreleri. | | `container` | `owasp`, `infra` | **Konteyner yapılandırması:** root, capabilities, soket bağlama, imaj sıkılaştırma. | | `infra` | `infra` | **Kod olarak altyapı:** Terraform, Dockerfile, GitHub Actions. | | `serverless` | `owasp`, `infra`, `lovable` | **FaaS fonksiyonları:** en az yetkili IAM, olay girdisi, bağlam, gizli bilgiler. | | `llm` | `ai`, `lovable` | **Yapay zeka ve LLM riskleri:** prompt injection, agency, RAG, MCP, çıktı. | | `supabase` | `lovable` | **Supabase arka ucu:** varsayılan olarak kapalı RLS, yapay zekanın hatalı ürettiği politikalar, anahtar modeli. | | `browser` | `javascript`, `lovable` | **İstemci tarafı riskler:** XSS, CSP, framing, depolama vb. | | `javascript` | `javascript` | **Dil düzeyindeki riskler:** RCE, prototype pollution vb. | | `python` | `python` | **Dil düzeyindeki riskler:** `pickle` ile RCE, class pollution, `-O` vb. | | `rust` | `rust` | **`unsafe` sağlamlığı:** güvenli çağıranlardan UB, `transmute`, taşma. | | `java` | `java` | **Seri durumdan çıkarma ve mobil kod:** `readObject` zincirleri, nesne ele geçirme. | | `ruby` | `ruby` | **Seri durumdan çıkarma ve `open`:** `Marshal` ve YAML ile nesne canlandırma, pipe tuhaflığı. | | `php` | `php` | **Type juggling ve `unserialize`:** magic hash'ler, POP zincirleri. | | `go` | `go` | **Typed nil ve data races:** `nil != nil`, paylaşılan bellekli goroutine'ler. | | `c-cpp` | `c-cpp` | **Biçim dizeleri:** `printf(user_input)`, `%n` ile write-what-where. | | `dotnet` | `dotnet` | **Platform düzeyindeki riskler:** `BinaryFormatter` ile RCE, `@Html.Raw`, enum boşlukları. | Yerleşik bilginin çoğunun özü OWASP'tan çıkarılmıştır. Her uzmanlığın OWASP'ın standart saldırı ve Cheat Sheet sayfalarıyla tam eşleşmesi için [**OWASP kaynakları**](https://lagune.ai/tr-TR/docs/references/owasp-sources) sayfasına bakın. Yığına özgü birkaç modül ise doğrudan sağlayıcının kendi rehberliğinden beslenir: örneğin `supabase`, Supabase belgelerinden ve CVE-2025-48757'den gelir. ## Kendi uzmanlıklarınız Yerleşik uzmanlıklar asla yeni bir komutla değil, bir bilgi dosyası ve bir dizin satırı eklenerek büyür. Kendi uzmanlıklarınızı da aynı şekilde, [`/lagune-specialize`](https://lagune.ai/tr-TR/docs/commands/specialize) komutuyla eklersiniz: onu bir makaleye ya da konuya yönlendirin, o da özünü çıkararak projenize yeni bir uzmanlık yazar (`.lagune/catalog/` altındaki dosya ve `.lagune/configs.json` içindeki kaydı). Kendi uzmanlıklarınız, kataloğun kategorileri ne olursa olsun her zaman kataloğun içindedir ve sizin bir uzmanlığınız aynı adlı yerleşik uzmanlığı gölgeler. **Lagune uzmanlıkları kendi içinde, talep üzerine otomatik olarak yükler** Detect ya da verify fazı bir uzmanlığın kapsadığı bir bağlamla karşılaştığında o uzmanlığı `read catalog ` ile kendisi yükler. Bu, fazın bir parçası olarak otomatik gerçekleşir. Bunun çalışması için elle bir şey yapmanız gerekmez. ## Nelerin mevcut olduğunu keşfedin Projenizin kataloğunu terminalden, her satırda etiketleriyle bir uzmanlık olacak şekilde listelemek için: ```bash npx lagune read catalog # regex: Regular Expression [required] # network: Requests, Webhook, URL Fetch, Socket, IMDS, Redirect # interpreter: Evaluator, Sink, Shell, Dynamic Execution # ... ``` `[required]` olarak işaretli bir uzmanlık, iş ne olursa olsun her zaman uygulanır. Listenin hangi yerleşik uzmanlıkları içerdiği, projenizin [**kategorilerine**](https://lagune.ai/tr-TR/docs/categories) bağlıdır. **Uzmanlıklar varsayılan olarak yüklenmez** Her kontrolün varsayılan olarak çalışması yerine, projenin gerçekte ne olduğuna uygun bilgi devreye alınır. ## Sıkça sorulan sorular ### Lagune uzmanlığı nedir? Yalnızca talep üzerine yüklenen, asla varsayılan olarak yüklenmeyen, dilden bağımsız ve odaklı bir güvenlik bilgisi modülüdür. Ajan becerileri gibi bir komut değildir. ### Bir projenin kataloğu nedir? Projenin kullandığı uzmanlıklardır: kategorilerinin yerleşik uzmanlıkları ile projenin kendi uzmanlıkları. Hiçbir kategori kaydedilmemişken yalnızca OWASP kullanılır. ### Uzmanlıklar varsayılan olarak yüklenir mi? Hayır. Yalnızca talep üzerine, projenin gerçekte ne olduğuna göre yüklenirler. ### Bir uzmanlığı doğrudan nasıl yüklerim? Görevle aynı prompt içinde ajanınızdan npx lagune read catalog komutunu çalıştırmasını isteyin. --- # /lagune-specialize: düz metinle bir güvenlik uzmanlığı eğitin > Verdiğiniz bir güvenlik kaynağının ya da konusunun özünü çıkararak talep üzerine yüklenen yeni bir uzmanlığa dönüştürün. Kanonik URL: https://lagune.ai/tr-TR/docs/commands/specialize Dil: tr-TR Orijinal: https://lagune.ai/docs/commands/specialize Son güncelleme: 2026-11-03 🎓 Verdiğiniz bir kaynaktan ya da konudan **Lagune**'ye yeni bir uzmanlık öğretin. Materyali okur ve özünü çıkararak odaklı, yalnızca savunma odaklı bir uzmanlığa dönüştürür. Bu uzmanlık [yerleşik olanlarla](https://lagune.ai/tr-TR/docs/catalog) tamamen aynı biçimdedir, böylece detect ve verify fazları onu sonrasında diğerleri gibi yükler. Yalnızca denetler ve açıklar: asla saldırı girdisi ya da exploit yazmaz ve kodunuza asla dokunmaz. **Bir makaleden** ```prompt # Bir bağlantı ya da kaynak: Lagune onun özünü çıkarıp savunmaya dönüştürür /lagune-specialize https://owasp.org/www-community/attacks/SQL_Injection ``` **Bir exploit** ```prompt # Kaynak olarak bir saldırı: uzmanlık yine de savunmayı anlatır /lagune-specialize "' OR 1=1 -- sorgu metnine SQL ekler" ``` **Bir konudan** ```prompt # Ya da yalnızca neyi kapsaması gerektiğini söyle /lagune-specialize SQL injection ``` **Bir saldırı kaynak olabilir, asla çıktı olamaz** Amaç ona karşı savunma yapmaksa onu bir saldırıya yönlendirmek sorun değildir: bir exploit yazısı, özünü çıkarıp savunmaya dönüştürdüğü bir çalışma materyalidir. Ürettiği uzmanlık her zaman denetler ve açıklar, asla çalışan bir exploit, payload ya da atlatma yöntemi üretmez. ## Ne yazar Sonuç, projenizde kodunuzla birlikte commit edilen ve incelenebilen iki dosyadır: - [Yerleşik olanlar](https://lagune.ai/tr-TR/docs/catalog) gibi biçimlendirilmiş, `.lagune/catalog/.md` konumundaki uzmanlık. - Projenizin kendi uzmanlıklarını, kataloğun yerleşik olanlarla birleştirmesi için dizinlediği `.lagune/configs.json` dosyasındaki kaydı. Ardından yeni kaydın orada olduğunu doğrulamak için kataloğu listeler. Kendi uzmanlıklarınız, kataloğun kategorileri ne olursa olsun her zaman kataloğun içindedir. Hiçbir zaman bir komut eklemez ya da pakete dokunmazsınız: yeni bir uzmanlık alanı, kendi projenize yazılan bir bilgi dosyası ve bir dizin kaydından ibarettir. ## İyileştirir, asla üzerine yazmaz `regex` gibi yerleşik bir uzmanlık ya da daha önce oluşturduğunuz bir uzmanlık olsun, zaten var olan bir adı yeniden uzmanlaştırmak mevcut dosyayı değiştirmek yerine onu **uzlaştırır**. Orada olanı okur, yeni bilgiyi içine katar, hâlâ geçerli olanı korur ve değişeni yeniden yazar. Görülmeden hiçbir şey atılmaz. Sizin bir uzmanlığınız aynı adlı yerleşik uzmanlığı gölgeler, böylece yerleşik bir uzmanlığı kaybetmeden kendi projeniz için keskinleştirebilirsiniz. **İpucu** - Yeni uzmanlık tam olarak yerleşik bir uzmanlık gibi yüklenir: detect ve verify fazları onu talep üzerine alır, ya da `npx lagune read catalog ` ile kendiniz yükleyip ona bir görev verirsiniz. - Materyalin belirlenebilir bir kaynağı olduğunda (bir makale, bir yazar, bir bağlantı, bir standart) uzmanlık o kaynağa atıf yapar. Yalnızca bir konu verildiğinde kaynak belirtilmez. **Not** **Yalnızca siz çağırdığınızda çalışır:** ajan onu asla kendiliğinden başlatmaz. ## Sıkça sorulan sorular ### Özel bir güvenlik uzmanlığını nasıl eklerim? /lagune-specialize komutunu bir kaynak ya da konuyla çalıştırın. Komut, onun özünü çıkararak yalnızca savunma odaklı bir uzmanlığa dönüştürür ve bunu .lagune/catalog/.md dosyasına, kaydını da .lagune/configs.json dosyasına yazar. ### Lagune bir exploit yazısından öğrenebilir mi? Evet, kaynak olarak, asla çıktı olarak değil. Bir saldırı kaynak olabilir, asla ürün olamaz. Specialize asla saldırı girdisi ya da exploit yazmaz. ### Specialize yerleşik uzmanlıkların üzerine yazar mı? Hayır. İyileştirir, asla üzerine yazmaz. --- # /lagune-prove: yalnızca savunma odaklı Proof of Concept > Tespit edilen her bulguyu sorumlu ifşa için çalıştırılabilir, yalnızca savunma odaklı bir Proof of Concept'e (PoC) ve güvenlik bültenine dönüştürün. Kanonik URL: https://lagune.ai/tr-TR/docs/commands/prove Dil: tr-TR Orijinal: https://lagune.ai/docs/commands/prove Son güncelleme: 2026-11-03 🧪 Tespit edilen her bulguyu sorumlu ifşa için çalıştırılabilir, yalnızca savunma odaklı bir kanıta dönüştürün. Tespit haritasındaki her bulgu için kendi başına okunabilen bir güvenlik bülteni ve **güvenli yolu** doğrulayan bir test yazar. Böylece test, sorun var olduğu sürece başarısız olur ve kod düzeltildiği anda geçer. **İpucu** **Lagune** testleri, kendi test paketinizden ayrı olarak `.lagune/` klasöründe yalıtılmış şekilde durur. ## Kullanım **Her bulgu** ```prompt /lagune-prove ``` **Adıyla bir bulgu** Takip edilen bulguları adlarıyla görün: ```prompt npx lagune read list --findings # Findings # ... # • Kullanıcı aramasında SQL injection # ... ``` ```prompt # Ardından bunlardan birini kanıtla /lagune-prove Kullanıcı aramasında SQL injection ``` ## Nasıl çalışır Her bulgunun işaret ettiği kaynak kodu okur ve kanıtlanan her bulgu için `.lagune/proofs/` altında tam olarak iki dosya içeren bir dizin yazar: | Dosya | Nedir | | -------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | | `report.test.mjs` (ya da `.cjs`) | Test. Projeniz zaten Poku kullanıyorsa Poku üzerinde, aksi hâlde yerleşik Node.js çalıştırıcısında çalışır, bu yüzden hiçbir şey kurmanız gerekmez. | | `report.md` | Kendi başına okunabilen bir güvenlik bülteni: önem derecesi, etki, sorunun nasıl yeniden üretildiği ve çalıştırma komutu. | İspatlar her zaman JavaScript'tir, bu yüzden projeniz hangi dille yazılmış olursa olsun taşınabilir kalırlar. Bir `README.md` dizini her ispata bağlantı verir ve hepsini çalıştırmak için tek bir komut sunar. **İpucu** - **İsteğe bağlı ve bağımsızdır:** beş fazdan biri değildir ve takip zincirinin parçası değildir. - Yalnızca `.lagune/proofs/` klasörüne yazar. Faz artefaktlarına ya da yalnızca okuduğu kodunuza asla dokunmaz. - Testi sorunu yeniden üretmeyen bir bulgu ispat almaz ve uzlaştırmak için o noktada [`/lagune-detect`](https://lagune.ai/tr-TR/docs/commands/detect) komutunu çalıştırmanızı söyler. - Yeniden çalıştırmak ispatları uzlaştırır: ortadan kalkan ya da artık yeniden üretilemeyen bir bulgunun dizini silinir. **Not** **Yalnızca siz çağırdığınızda çalışır:** ajan onu asla kendiliğinden başlatmaz. **Detect fazına dayanır** Prove, [`/lagune-detect`](https://lagune.ai/tr-TR/docs/commands/detect) komutunun tespit haritasını okur, bu yüzden önce detect fazını çalıştırın. ## Yalnızca savunma ve yalnızca yetkiyle Herhangi bir şey üretmeden önce hedefi test etme yetkiniz olduğunu doğrular ve çalışan bir exploit, saldırı payload'ı ya da tespit atlatma isteğini reddeder. Bir ispat güvenli davranışı gösterir, asla bir saldırı girdisi üretmez. ## İspattan ifşaya Kanıtlanan her bulgunun iki dosyası, güvenlik açığını bildirmek için bir **gizli GitHub Gist** içinde birlikte durmalıdır. Bunlar hâlâ var olan ve henüz ifşa edilmemiş bir sorunun kanıtlarıdır, bu yüzden bir `.gitignore` dosyası, bulunduğu `.lagune/proofs/` klasöründen onları her commit'in dışında tutar: bakımcılar sorunu çözene kadar onları yalnızca o Gist üzerinden paylaşın. **Lagune** zincirinde bir bulguyu kapatmak yine [`/lagune-harden`](https://lagune.ai/tr-TR/docs/commands/harden) ve [`/lagune-verify`](https://lagune.ai/tr-TR/docs/commands/verify) komutlarının işidir: prove kanıt üretir, hiçbir şeyi kapatmaz. ## Sıkça sorulan sorular ### Lagune exploit üretir mi? Hayır. /lagune-prove yalnızca savunma odaklı kanıt yazar: güvenli yolu doğrulayan, sorun var olduğu sürece başarısız olan ve kod düzeltildiği anda geçen bir test ile sorumlu ifşa için bir güvenlik bülteni. ### Prove ne üretir? Her bulgu için iki dosya: bir test (report.test.mjs ya da .cjs) ve bir güvenlik bülteni (report.md). ### Lagune'nin bulduğu bir hatayı sorumlu bir şekilde nasıl bildiririm? Prove, sorumlu ifşa ilkesine uygun olarak gizli bir GitHub Gist gibi özel bir kanaldan paylaşabileceğiniz, kendi başına okunabilen bir güvenlik bülteni yazar. --- # agent hook'u: sınırsız ajan döngülerini tespit edin > Kod tabanını adım veya süre sınırı olmayan ajan ve LLM çağrılarına karşı tarayın ya da tek bir çağrıyı doğrudan komut satırından değerlendirin. Kanonik URL: https://lagune.ai/tr-TR/docs/hooks/agent Dil: tr-TR Orijinal: https://lagune.ai/docs/hooks/agent Son güncelleme: 2026-11-03 `agent` hook'u, **tur, bütçe veya süre sınırı olmadan döngüye giren ajan çalışma ortamlarını** işaretler. Bu, özel hazırlanmış bir girdiyi sınırsız maliyete ya da prompt injection yoluyla yetki yükseltmeye dönüştüren, kontrolden çıkmış özerklik açığıdır. Hook **dile duyarlıdır** ve iki ajan çatısı ekosistemini kapsar: **JavaScript** (**Claude** ajan SDK'sının `query` çalışma ortamı) ve **Python** (**LangChain**, **LangGraph**, **CrewAI**, **OpenAI Agents**). [`llm` uzmanlığının](https://lagune.ai/tr-TR/docs/catalog) arkasındaki deterministik motordur ve onu **scan** veya **check** modunda kendiniz çalıştırabilirsiniz. ## Çalıştırma **Kod tabanını tara** ```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 ``` **Bir çağrıyı kontrol et** ```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 ``` **Uncapped agent loops found** altındaki her satır, bir ajan SDK'sını içe aktaran bir dosyada şu ikisinden biridir: tur, bütçe veya süre sınırı olmadan çağrılan Claude ajan SDK'sının `query` çalışma ortamı (JavaScript, varsayılan olarak sınırsız) ya da bir çatının varsayılan sınırının `max_iterations=None` / `max_turns=None` gibi açıkça kaldırılması (Python, varsayılan olarak sınırlı). Her iki durumda da hook sıfırdan farklı bir kodla çıkar. Vercel AI SDK'sının `generateText`/`streamText` fonksiyonları varsayılan olarak tek adım çalışır (`stopWhen: stepCountIs(1)`), bu yüzden oradaki yalın bir çağrı döngüye giremez ve işaretlenmez. Sıradan bir `db.query(...)` da asla ajan çağrısıyla karıştırılmaz. Temiz bir çalıştırma `no uncapped agent loops found` çıktısını verir. ## Kararı nasıl okumalı | Karar | Anlamı | | ---------- | -------------------------------------------------------------------------------------------------------- | | `uncapped` | Sınır koymayan bir `query` çalışma ortamı çağrısı (JS) ya da sınırın açıkça kaldırılması (`=None`, Py). | | `safe` | Sınır koyan bir `query` çağrısı, tek adımlı bir üretim ya da varsayılan olarak sınırlı bir çatı çağrısı. | | `invalid` | Kod parçası, değerlendirilebilecek tanınır bir ajan çağrısı içermiyor. | ### CLI seçenekleri | Seçenek | Değer | Açıklama | | ----------- | --------------- | --------------------------------------------------------------------------------------------------- | | `--pattern` | bir kod parçası | Tek bir çağrıyı kontrol eder. Birkaçını kontrol etmek için tekrarlayın, her satıra bir karar düşer. | | `--lang` | bir dil | `--pattern` ile zorunludur: `javascript` veya `python`. | | `--dir` | bir dizin | Taramayı bir dizinle sınırlar. Tekrarlanabilir ve `--file` ile birleştirilebilir. | | `--file` | bir dosya | Taramayı tek bir dosyayla sınırlar. Tekrarlanabilir ve `--dir` ile birleştirilebilir. | Seçenek verilmezse tüm proje taranır. `--pattern`, `--lang` gerektirir ve `--dir` ya da `--file` ile birleştirilemez. **Elden gelenin en iyisi, ama eksiksiz değil** Herhangi bir dilde elle yazılmış bir ajan döngüsü, statik bir taramanın erişebileceği şey değildir. Bunu eksiksiz bir envanter olarak değil, sağlam bir taban olarak görün. **İpucu** Hook yalnızca sınırın varlığına karar verir: yetenek kapsamını daraltma, güven düzeylerinin karışması ve yetkilendirme, değerlendirme gerektiren konulardır ve onları [`llm` uzmanlığı](https://lagune.ai/tr-TR/docs/catalog) kapsamaya devam eder. ## Sıkça sorulan sorular ### Bir ajan döngüsüne neden sınır koymalıyım? Sınırsız bir ajan, sonsuz özyinelemeye, sınırsız maliyete ya da prompt injection yoluyla yetki yükseltmeye sürüklenebilir. maxTurns, maxBudgetUsd, stopWhen veya signal ayarlamak onu sınırlar. agent hook'u ise bunların hiçbirini ayarlamayan bir query çalışma ortamı çağrısını işaretler. --- # cors hook'u: CORS kökenlerini denetleyin > Kaynak kodu atlatılabilir bir CORS köken izin listesine karşı tarayın ya da tek bir köken değerini aşırı serbest erişime karşı doğrudan komut satırından puanlayın. Kanonik URL: https://lagune.ai/tr-TR/docs/hooks/cors Dil: tr-TR Orijinal: https://lagune.ai/docs/hooks/cors Son güncelleme: 2026-11-03 `cors` hook'u, [`http-request` uzmanlığının](https://lagune.ai/tr-TR/docs/catalog) arkasındaki deterministik motordur ve onu kendiniz çalıştırabilirsiniz. Tek bir komutla iki modda çalışır: kaynak kodu **atlatılabilir bir köken izin listesine** (saldırganın sunucusunun yanından sızıp geçtiği bir sunucu doğrulama regex'ine) karşı tarayan **scan** ve tek bir **CORS köken** değerini `wildcard`, `null` veya `safe` olarak puanlayan **score**. ## Kod tabanını tarama Hiçbir bayrak verilmezse tüm proje taranır. **Tüm proje** ```bash npx lagune read cors ``` **Bir dizin** ```bash npx lagune read cors --dir src/server ``` **Tek bir dosya** ```bash npx lagune read cors --file internal/auth/origin.go ``` Hook, atlatılabilir her izin listesini tek bir başlık altında, dosyaya göre gruplayarak listeler. `.+`/`.*` ifadesi güvenilen sunucu sonekinden önce, authority bölümünde yer alan bir sunucu doğrulayıcısı (`^https?://.+\.trusted\.com`), `your-site.com.attacker.com` gibi bir saldırgan sunucusunun yanından sızıp geçmesine izin verir. ```text Origin-allowlist patterns with a greedy wildcard (bypassable, review): internal/auth/origin.go ^https?://.+\.trusted\.com ``` Bu, kapatılmış bir bulgu değil, incelenmesi gereken bir ipucudur: regex'in gerçek bir güven kararını denetleyip denetlemediği metinden anlaşılamaz, bu yüzden tarama çıkış kodunu asla değiştirmez. Her birini okuyun ve izin listesinin tam eşitlikle karşılaştırdığından emin olun. Hiçbir şey bulunamazsa tek bir satır yazdırılır. ```bash npx lagune read cors --dir src/clean # => no bypassable origin allowlist found ``` ## Bir kökeni puanlama Her kökeni `--origin` ile verin. Hook her köken için tek bir kelime yazdırır ve herhangi bir `wildcard` ya da `null` sonucunda sıfırdan farklı bir kodla çıkar. **Tek köken** ```bash npx lagune read cors --origin '*' # => wildcard npx lagune read cors --origin 'null' # => null npx lagune read cors --origin 'https://app.example.com' # => safe ``` **Birkaç köken** Bütün bir izin listesini tek çağrıda puanlamak için `--origin` seçeneğini tekrarlayın. Her satıra sırasıyla bir karar düşer. ```bash npx lagune read cors \ --origin 'https://app.example.com' \ --origin '*' \ --origin 'null' # => safe # => wildcard # => null ``` | Karar | Anlamı | | ---------- | --------------------------------------------------------------------------------------------------------------- | | `safe` | `*`, `null` veya `*` içeren bir glob değildir. Kökenin doğru biçimlendirildiğini garanti etmez. | | `wildcard` | `*` ya da bir alt alan adı, sunucu veya port glob'u: herhangi bir site (veya geniş bir küme) yanıtı okuyabilir. | | `null` | Korumalı alandaki iframe'lerin ve yönlendirmelerin sahteleyebildiği `null` kökeni. | Yalnızca `safe` bir izindir ve `--origin` bir değer kahinidir: işleyiciyi değil değeri değerlendirir, bu yüzden işleyiciyi `http-request` uzmanlığıyla doğrulayın. ### CLI seçenekleri | Seçenek | Değer | Açıklama | | ---------- | --------- | ------------------------------------------------------------------------------------------ | | `--origin` | bir köken | Tek bir köken değerini puanlar. Birkaçını puanlamak için tekrarlayın, her satıra bir tane. | | `--dir` | bir dizin | Taramayı bir dizinle sınırlar. Tekrarlanabilir ve `--file` ile birleştirilebilir. | | `--file` | bir dosya | Taramayı tek bir dosyayla sınırlar. Tekrarlanabilir ve `--dir` ile birleştirilebilir. | Seçenek verilmezse tüm proje taranır. `--origin` score modudur ve `--dir` ya da `--file` ile birleştirilemez. **Neleri kapsamaz** Tarama **atlatılabilir regex** biçimini okur, `--origin` ise köken **değerlerini** puanlar. Kaynak kod düzeyindeki iki örüntü erişim dışında kalır: isteğin `Origin` değerinin yansıtılması (sunucunun gelen `Origin` değerini geri yansıtması ya da kimlik bilgileriyle eşleştirmesi) ve serbest bir `endsWith` veya alt dize tabanlı izin listesi. Bunları kodda tanıyın ve [`http-request` uzmanlığının](https://lagune.ai/tr-TR/docs/catalog) anlattığı şekilde ele alın. ## Sıkça sorulan sorular ### Null CORS kökeni neden tehlikeli? Korumalı alandaki iframe'ler ve bazı yönlendirmeler Origin: null gönderir, bu yüzden null değerine güvenen bir izin listesi bu bağlamlara okuma erişimi verir. cors hook'u bunu wildcard ile birlikte işaretler. ### Atlatılabilir bir CORS köken izin listesini nasıl yakalarım? Kod tabanı üzerinde npx lagune read cors komutunu çalıştırın. Hook, açgözlü wildcard'ı güvenilen sonekten önce gelen bir sunucu doğrulama regex'ini işaretler, çünkü böyle bir regex your-site.com.attacker.com gibi bir saldırgan sunucusunun yanından sızıp geçmesine izin verir. --- # crypto hook'u: zayıf kriptografiyi tespit edin > Kod tabanını zayıf kriptografik primitiflere karşı tarayın ya da tek bir kod parçasını doğrudan komut satırından puanlayın. Kanonik URL: https://lagune.ai/tr-TR/docs/hooks/crypto Dil: tr-TR Orijinal: https://lagune.ai/docs/hooks/crypto Son güncelleme: 2026-11-03 `crypto` hook'u, **zayıf kriptografik primitifleri** çağrıldıkları yerde işaretler: kullanımdan kaldırılmış bir şifre, güvensiz bir mod ya da kırılmış bir özet algoritması. **Dile duyarlıdır**, her dosyayı kendi kurallarıyla okur, bu yüzden bir Python yapısı asla bir Rust dosyasında işaretlenmez. [`crypto` uzmanlığının](https://lagune.ai/tr-TR/docs/catalog) arkasındaki deterministik motordur ve onu **scan** veya **check** modunda kendiniz çalıştırabilirsiniz. ## Çalıştırma **Kod tabanını tara** ```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 ``` **Bir kod parçasını kontrol et** ```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 ``` Tarama en fazla iki bölüm yazdırır. **Weak cryptography found** bulgu kümesidir (DES/3DES/RC4/Blowfish/RC2, ECB modu): her biri kırılmış bir şifreleme primitifidir, bu yüzden hook sıfırdan farklı bir kodla çıkar. **Cryptography to review manually** ise hook'un tek başına değerlendiremediği ipuçlarının kümesidir: bir MD5/SHA-1 özeti (güvenlik amacıyla kırılmıştır ama sıradan bir sağlama toplamı olarak meşrudur, yani karar niyete bağlıdır), güvenlik bağlamında kriptografik olmayan bir rastgele sayı üreteci ya da zamanlama saldırısına açık bir karşılaştırma. Temiz bir çalıştırma `no weak cryptography found` çıktısını verir. ## Kararı nasıl okumalı | Karar | Anlamı | | --------- | ------------------------------------------------------------------------------------------------------------------------ | | `weak` | Kod parçası kırılmış bir şifreleme primitifi kullanıyor (DES/3DES, RC4, Blowfish, RC2 veya ECB modu). | | `review` | Niyete bağlı bir primitif: bir MD5/SHA-1 özeti ya da güvenlik bağlamında kriptografik olmayan bir rastgele sayı üreteci. | | `safe` | Kod parçası kriptografi kullanıyor ve hiçbir zayıf primitif bulunamadı. | | `invalid` | Kod parçası, değerlendirilebilecek tanınır bir kriptografik yapı içermiyor. | ### CLI seçenekleri | Seçenek | Değer | Açıklama | | ----------- | --------------- | ------------------------------------------------------------------------------------------------------------------- | | `--pattern` | bir kod parçası | Tek bir kod parçasını kontrol eder. Birkaçını kontrol etmek için tekrarlayın, her satıra bir karar düşer. | | `--lang` | bir dil | `--pattern` ile zorunludur: javascript, python, go, java, kotlin, php, ruby, rust, csharp, c, cpp dillerinden biri. | | `--dir` | bir dizin | Taramayı bir dizinle sınırlar. Tekrarlanabilir ve `--file` ile birleştirilebilir. | | `--file` | bir dosya | Taramayı tek bir dosyayla sınırlar. Tekrarlanabilir ve `--dir` ile birleştirilebilir. | Seçenek verilmezse tüm proje taranır. `--pattern`, `--lang` gerektirir ve `--dir` ya da `--file` ile birleştirilemez. ### Desteklenen diller Tarama bu dilleri dosya uzantısına göre tanıyarak okur ve her birini kendi kriptografik API'lerine göre kontrol eder. | Dil | Zayıf şifreler (bulgu) ve özetler ile rastgele sayı üreteçleri (inceleme) | | --------------------------- | ------------------------------------------------------------------------------------------------------------------ | | **JavaScript / TypeScript** | `createCipher`, `CryptoJS.DES/RC4`, tırnak içinde `*-ecb`; 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()` | **Elden gelenin en iyisi, ama eksiksiz değil** Hook kaynak kodu metin olarak okur, bu yüzden çalışma zamanında oluşturulan, bir takma adın arkasına gizlenen ya da tanımadığı bir biçimde yazılan bir primitif gözden kaçabilir. Tabloyu eksiksiz bir envanter olarak değil, sağlam bir başlangıç noktası olarak görün. **İpucu** Hook tabanı garanti eder (bu yapılar mevcuttur): anahtar yönetimi, IV'nin yeniden kullanımı ve RSA dolgusu, değerlendirme gerektiren konulardır ve onları [`crypto` uzmanlığı](https://lagune.ai/tr-TR/docs/catalog) kapsamaya devam eder. ## Sıkça sorulan sorular ### Bir kod tabanını zayıf kriptografiye karşı nasıl tararım? crypto hook'unu bayraksız çalıştırın. Kırılmış şifreler ve ECB modu, sıfırdan farklı bir kodla çıkan bulgulardır. Bir MD5/SHA-1 özeti ise incelenmesi gereken bir ipucudur, çünkü güvenlik amacıyla kırılmıştır ama sıradan bir sağlama toplamı olarak meşrudur. ### crypto hook'u Math.random() kullanımını işaretler mi? Yalnızca güvenlik bağlamında, incelenmesi gereken bir ipucu olarak işaretler, asla otomatik bir bulgu olarak değil, çünkü rastgelelik jitter veya arayüzdeki sıralama için meşrudur. --- # cvss hook'u: bir CVSS v4.0 vektörünü puanlayın > Bir veya birden çok CVSS v4.0 vektörünü FIRST hesaplayıcısıyla aynı aritmetikle doğrudan komut satırından puanlayın ve her birini sade bir dille okuyun. Kanonik URL: https://lagune.ai/tr-TR/docs/hooks/cvss Dil: tr-TR Orijinal: https://lagune.ai/docs/hooks/cvss Son güncelleme: 2026-11-03 `cvss` hook'u bir **CVSS v4.0 vektörünü** puanlar ve puanını ile önem derecesi aralığını yazdırır. Bu, [`/lagune-plan`](https://lagune.ai/tr-TR/docs/commands/plan) komutunun her düzeltmeye, [`/lagune-prove`](https://lagune.ai/tr-TR/docs/commands/prove) komutunun da her güvenlik bültenine yazdığı derecelendirmedir. Hook, bu derecelendirmelerin arkasındaki deterministik motordur, [FIRST hesaplayıcısıyla](https://www.first.org/cvss/calculator/4.0) aynı aritmetiği kullanır ve onu kendiniz çalıştırabilirsiniz. ## Çalıştırma Her vektörü `--vector` ile verin. Hook her vektör için bir satır yazdırır: puanını ve aralığını. **Tek vektör** ```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 ``` **Birkaç vektör** Birkaç vektörü aynı anda puanlamak için `--vector` seçeneğini tekrarlayın. Her biri için sırasıyla bir satır yazdırılır. ```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 ``` **Sade bir dille** Her metriği sade bir dille okumak için `--explain` ekleyin. Threat veya Environmental metrikleri puanı değiştirdiğinde önce yalnızca Base metriklerine göre puan gösterilir. ```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 # => ... ``` ## Sonucu nasıl okumalı | Aralık | Puan | | ---------- | ------------------ | | `None` | 0.0 | | `Low` | 0.1 ile 3.9 arası | | `Medium` | 4.0 ile 6.9 arası | | `High` | 7.0 ile 8.9 arası | | `Critical` | 9.0 ile 10.0 arası | Yalnızca Base metrikleri içeren bir vektör, en kötüsünü varsayarak açığın kendisini puanlar: her güvenlik gereksinimi High düzeyindedir ve açık gerçek dünyada saldırıya uğramaktadır. Environmental metrikleri (`MAV` ve değiştirilmiş diğer metrikler, ayrıca `CR`, `IR` ve `AR`) puanı belirli bir dağıtım için, Threat metriği (`E`) ise istismar hakkında bilinenlere göre netleştirir. Geçersiz bir vektör `invalid vector:` ifadesini ve sorunun ne olduğunu yazdırır, hook da sıfırdan farklı bir kodla çıkar. ### CLI seçenekleri | Seçenek | Değer | Açıklama | | ----------- | ---------------------- | ----------------------------------------------------------------------------------------------------- | | `--vector` | bir `CVSS:4.0` vektörü | Tek bir vektörü puanlar. Birkaçını puanlamak için tekrarlayın, her vektöre sırasıyla bir satır düşer. | | `--explain` | | Her derecelendirme satırının altına her metriği sade bir dille ekler. | En az bir `--vector` zorunludur. Vektör asla yalın bir konumsal argüman olarak verilmez, bu yüzden bir bayrakla karıştırılamaz. **Neden bir bayrak değeri** Her vektör bir bayrak değeri olarak verilir, asla komutun içine yerleştirilmez. Tırnak veya ters tırnak içeren bir değer etkisiz kalır ve kabuğa enjeksiyon yapamaz. Kabuğunuzun onu önceden genişletmemesi için her zaman tek tırnak içine alın. **Neleri kapsamaz** Yalnızca CVSS v4.0: bir v2.0, v3.0 veya v3.1 vektörü puanlanmaz, reddedilir, çünkü **Lagune** her bulguyu v4.0 ile derecelendirir. **İpucu** plan fazının doğrulaması her CVSS satırında aynı aritmetiği yeniden çalıştırır, bu yüzden vektöründen sapmış bir puan, plan kabul edilmeden önce yakalanır. ## Sıkça sorulan sorular ### Lagune bir CVSS puanını nasıl hesaplar? cvss hook'u CVSS v4.0 için FIRST'ün referans hesaplayıcısını izler, bu yüzden bir vektör FIRST sitesindekiyle tam olarak aynı puanı alır. ### Bununla bir CVSS v3.1 vektörünü puanlayabilir miyim? Hayır. Lagune her bulguyu CVSS v4.0 ile derecelendirir ve hook başka herhangi bir sürümü puanlamak yerine reddeder. ### --explain bayrağı ne işe yarar? Her metriği sade bir dille okur ve Base puanını genel puanın yanında gösterir, böylece herkes vektörün ne söylediğini ve proje bağlamının puanı nasıl değiştirdiğini görebilir. --- # infra hook'u: IaC yapılandırma hatalarını tespit edin > Terraform, Dockerfile ve GitHub Actions dosyalarını yapılandırma hatalarına karşı tarayın ya da tek bir kod parçasını doğrudan komut satırından puanlayın. Kanonik URL: https://lagune.ai/tr-TR/docs/hooks/infra Dil: tr-TR Orijinal: https://lagune.ai/docs/hooks/infra Son güncelleme: 2026-11-03 `infra` hook'u, dosyanın kendisinden anlaşılabilen **kod olarak altyapı (IaC) yapılandırma hatalarını** işaretler: tüm dünyaya açık bir ağ, wildcard içeren bir izin, bir manifestteki gizli bilgi, root olarak çalışan bir konteyner, bir CI kabuğundaki güvenilmeyen bir değer. Yalnızca IaC dosyalarını okur (`.tf`/`.tf.json`/`.hcl`, `Dockerfile*`, `.github/workflows/**`). [`infra` uzmanlığının](https://lagune.ai/tr-TR/docs/catalog) arkasındaki deterministik motordur ve **scan** veya **check** modunda çalışır. ## Çalıştırma **Kod tabanını tara** ```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 ``` **Bir kod parçasını kontrol et** Kod parçasını `--pattern` ile, türünü de `--kind` ile verin (`terraform`, `dockerfile` veya `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 ``` Tarama en fazla iki bölüm yazdırır. **Infrastructure risks found** sıfırdan farklı bir kodla çıkar ve kesin olarak belirlenebilen kusurları içerir (hassas bir porta `0.0.0.0/0` gelen trafiği, wildcard içeren bir IAM ifadesi, bir manifestteki gizli bilgi, `encrypted = false`, sabitlenmemiş bir git modülü, açıkça root olarak çalışan bir imaj, bir `curl | sh`, bir CI betiği enjeksiyonu, `permissions: write-all`). **Infrastructure hardening advisories** çıkış kodunu değiştirmez (değişebilir bir temel etiket, etikete sabitlenmiş bir action). Temiz bir çalıştırma `no infrastructure risks found` çıktısını verir. ## Kararı nasıl okumalı check modu, eşleştiği en yüksek önem derecesine sahip etiketi (örneğin `public-ingress`, `iam-wildcard`, `root-user`, `curl-pipe`, `script-injection`, `write-all`), bir öneri etiketini (`mutable-tag`, `unpinned-action`) ya da `safe` yazdırır. Yalnızca bulgu düzeyindeki bir etiket sıfırdan farklı bir kodla çıkar. ### CLI seçenekleri | Seçenek | Değer | Açıklama | | ----------- | ----------------------------------------------- | ------------------------------------------------------------------------------------- | | `--pattern` | bir kod parçası | Tek bir kod parçasını kontrol eder. `--kind` gerektirir. Birkaçı için tekrarlayın. | | `--kind` | `terraform` \| `dockerfile` \| `github-actions` | Kod parçasının hangi tür olarak değerlendirileceği. | | `--dir` | bir dizin | Taramayı bir dizinle sınırlar. Tekrarlanabilir ve `--file` ile birleştirilebilir. | | `--file` | bir dosya | Taramayı tek bir dosyayla sınırlar. Tekrarlanabilir ve `--dir` ile birleştirilebilir. | Seçenek verilmezse projedeki her IaC dosyası taranır. `--pattern`, `--dir` ya da `--file` ile birleştirilemez. **İpucu** Hook bariz ve kesin olarak belirlenebilen durumları yakalar: şifrelemenin eksikliği, `pull_request_target` kaynaklı açıklık ve doğru IAM kapsamı, değerlendirme gerektiren konulardır ve onları [`infra` uzmanlığı](https://lagune.ai/tr-TR/docs/catalog) kapsamaya devam eder. ## Sıkça sorulan sorular ### infra hook'u hangi altyapı dosyalarını okur? Terraform ve HCL (.tf, .tf.json, .hcl), Dockerfile'lar ve .github/ altındaki GitHub Actions iş akışı ile action YAML dosyaları. Kaynak kod tarayıcıları bu dosyaları atlasa da hook onlara ulaşır. --- # interpreter hook'u: dinamik kod çalıştırma sink'lerini işaretleyin > Kod tabanını farklı dillerdeki dinamik kod çalıştırma sink'lerine karşı tarayın ya da tek bir kod parçasını doğrudan komut satırından puanlayın. Kanonik URL: https://lagune.ai/tr-TR/docs/hooks/interpreter Dil: tr-TR Orijinal: https://lagune.ai/docs/hooks/interpreter Son güncelleme: 2026-11-03 `interpreter` hook'u **dinamik kod çalıştırma sink'lerini** işaretler: `eval`'den yerel seri durumdan çıkarmaya kadar, veriyi çalışan koda dönüştüren ya da bir kabuğa aktaran yapılar. Dile duyarlıdır, her dosyayı kendi kurallarıyla okur. [`interpreter` uzmanlığının](https://lagune.ai/tr-TR/docs/catalog) arkasındaki deterministik motordur ve onu **scan** veya **check** modunda kendiniz çalıştırabilirsiniz. ## Çalıştırma **Kod tabanını tara** ```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 ``` **Bir kod parçasını kontrol et** ```bash npx lagune read interpreter --lang javascript --pattern 'eval(x)' # => careful npx lagune read interpreter --lang python --pattern 'json.loads(x)' # => safe ``` Bu sink'ler çift kullanımlıdır: saldırganın etkileyebildiği bir girdinin bunlardan birine ulaşıp ulaşmadığına statik bir tarama karar veremez, bu yüzden her eşleşme onaylanmış bir bulgu değil, **incelenmesi gereken bir uyarıdır**. Tarama, dosyaya göre gruplanmış tek bir **Dynamic-execution sinks to review** bölümü yazdırır. Temiz bir çalıştırma `no dynamic-execution sinks found` çıktısını verir. **İşaretlenen kodu okuyun, asla çalıştırmayın!** Her sink'i **statik olarak** değerlendirin ve güvenilmeyen bir girdinin ona ulaşıp ulaşmadığını izleyin. Ne yaptığını "test etmek" için işaretlenen kodu ya da onun çektiği uzak veya çalışma zamanında indirilen herhangi bir kodu asla çalıştırmayın ve `eval` ile değerlendirmeyin. ## Kararı nasıl okumalı | Karar | Anlamı | | --------- | ---------------------------------------------------------------------------------------------------------------- | | `careful` | Kod parçası, kendi dili için bir dinamik çalıştırma sink'i içeriyor. Onu çalıştırarak değil, okuyarak inceleyin. | | `safe` | Verilen dil için hiçbir dinamik çalıştırma sink'i bulunamadı. | ### CLI seçenekleri | Seçenek | Değer | Açıklama | | ----------- | --------------- | ------------------------------------------------------------------------------------------------------------------- | | `--pattern` | bir kod parçası | Tek bir kod parçasını kontrol eder. Birkaçını kontrol etmek için tekrarlayın, her satıra bir karar düşer. | | `--lang` | bir dil | `--pattern` ile zorunludur: javascript, python, php, ruby, java, kotlin, go, rust, c, cpp, csharp dillerinden biri. | | `--dir` | bir dizin | Taramayı bir dizinle sınırlar. Tekrarlanabilir ve `--file` ile birleştirilebilir. | | `--file` | bir dosya | Taramayı tek bir dosyayla sınırlar. Tekrarlanabilir ve `--dir` ile birleştirilebilir. | Seçenek verilmezse tüm proje taranır. `--pattern`, `--lang` gerektirir ve `--dir` ya da `--file` ile birleştirilemez. ### Desteklenen diller Tarama bu dilleri dosya uzantısına göre tanıyarak okur ve her birini kendi dinamik çalıştırma sink'leri kümesine göre kontrol eder. | # | Dil | Uzantılar | İşaretlediği sink'ler | | --- | --------------------------- | ------------------------------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | 1 | **JavaScript / TypeScript** | `.js`, `.jsx`, `.mjs`, `.cjs`, `.ts`, `.tsx`, `.mts`, `.cts`, `.astro`, `.vue`, `.svelte`, `.marko`, `.riot` | `eval()`, Function yapıcısı, gövdesi dize olan `setTimeout`/`setInterval`, `vm` modülü, `child_process` exec, dinamik `require()`, dinamik `import()` | | 2 | **Python** | `.py`, `.pyi` | `eval`/`exec`, `__import__()`, `os.system`/`os.popen`, `subprocess` `shell=True`, `pickle.load`/`loads`, `yaml.load` (güvensiz) | | 3 | **Ruby** | `.rb` | eval ailesi (`instance_eval`/`class_eval`/`module_eval`/`eval`), `system`/`exec`, ters tırnaklar veya `%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()`, dize üzerinde `assert()`, `create_function()`, kabukta çalıştırma (`system`/`exec`/`shell_exec`/`passthru`/`popen`/`proc_open`), `call_user_func`/`call_user_func_array`, çalışma zamanında belirlenen yolla `include`/`require` | | 6 | **Rust** | `.rs` | `Command::new`, `process::Command` | | 7 | **Java** | `.java` | `Runtime.exec`, `ProcessBuilder`, `ScriptEngine`, `ObjectInputStream.readObject` | | 8 | **Kotlin** | `.kt`, `.kts` | JVM sink'leri: `Runtime.exec`, `ProcessBuilder`, `ScriptEngine`, `ObjectInputStream.readObject` | | 9 | **C#** | `.cs` | `Process.Start` / `new Process`, `BinaryFormatter`, `Assembly.Load` | | 10 | **C** | `.c`, `.h` | `system()`, `popen()`, `exec*` ailesi (`execl`, `execve`, `execvp`, …) | | 11 | **C++** | `.cc`, `.cpp`, `.cxx`, `.hpp`, `.hh`, `.hxx` | `system()`, `popen()`, `exec*` ailesi (`execl`, `execve`, `execvp`, …) | **Elden gelenin en iyisi, ama eksiksiz değil** Hook kaynak kodu metin olarak okur, bu yüzden çalışma zamanında oluşturulan, bir takma adın arkasına gizlenen ya da tanımadığı bir biçimde yazılan bir sink gözden kaçabilir. Tabloyu eksiksiz bir envanter olarak değil, sağlam bir başlangıç noktası olarak görün. **İpucu** Hook tabanı garanti eder (bu sink'ler mevcuttur ve yerleri bellidir): güvenilmeyen bir değerin gerçekten bunlardan birine ulaşıp ulaşmadığı ise [`interpreter` uzmanlığının](https://lagune.ai/tr-TR/docs/catalog) kapsadığı bir değerlendirmedir. ## Sıkça sorulan sorular ### interpreter hook'u bir güvenlik açığını doğrular mı? Hayır. Dinamik çalıştırma sink'lerini onaylanmış bir bulgu olarak değil, incelenmesi gereken bir uyarı olarak işaretler, çünkü saldırganın etkileyebildiği bir girdinin sink'e ulaşıp ulaşmadığına statik bir tarama karar veremez. ### interpreter hook'u hangi dilleri kapsar? Desteklenen diller tablosundaki dilleri dosya uzantısına göre tanıyarak okur ve her birini kendi sink kümesine göre kontrol eder. Diğer dillerde sink bulunmaz. --- # jwt hook'u: algoritması sabitlenmemiş JWT doğrulamasını tespit edin > Kod tabanını algoritması sabitlenmemiş JWT doğrulamasına karşı tarayın ya da tek bir çağrıyı doğrudan komut satırından puanlayın. Kanonik URL: https://lagune.ai/tr-TR/docs/hooks/jwt Dil: tr-TR Orijinal: https://lagune.ai/docs/hooks/jwt Son güncelleme: 2026-11-03 `jwt` hook'u, **algoritması sabitlenmemiş JWT doğrulamasını**, yani doğrulayıcının token'ın kendi `alg` başlığına güvendiği algoritma karışıklığı açığını ve **tamamen kapatılmış doğrulamayı** işaretler. **Dile duyarlıdır**, her dosyayı kullandığı JWT kütüphanesine göre okur. [`federation` uzmanlığının](https://lagune.ai/tr-TR/docs/catalog) arkasındaki deterministik motordur ve onu **scan** veya **check** modunda kendiniz çalıştırabilirsiniz. ## Çalıştırma **Kod tabanını tara** ```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 ``` **Bir çağrıyı kontrol et** ```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 ``` **Unpinned JWT verification found** altındaki her satır, `algorithms` izin listesi belirlemeyen (kütüphanenin buna ihtiyaç duyduğu yerde), güvensiz bir liste kabul eden (`none` ya da HMAC ile karıştırılmış asimetrik bir algoritma) veya imza kontrolünü tamamen devre dışı bırakan bir doğrulama çağrısıdır, dolayısıyla token'ın kendi `alg` değerine güvenir. Bu doğrulanmış bir açıklık olduğundan hook sıfırdan farklı bir kodla çıkar. Temiz bir çalıştırma `no unpinned JWT verification found` çıktısını verir. ## Kararı nasıl okumalı | Karar | Anlamı | | ---------- | --------------------------------------------------------------------------------------------------------------------------------- | | `unpinned` | Algoritma izin listesi olmayan (gerektiği yerde), güvensiz bir liste kullanan ya da doğrulaması kapatılmış bir doğrulama çağrısı. | | `safe` | Sağlam bir algoritma izin listesini sabitleyen ya da kütüphanesi bunu örtük olarak sabitleyen bir doğrulama çağrısı. | | `invalid` | Kod parçası, değerlendirilebilecek tanınır bir doğrulama çağrısı içermiyor. | ### CLI seçenekleri | Seçenek | Değer | Açıklama | | ----------- | --------------- | ----------------------------------------------------------------------------------------------------------- | | `--pattern` | bir kod parçası | Tek bir çağrıyı kontrol eder. Birkaçını kontrol etmek için tekrarlayın, her satıra bir karar düşer. | | `--lang` | bir dil | `--pattern` ile zorunludur: javascript, python, go, java, kotlin, php, ruby, rust, csharp dillerinden biri. | | `--dir` | bir dizin | Taramayı bir dizinle sınırlar. Tekrarlanabilir ve `--file` ile birleştirilebilir. | | `--file` | bir dosya | Taramayı tek bir dosyayla sınırlar. Tekrarlanabilir ve `--dir` ile birleştirilebilir. | Seçenek verilmezse tüm proje taranır. `--pattern`, `--lang` gerektirir ve `--dir` ya da `--file` ile birleştirilemez. ### Desteklenen diller Tarama bu kütüphaneleri dosya uzantısına göre tanıyarak okur. Bazıları algoritmayı örtük olarak sabitlediğinden (açık bir listenin olmaması orada sağlamdır), "izin listesi yok ⇒ unpinned" kuralı yalnızca kütüphanenin açık bir liste beklediği yerde uygulanır, böylece doğru yapılandırılmış bir çağrı asla işaretlenmez. | Dil | Kütüphane | İzin listesinin yokluğunu unpinned olarak işaretler mi? | Her zaman işaretler | | --------------------------- | ----------------------- | ----------------------------------------------------------------------------------------- | ------------------------------------------------------ | | **JavaScript / TypeScript** | jsonwebtoken, jose | Evet | `none`, asimetrik algoritmanın HMAC ile karıştırılması | | **Python** | PyJWT, python-jose | Evet (PyJWT bunu zorunlu tutar, python-jose varsayılan olarak `algorithms=None` kullanır) | `none`, `verify_signature: False` | | **Go** | golang-jwt | Evet (`WithValidMethods` yoksa) | `none`, `ParseUnverified` | | **Ruby** | ruby-jwt | Evet | `none`, `verify = false` | | **Java / Kotlin** | jjwt, nimbus | Hayır (anahtardan türetilir) | `none`, imzasız ya da `unsecured` bir ayrıştırıcı | | **PHP** | firebase/php-jwt | Hayır (algoritmayı `Key` taşır) | `none` | | **Rust** | jsonwebtoken | Hayır (`Validation` bunu zorunlu tutar) | `none`, `insecure_disable_signature_validation` | | **C#** | Microsoft.IdentityModel | Hayır (çok satırlı parametreler) | `none`, `RequireSignedTokens = false` | **İpucu** Hook yalnızca algoritmanın sabitlenmesine karar verir: claim, anahtar ve akış kontrolleri, değerlendirme gerektiren konulardır ve onları [`federation` uzmanlığı](https://lagune.ai/tr-TR/docs/catalog) kapsamaya devam eder. ## Sıkça sorulan sorular ### JWT algoritma karışıklığı nedir? Algoritmayı token başlığından okuyan bir doğrulayıcı, saldırganın RS256'yı HS256 ile değiştirip açık anahtarla imzalamasına izin verir. Kodda sağlam bir algoritma izin listesini sabitlemek bunu önler. jwt hook'u ise hiç izin listesi belirlemeyen ya da güvensiz bir liste belirleyen bir doğrulama çağrısını işaretler. --- # network hook'u: URL'leri SSRF'ye karşı puanlayın > Bir veya birden çok istek hedefini doğrudan komut satırından SSRF'ye karşı puanlayın. Kanonik URL: https://lagune.ai/tr-TR/docs/hooks/network Dil: tr-TR Orijinal: https://lagune.ai/docs/hooks/network Son güncelleme: 2026-11-03 `network` hook'u, sunucu tarafındaki bir istek hedefinin **SSRF**'ye (iç servislere, bulut meta verilerine veya özel sunuculara yöneltilebilen bir istek) karşı güvenli olup olmadığına karar verir. [`network` uzmanlığının](https://lagune.ai/tr-TR/docs/catalog) arkasındaki deterministik motordur ve onu kendiniz çalıştırabilirsiniz. ## Çalıştırma Her hedefi `--url` ile verin. Hook her hedef için tek bir kelime yazdırır, anlamları aşağıdaki tabloda yer alır. **Tek hedef** ```bash npx lagune read network --url 'http://example.com/' # => safe npx lagune read network --url 'http://0x7f000001/' # => private-target ``` **Birkaç hedef** Bütün bir izin listesini ya da engelleme listesini tek çağrıda puanlamak için `--url` seçeneğini tekrarlayın. Her satıra sırasıyla bir karar düşer. ```bash npx lagune read network \ --url 'http://example.com/' \ --url 'http://[::1]/' \ --url 'http://allowed.com@evil.example/' # => safe # => private-target # => parser-divergent ``` Hook, sunucu adını ağın çözümlediği şekilde çözümler, bu yüzden bir iç adresin kodlanmış biçimleri gözden kaçmaz: onaltılık, sekizlik, noktasız ondalık, kısaltılmış, IPv6 ve IPv4-mapped biçimlerin hepsi `private-target` sonucunu verir. Özensiz bir doğrulayıcının ve gerçek istemcinin farklı sunucular okuyacağı durumlarda ise karar `parser-divergent` olur. ## Kararı nasıl okumalı | Karar | Anlamı | | ------------------ | ------------------------------------------------------------------------------------------------- | | `safe` | Hedef herkese açık bir sunucuya bağlanır ve özensiz bir doğrulayıcı da aynı sunucuyu okur. | | `private-target` | Sunucu adı özel, loopback, link-local, belirtilmemiş ya da bulut meta verisi adresine çözümlenir. | | `parser-divergent` | Özensiz bir metin doğrulayıcısı, istemcinin bağlandığından farklı bir gerçek sunucu okur. | | `invalid url` | Dize bir URL olarak ayrıştırılamaz, yani istenecek bir şey yoktur. | Yalnızca `safe` bir izindir. `private-target`, `parser-divergent` ve `invalid url` sonuçlarının hepsini engelleme olarak ele alın. ### CLI seçenekleri | Seçenek | Değer | Açıklama | | ------- | ----------------------- | -------------------------------------------------------------------------------------------------- | | `--url` | bir URL veya sunucu adı | Tek bir hedefi kontrol eder. Birkaçını kontrol etmek için tekrarlayın, her satıra bir karar düşer. | En az bir `--url` zorunludur. Hedef asla yalın bir konumsal argüman olarak verilmez, bu yüzden bir bayrakla karıştırılamaz. **Neden bir bayrak değeri** Her hedef bir bayrak değeri olarak verilir, asla komutun içine yerleştirilmez. Tırnak veya ters tırnak içeren bir değer etkisiz kalır ve kabuğa enjeksiyon yapamaz. Kabuğunuzun onu önceden genişletmemesi için her zaman tek tırnak içine alın. **Neleri kapsamaz** Hook saf bir işlevdir ve asla DNS çözümlemesi yapmaz, bu yüzden çalışma zamanına ait iki boşluk kapsam dışında kalır: **DNS rebinding** (kontrol edilirken herkese açık, istek yapılırken iç adrese çözümlenen bir ad) ve **yönlendirme zincirleri** (kontrolden geçen, sonra içeriye yönlendiren ilk adım). Bunları, adı bir kez çözümleyip doğrulanan adrese bağlanarak ve yönlendirmeleri reddederek kapatın. Hook, ayrılmış loopback adlarını (`localhost` ve `.localhost` ailesi) çözümleme yapmadan iç adres olarak sabitler, ancak diğer her DNS adı `safe` sonucunu verir, çünkü bir adın içeriye çözümlendiğini öne sürmek çözümleme gerektirir: bu adları izin listesi korur ve bu denetleyicinin doğruladığı da odur. **İpucu** Bu, [`network` uzmanlığının](https://lagune.ai/tr-TR/docs/catalog) bir hedef filtresinin işe yaradığını kanıtlamak için çalıştırdığı kontrolün aynısıdır. ## Sıkça sorulan sorular ### Bir URL'yi SSRF'ye karşı nasıl test ederim? network hook'unu çalıştırın. Hook bir istek hedefini puanlar ve safe, private-target, parser-divergent veya invalid url sonucunu döndürür. Yalnızca safe bir izindir. ### Parser-divergent URL nedir? Farklı ayrıştırıcıların farklı okuduğu bir URL'dir ve klasik bir SSRF atlatma yöntemidir. network hook'u ona izin vermek yerine onu işaretler. --- # regex hook'u: ReDoS örüntülerini tespit edin > Kod tabanını ReDoS'a yatkın regex'lere karşı tarayın ya da tek bir örüntüyü doğrudan komut satırından puanlayın. Kanonik URL: https://lagune.ai/tr-TR/docs/hooks/regex Dil: tr-TR Orijinal: https://lagune.ai/docs/hooks/regex Son güncelleme: 2026-11-03 `regex` hook'u, [`regex` uzmanlığının](https://lagune.ai/tr-TR/docs/catalog) çalıştırdığı deterministik regex güvenliği motorudur ve onu kendiniz çalıştırabilirsiniz. Tek bir komutla iki modda çalışır: kod tabanını **ReDoS**'a yatkın ve çalışma zamanında oluşturulan örüntülere karşı tarayan **scan** ve verdiğiniz tek bir örüntüyü puanlayan **check**. ## Kod tabanını tarama Hiçbir bayrak verilmezse tüm proje taranır. `--dir` taramayı bir dizinle, `--file` ise tek bir dosyayla sınırlar. İkisi de tekrarlanabilir ve tek bir raporda birleştirilebilir. Bir dosyayı birden fazla hedef kapsasa bile o dosya raporda yalnızca bir kez listelenir. **Tüm proje** ```bash npx lagune read regex ``` **Bir dizin** ```bash npx lagune read regex --dir src/services ``` **Tek bir dosya** ```bash npx lagune read regex --file bin/import.pl ``` **Birkaç hedef** ```bash npx lagune read regex --dir core --dir workers --file Sources/App/Router.swift ``` **Sınırla** `--limit`, tarama için ReDoS eşiğini belirler (varsayılan 25). Bu, check modunun da aldığı sınırın aynısıdır. Daha düşük bir sınır daha katıdır. ```bash npx lagune read regex --dir src/services --limit 15 ``` Çıktı, başlıkları her bölümün nasıl okunacağını söyleyen düz bir metindir. Bir bölüm yalnızca bulgu içerdiğinde gösterilir. ```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 ``` Hiçbir şey bulunamazsa tek bir satır yazdırılır. ```bash npx lagune read regex --dir src/clean # => no unsafe patterns found ``` ### Bölümleri nasıl okumalı | Bölüm | Anlamı | | ------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `Vulnerable regular expressions found` | Dosyaya göre gruplanmış, ReDoS'a yatkın örüntüler. Her örüntü dosyanın altında girintili yer alır, ardından parantez içinde neden güvensiz olduğu ve varsa kapsamı ile bayrakları gelir. Her satır güvensizdir, bu yüzden karar tekrarlanmaz. | | `Regular expressions the analysis could not settle (review manually)` | Analizin iş sınırı içinde karara bağlayamadığı örüntüler, aynı şekilde listelenir. | | `Dynamically built regular expressions (review manually by simulating a constructed regex)` | Bir regex'i bir değişkenden, bir birleştirmeden ya da bir enterpolasyondan oluşturan dosyalar. | | `Static regex wrapped in a constructor (use a literal instead)` | Bir regex literalinin daha basit olacağı ve çalışma zamanındaki derlemeyi atlayacağı yerde bir regex yapıcısına sıradan bir dize literali veren dosyalar. | İlk bölüm bir güvenlik bulgusudur. İkinci ve üçüncü bölüm tek başına bulgu değildir: statik bir kontrolün karara bağlayamadığı koda işaret eder, bu yüzden bir insanın okumasını gerektirir. Dördüncü bölüm bir güvenlik bulgusu değil, kodu daha anlaşılır kılmaya yönelik bir ipucudur. ### CLI seçenekleri | Seçenek | Değer | Açıklama | | ----------- | ---------------------------- | ---------------------------------------------------------------------------------------------------------------- | | `--pattern` | bir regex kaynağı | Tek bir örüntüyü kontrol eder. Birkaçını kontrol etmek için tekrarlayın, her örüntüye sırasıyla bir karar düşer. | | `--flags` | regex bayrakları | Her `--pattern` değerini `im` gibi bu bayraklarla kontrol eder. Yalnızca check modunda geçerlidir. | | `--dir` | bir dizin | Taramayı bir dizinle sınırlar. Tekrarlanabilir ve `--file` ile birleştirilebilir. | | `--file` | bir dosya | Taramayı tek bir dosyayla sınırlar. Tekrarlanabilir ve `--dir` ile birleştirilebilir. | | `--limit` | negatif olmayan bir tam sayı | ReDoS tekrar sınırını belirler (varsayılan 25). Her iki modda da geçerlidir. Daha düşük bir sınır daha katıdır. | Seçenek verilmezse tüm proje taranır. `--pattern` check modudur ve `--dir` ya da `--file` ile birleştirilemez. ### Desteklenen diller Tarama bu dilleri dosya uzantısına göre tanıyarak, her birini kendi kurallarıyla okur, böylece bir dildeki örüntü asla başka bir dilin kurallarıyla test edilmez. Geri kalan her şey yanlış kurallarla taranmak yerine atlanır. | # | Dil | Uzantılar | | --- | --------------------------- | ------------------------------------------------------------------------------------------------------------ | | 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` | **Elden gelenin en iyisi, ama eksiksiz değil** Hook kaynak kodu metin olarak okur, bu yüzden çalışma zamanında oluşturulan bir örüntüyü değerlendiremez. Birden çok satıra yayılan, bir takma adın arkasına gizlenen ya da tanımadığı bir biçimde yazılan bir örüntü de gözden kaçabilir. Bölümleri eksiksiz bir envanter olarak değil, sağlam bir başlangıç noktası olarak görün ve onların erişemediği yerler için kodu okumaya devam edin. ## Tek bir örüntüyü kontrol etme Bir örüntüyü puanlamak için kaynağını `--pattern` ile verin. Hook tek bir kelime yazdırır: `safe`, `unsafe`, analiz örüntüyü karara bağlamadan iş sınırına ulaştığında `undetermined` ya da `invalid regex`. Birkaç örüntüyü aynı anda puanlamak için `--pattern` seçeneğini tekrarlayın. Her örüntüye sırasıyla bir karar düşer. **Tek örüntü** ```bash npx lagune read regex --pattern '(a+)+$' # => unsafe npx lagune read regex --pattern '^[a-z0-9_]{3,20}$' # => safe ``` **Birkaç örüntü** ```bash npx lagune read regex --pattern '(a+)+$' --pattern '^[a-z]+$' # => unsafe # => safe ``` **Bayraklarla** `--flags`, çağrıdaki her `--pattern` değerini çalışacağı bayraklarla kontrol eder, çünkü bir bayrak, örüntünün hangi karakterlerle eşleştiğini değiştirir. ```bash npx lagune read regex --pattern '^(?:a|A)+$' # => safe npx lagune read regex --pattern '^(?:a|A)+$' --flags 'i' # => unsafe ``` **Sınırla** `--limit`, tekrar sınırını belirler (varsayılan 25) ve çağrıdaki her `--pattern` için geçerlidir. Daha düşük bir sınır daha katıdır. ```bash npx lagune read regex --pattern 'a?a?a?' --limit 2 # => unsafe ``` **Neden tırnak içinde bir argüman** Her örüntü bir bayrak değeri olarak verilir, asla komutun içine yerleştirilmez. Tırnak veya ters tırnak içeren bir değer etkisiz kalır ve kabuğa enjeksiyon yapamaz. Kabuğunuzun onu önceden genişletmemesi için örüntüyü her zaman tek tırnak içine alın. **İpucu** Bu, [`regex` uzmanlığının](https://lagune.ai/tr-TR/docs/catalog) çalıştırdığı motorun aynısıdır: scan bir ReDoS incelemesini başlatır, check ise taramanın ortaya çıkardığı bir örüntüyü doğrular. ## Sıkça sorulan sorular ### Bir regex'i CLI'dan ReDoS'a karşı nasıl kontrol ederim? npx lagune read regex --pattern '' komutunu çalıştırın. Hook safe, unsafe, undetermined veya invalid regex sonucunu döndürür. ### Bütün bir projeyi güvensiz regex'lere karşı nasıl tararım? regex hook'unu kod tabanı üzerinde scan modunda çalıştırın. Hook, desteklenen 25 dilde ReDoS'a yatkın örüntüleri raporlar. --- # secrets hook'u: koda gömülü gizli bilgileri tespit edin > Kod tabanını koda gömülü kimlik bilgilerine karşı doğrudan komut satırından tarayın. Kanonik URL: https://lagune.ai/tr-TR/docs/hooks/secrets Dil: tr-TR Orijinal: https://lagune.ai/docs/hooks/secrets Son güncelleme: 2026-11-03 `secrets` hook'u, ortamdan okunmak yerine **kaynak koda gömülmüş kimlik bilgilerini** işaretler. Değerin içeriğine değil **kaynağına** (bir literal mi, yoksa ortamdan okunan bir değer mi) bakar, bu yüzden sağlayıcı öneklerinden oluşan kapsamlı bir kataloğa ihtiyaç duymaz ve neredeyse hiç yanlış pozitif üretmez. [`secrets` uzmanlığının](https://lagune.ai/tr-TR/docs/catalog) arkasındaki deterministik motordur. Sağlayıcı biçimi imzaları, bağlantı dizelerindeki kimlik bilgileri ve adı gizli bilgiye işaret eden bir tanımlayıcıya atanmış bir literal **dilden bağımsızdır**: aynı dize her dosyada aynı şekilde okunur. Sözdizimine bağlı iki sezgisel kural, yani koda gömülü varsayılan değere sahip bir ortam değişkeni okuması ve bir log sink'ine akan gizli bilgi ise **dile duyarlıdır**, bu yüzden JavaScript'in `console.log` çağrısı asla bir Rust dosyasında aranmaz ve Python'un `os.getenv("X", "default")` kalıbı kendi başına tanınır. ## Çalıştırma ```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 ``` Tarama en fazla iki bölüm yazdırır. **Hardcoded secrets found** bulgu kümesidir (adı gizli bilgiye işaret eden bir ortam değişkeni için koda gömülü bir varsayılan değer, bir bağlantı dizesine gömülmüş bir kimlik bilgisi ya da özenle derlenmiş bir sağlayıcı biçimiyle eşleşen bir değer), bu yüzden hook sıfırdan farklı bir kodla çıkar. **Secret handling to review manually** ise ipuçlarının kümesidir: adı gizli bilgiye işaret eden bir tanımlayıcıya atanmış sıradan bir literal (kaynağı belirlenebilir, ama değerin gerçek bir gizli bilgi olup olmadığı belirlenemez) ve bir log ya da yanıt sink'ine akan, adı gizli bilgiye işaret eden bir değer. Temiz bir çalıştırma `no hardcoded secrets found` çıktısını verir. ### CLI seçenekleri | Seçenek | Değer | Açıklama | | -------- | --------- | ------------------------------------------------------------------------------------- | | `--dir` | bir dizin | Taramayı bir dizinle sınırlar. Tekrarlanabilir ve `--file` ile birleştirilebilir. | | `--file` | bir dosya | Taramayı tek bir dosyayla sınırlar. Tekrarlanabilir ve `--dir` ile birleştirilebilir. | Seçenek verilmezse tüm proje taranır. ### Dil kapsamı Ortam değişkeni varsayılanı bulgusu ve log sink'i ipucu, her dil için ayrı bir biçim kümesi okur, bu yüzden aşağıdaki dilleri kapsar ve diğerlerinde sessiz kalır. Diğer üç sinyal **her** dosyada çalışır. | Sinyal | Diller | | --------------------------- | ------------------------------------------------------------------------------- | | Ortam değişkeni varsayılanı | JavaScript/TypeScript, Python, Ruby, PHP, Kotlin, Java, Go (`cmp.Or`), Rust, C# | | Log veya yanıt sink'i | JavaScript/TypeScript, Python, Ruby, PHP, Java, Kotlin, Go, Rust, C, C++, C# | **Bu bir kullanım politikası sorunu mu?** Hayır. Commit edildiği konusunda uyarmak için bir gizli bilginin biçimini tespit etmek, standart bir savunma aracıdır ve gitleaks, trufflehog ve GitHub push protection'ın yaptığı işlemin aynısıdır. Hook, gerçek bir gizli bilgiyi değil, tespit imzalarını (herkese açık token **biçimlerini**) içerir, veriyi dışarı sızdırmak yerine denetler ve açıklar. ## Sıkça sorulan sorular ### secrets hook'u yanlış pozitiflerden nasıl kaçınır? Değerin içeriğine değil kaynağına bakar. Yüksek güvenilirlikli biçimler (sağlayıcı token'ları, ortam değişkeni varsayılanları, bağlantı dizeleri) sıfırdan farklı bir kodla çıkan bulgulardır. Adı gizli bilgiye işaret eden bir tanımlayıcıya atanmış sıradan bir literal doğrulanması gereken bir inceleme ipucudur ve aynı tanımlayıcı process.env üzerinden okunduğunda hiç işaretlenmez. --- # Lagune prompt örnekleri: Blue Team akışını otomatikleştirin > Kopyalamaya hazır Lagune prompt'ları: salt okunur bir tarama, tam Blue Team akışı ve bir Zero Trust denetimi, ayrıca bir commit'e, bir dalın ya da PR'ın diff'ine veya gerçek bir olaya göre kapsamı daraltılmış tespit. Kanonik URL: https://lagune.ai/tr-TR/docs/examples/prompts Dil: tr-TR Orijinal: https://lagune.ai/docs/examples/prompts Son güncelleme: 2026-11-03 Doğrudan yapay zeka ajanınıza yapıştırabileceğiniz, kopyalamaya hazır Lagune prompt'ları. ## 💧 Yüzeysel tarama Kodu kendi başına okuyup her kusuru bir düzeltmeyle birlikte raporlayan salt okunur bir tarama. Blue Team akışını çalıştırmaz ve Lagune'nin takibine hiçbir şey yazmaz. **İpucu** Planlama modunda ve tanımlanmış bir charter (`/lagune-charter`) ile daha iyi çalışır. **🪼 Varsayılan** | Yön | Ödünleşim | Düzey | | ------------------- | ------------------------------------------------------------ | ------------------- | | **Çaba** | Tek bir ajan tarar ve raporlar, alt ajan yok. | 1/5 | | **Süre** | Hızlı. Tek bir salt okunur geçiş, hiçbir şey uygulanmaz. | 2/5 | | **Token kullanımı** | Orta, paylaşımlı. Taramanın tamamı tek bir bağlamda çalışır. | 2/5 | ```md /lagune Savunma güvenliğinde derin uzmanlığa sahip bir siber güvenlik araştırmacısısın ve bilgini ve isabetini artırmak için Lagune'yi kullanıyorsun. Çalışma alanını kendi başına tara ve bulduğun her kusuru somut bir düzeltmeyle eşleştir. Bu, Blue Team akışı değil, bağımsız bir taramadır: detect, plan, harden ya da verify çalıştırma ve Lagune'nin takibine hiçbir şey yazma. Sonunda bulduğun her kusuru, önem derecesi ve somut bir düzeltmeyle birlikte listele. ``` **🐬 Çoklu ajan** | Yön | Ödünleşim | Düzey | | ------------------- | ------------------------------------------------------------------------------- | ------------------- | | **Çaba** | Dosya başına bir alt ajan, kod tabanınızın boyutuna göre ölçeklenir. | 2/5 | | **Süre** | Dosya başına paralel, ardından tek bir raporda birleştirilir. Yine salt okunur. | 3/5 | | **Token kullanımı** | Daha yüksek, ama yalıtılmış. Her alt ajan kendi bağlamında tarar. | 3/5 | ````md /lagune Lagune'yi kullanarak yolları listeleyen, her yol için bir alt ajan görevlendiren ve raporlarını birleştiren bir siber güvenlik orkestratörüsün (tüm içeriği alt ajanlar okur). Görevi mevcut projenin boyutuna göre alt ajanlara devretmelisin: kod tabanı ne kadar büyükse o kadar çok alt ajan görevlendirilmeli. Hepsini paralel çalıştır ve her birine aşağıdaki prompt'u ver: ```prompt /lagune Savunma güvenliğinde derin uzmanlığa sahip bir siber güvenlik araştırmacısısın ve bilgini ve isabetini artırmak için Lagune'yi kullanıyorsun. yolunu kendi başına tara ve bulduğun her kusuru somut bir düzeltmeyle eşleştir. Bu, Blue Team akışı değil, bağımsız bir taramadır: detect, plan, harden ya da verify çalıştırma ve Lagune'nin takibine hiçbir şey yazma. Sonunda içindeki her kusuru, önem derecesi ve somut bir düzeltmeyle birlikte listele. ``` Sonunda tüm alt ajan raporlarını, kusurların ve düzeltmelerin önceliklendirilmiş tek bir listesinde birleştir. ```` **Uyarı** Hızlı tarama, geniş ve kapsamı daraltılmamış tek bir prompt'tur, bu yüzden bazı ajanların onu reddetme ya da yarıda kesme olasılığı daha yüksektir. Sizinki direnirse bunun yerine aşağıdaki tam **Blue Team akışını** çalıştırın: kapsamı daraltılmış, adım adım ilerleyen fazlarının engellenme olasılığı çok daha düşüktür. --- ## 🌊 Otomatik Blue Team denetim akışı [Komut akışının tamamını](https://lagune.ai/tr-TR/docs/get-started/commands) girdi beklemek için durmadan baştan sona çalıştırır. **🪼 Varsayılan** | Yön | Ödünleşim | Düzey | | ------------------- | ------------------------------------------------------------------------------------- | ------------------- | | **Çaba** | Kod tabanının boyutundan bağımsız olarak tek bir ajan, alt ajan yok. | 3/5 | | **Süre** | Orta, ama büyük kod tabanlarında daha az kapsamlı. Her komut sırayla bir kez çalışır. | 4/5 | | **Token kullanımı** | Daha düşük, ama daha az yalıtılmış. Tüm komutlar aynı bağlamı paylaşır. | 4/5 | ```md Şu komutları sırayla tek tek çalıştır: `/lagune-charter`, `/lagune-detect`, `/lagune-plan`, `/lagune-harden` ve `/lagune-verify`. ## Döngü `/lagune-verify` bir ya da daha fazla düzeltmeyi reddettiğinde, tüm bulgular gerektiği gibi çözülene kadar `/lagune-harden` ve ardından `/lagune-verify` komutunu tekrarla. ## Önemli - Durma, soru sorma: şüpheye düştüğünde her şeyi "full" modda yap. ``` **🐋 Çoklu ajan (derin tarama)** | Yön | Ödünleşim | Düzey | | ------------------- | --------------------------------------------------------------------------------------------------------------------------------------- | ------------------- | | **Çaba** | Alt ajan sayısı kod tabanınızın boyutuna göre ölçeklenir. | 5/5 | | **Süre** | Daha uzun, ama daha kapsamlı. Bulguları paralel olarak tespit etmek, planlamak ve sıkılaştırmak için birden çok alt ajan görevlendirir. | 5/5 | | **Token kullanımı** | Daha yüksek, ama daha güvenli. Her alt ajanın önyargısız, kendine ait yalıtılmış bir bağlamı vardır. | 5/5 | ````md Şu komutların her birini bir alt ajana ver, her seferinde bir tane (ters tırnak olmadan, yalnızca komutu): Alt ajan 1 prompt'u: `/lagune-charter` Alt ajan 2 prompt'u: `/lagune-detect` Alt ajan 3 prompt'u: `/lagune-plan` Alt ajan 4 prompt'u: `/lagune-harden` Alt ajan 5 prompt'u: `/lagune-verify` `/lagune-detect`, `/lagune-plan`, `/lagune-harden` ve `/lagune-verify` komutlarında görevi mevcut projenin boyutuna göre alt ajanlara devretmelisin: kod tabanı ne kadar büyükse o kadar çok alt ajan görevlendirilmeli. Örneğin: ```prompt /lagune-detect ``` ```prompt /lagune-plan ``` ```prompt /lagune-harden ``` ```prompt /lagune-verify ``` - Aynı komut üzerindeki birden çok ajan paralel olarak görevlendirilmeli. - Tüm `/lagune-detect` alt ajanları bittiğinde şunu çalıştır: ```prompt /lagune-detect eşdeğer bulguları birleştir. Yeni bulgu arama ve kod tabanını yeniden tarama. ``` ## Döngü `/lagune-verify` bir ya da daha fazla düzeltmeyi reddettiğinde, tüm bulgular gerektiği gibi çözülene kadar `/lagune-harden` ve ardından `/lagune-verify` komutunu tekrarla. ## Önemli - Durma, soru sorma: şüpheye düştüğünde her şeyi "full" modda yap. ```` --- ## 🪄 Kapsamı daraltılmış tespit [`/lagune-detect`](https://lagune.ai/tr-TR/docs/commands/detect) komutunu projenin tamamı yerine bir dilimine yöneltin. Kapsamı sade bir dille tarif edin (bir commit, bir pull request ya da gerçek bir durum), komut yalnızca oradaki güvenlikle ilgili bulguları belirler. **İpucu** Burada tespit ettiği her şey normal bir bulgudur, bu yüzden yalnızca o öğelerle sınırlı olarak doğrudan `/lagune-plan`, `/lagune-harden` ve `/lagune-verify` komutlarına taşıyabilirsiniz. **📌 Bir commit** Yeni bir commit grubuna, yalnızca değiştirdikleriyle sınırlı kendi güvenlik geçişini verin, örneğin: ```prompt /lagune-detect Tespiti `a1b2c3d` commit'inden beri değişen her şeyle sınırla. ``` **🔀 Dal ya da PR diff** Bir pull request'i birleştirilmeden önce, yalnızca diff'iyle sınırlı olarak güvenlik açısından inceleyin, örneğin: ```prompt /lagune-detect Tespiti bu dalın `main` dalına göre getirdiği değişikliklerle sınırla. ``` **⛑️ Bir olaydan sonra** Ne olduğunu kendi sözlerinizle anlatın. Lagune bir bayrağı değil durumu okur ve onu odaklı bir aramaya dönüştürür, örneğin: ```prompt /lagune-detect Sitemizde birkaç hafta önce bir veri sızıntısı oldu. Tam olarak nasıl olduğunu bilmiyorum ve verinin yeniden sızmasına yol açabilecek bir açığın hâlâ açık olmasından endişeleniyorum. Kodu dikkatle incele, hassas verinin okunduğu, saklandığı ya da açığa çıktığı her yere odaklan ve hâlâ bir çıkış yolu olabilecek her şeyi belirle. Bunu bir tatbikat değil, gerçek bir olay olarak ele al. ``` --- ## 🚨 Zero Trust denetimi Çalışma alanının tamamını ve her bağımlılığı düşmanca kabul eder: yorumlayıcıları, ağ çağrılarını, kodlanmış payload'ları ve tarayıcılardan kaçmak için beklenmedik yerlere gizlenmiş kodu arar, ardından projenin kullanıma güvenli olup olmadığına dair bir evet ya da hayır kararıyla biter. Prompt'lar bu denetimin dayandığı uzmanlıkları, projenizin kategorileri ne olursa olsun doğrudan yükler. Kataloğun `/lagune` komutunun eşleştirdiği geri kalanı için projenin **OWASP**, **AI/LLM** ve kendi teknoloji yığınının kategorisini (örneğin **JavaScript**, **Python** vb.) kullandığından emin olun: ```bash npx lagune write add --categories owasp ai javascript ``` **Tehlike** Güvenilmeyen kaynaklardan gelen projeleri yerel ortamınızda çalıştırırken dikkatli olun. Kötü amaçlı kodun sisteminizi etkilemesini önlemek için **sandbox** (önerilir), **VM** ya da benzeri yalıtılmış bir ortam kullanın. **🪼 Varsayılan** | Yön | Ödünleşim | Düzey | | ------------------- | --------------------------------------------------------------------------------- | ------------------- | | **Çaba** | Tek bir ajan tüm çalışma alanını tarar, alt ajan yok. | 2/5 | | **Süre** | Orta. Tek bir ajan kodu ve bağımlılıklarını sırayla inceler. | 3/5 | | **Token kullanımı** | Orta, ama paylaşımlı. Uzmanlıklar, kod ve bağımlılıklar tek bir bağlama yüklenir. | 3/5 | ```md /lagune Zero trust savunma güvenliğinde derin uzmanlığa sahip bir siber güvenlik araştırmacısısın ve bilgini ve isabetini artırmak için Lagune'yi kullanıyorsun. Çalışma alanının tamamını güvenilmeyen bir kaynak ve potansiyel olarak kötü amaçlı bir kapsam olarak incele. Her yorumlayıcı, fetch, base64 ve benzeri, potansiyel bir tehdit olarak ele alınmalı. Analizini bağımlılıklara ve alt bağımlılıklara da genişlet: bir proje, tarayıcılardan kaçmak için kötü amaçlı kodu beklenmedik bir yere gizlemeye çalışabilir. Zorunlu uzmanlıklar (her birini `npx lagune read catalog ` ile tek tek yükle): - interpreter - secrets - llm - path Açık olmak gerekirse: belirlenen her güvenlik açığı istisnasız potansiyel bir tehdit olarak ele alınmalı. Sonunda projenin benim kullanmam için güvenli ve güvenilir olup olmadığına dair bir karar ver. ``` **🐋 Çoklu ajan (derin tarama)** | Yön | Ödünleşim | Düzey | | ------------------- | ------------------------------------------------------------------------------------------------------ | ------------------- | | **Çaba** | Dosya başına bir alt ajan, kod tabanınızın boyutuna göre ölçeklenir. | 5/5 | | **Süre** | Daha uzun, ama daha kapsamlı. Dosyalar paralel olarak taranır, ardından tek bir kararda birleştirilir. | 4/5 | | **Token kullanımı** | En yüksek, ama en güvenli. Her alt ajan uzmanlıkları kendi yalıtılmış bağlamında okur. | 5/5 | ````md /lagune Lagune'yi kullanarak dosyaları listeleyen, her dosya için bir alt ajan görevlendiren ve raporlar üreten bir siber güvenlik orkestratörüsün (tüm içeriği alt ajanlar okur). Her dosya için bir alt ajan görevlendir, hepsini paralel çalıştır ve her birine kendi dosyasıyla sınırlı olarak aşağıdaki prompt'u ver: ```prompt /lagune Zero trust savunma güvenliğinde derin uzmanlığa sahip bir siber güvenlik araştırmacısısın ve bilgini ve isabetini artırmak için Lagune'yi kullanıyorsun. dosyasını güvenilmeyen bir kaynak ve potansiyel olarak kötü amaçlı bir kapsam olarak ele al. Her yorumlayıcı, fetch, base64 ve benzeri, potansiyel bir tehdit olarak ele alınmalı. Analizi dosyasının içe aktardığı her şeye, kötü amaçlı kodun tarayıcılardan kaçmak için gizlenebileceği bağımlılıklar ve alt bağımlılıklar dahil, genişlet. Her alt ajan için zorunlu uzmanlıklar (her birini `npx lagune read catalog ` ile tek tek yükle): - interpreter - secrets - llm - path Açık olmak gerekirse: belirlenen her güvenlik açığı istisnasız potansiyel bir tehdit olarak ele alınmalı. Sonunda projenin benim kullanmam için güvenli ve güvenilir olup olmadığına dair bir karar ver. ``` Sonunda tüm alt ajan raporlarını tek bir nihai kararda birleştir. ```` --- # Security-Driven Hardening: yapay zeka destekli geliştirme çağı için bir yaklaşım > Security-Driven Hardening (SDH) metodolojisi: yapay zeka desteğiyle ve vibe coding ile geliştirilen yazılımları denetlemek ve sıkılaştırmak için bağlama duyarlı bir Blue Team yaklaşımı. Kanonik URL: https://lagune.ai/tr-TR/docs/references/paper Dil: tr-TR Orijinal: https://lagune.ai/docs/references/paper Son güncelleme: 2026-11-03 - **Weslley Araújo** - **Metodoloji makalesi, 2026.** --- ## Özet Security-Driven Hardening (SDH), yazılımları giderek daha çok yapay zeka ajanlarının ve güvenlik uzmanı olmayan kişilerin yazdığı bir dönem için tasarlanmış, yapılandırılmış, yapay zeka güdümlü ve yalnızca savunma odaklı bir güvenlik metodolojisidir. SDH genel bir kontrol listesi uygulamak yerine önce bir sistemin gerçekte ne yaptığını (oturum açma, dosya yükleme, ödemeler, veri ifşası vb.) tespit eder, ardından o bağlama özgü güvenlik çalışmasını yönlendirir. Varsayılan olarak güvenli ilkelerle yönetilir, tamamen savunma üzerine kuruludur ve her kullanıcının harekete geçebilmesi için sade bir dille ifade edilir. Bu belge, SDH'nin tek bir araç değil, eksik olan bir yaklaşım olduğunu savunur. Güvenlik bilgisi metodolojide ve onun talep üzerine yüklenen uzmanlıklarında, yani her kullanıcının üzerine inşa edebileceği bir temelde bulunur. Bu sayede aynı akış hem yeni başlayana hem de uzmana hizmet eder. İki özellik SDH'yi önceki spec-first yaklaşımlardan `[1]` ayırır. SDH **durumdan bağımsızdır**: boş bir dizine, devam eden bir projeye, tek bir pull request'e ya da büyük ve eski bir kod tabanına, her teknoloji yığınında uyum sağlar. SDH ayrıca **kapatılabilirdir**: kapandığı doğrulanan bir risk tüm akışta takipten çıkarılır, böylece o bulgu durgun bir duruma ulaşır ve yalnızca kod değiştiğinde yeniden açılır. SDH güvenlik profesyonellerinin ya da özelleşmiş Blue Team araçlarının yerini almaz. Geliştiricinin kendi bilgisini genişletir ve geliştirici güvenliği ne kadar iyi anlarsa akışı o kadar iyi yönlendirebilir. **Lagune** referans uygulamadır ve metodolojinin hayata geçirilebilir ve taşınabilir olduğunu kanıtlar. SDH, başkalarının benimseyebileceği bir yaklaşım olarak sunulur. > **Anahtar terimler** > > yapay zeka destekli geliştirme, yazılım güvenliği, savunma güvenliği, spec-driven development, güvenlik sıkılaştırması, ajan güdümlü iş akışları, kapatılabilirlik, bağlama duyarlı güvenlik, talep üzerine bilgi, ajandan bağımsız araçlar. --- ## I. Giriş: yapay zeka destekli geliştirmenin açtığı güvenlik boşluğu Yazılımları giderek daha çok, güvensiz bir kalıbı güvenilir biçimde tanıyamayan kişiler ve yapay zeka ajanları yayına alıyor: sızdırılmış bir gizli bilgi, eksik bir yetkilendirme kontrolü, enjeksiyona açık bir sorgu. Bunlar sıra dışı riskler değildir. Gerçek olaylarda baskın olan ve yıllardır kamuya açık kaynaklarda belgelenen risk sınıfları arasında yer alırlar `[6]`, `[7]`. Son çalışmalar da yapay zekanın ürettiği kodun azımsanmayacak bir kısmının tam olarak bu tür kusurlarla yayına çıktığını bildiriyor `[8]`. Yapay zeka kodlama asistanları, geliştirici olmayanların gerçek yazılım yayınlamasını mümkün kılarak sorunu keskinleştirdi, ancak boşluk tek bir kitleden çok daha geniştir. Çoğu proje, gerçekte yaptığı şeye özgü bir güvenlik incelemesinden hiç geçmez. Ekosistem, her erken "çalışıyor, yayınla" kararıyla biraz daha kırılganlaşır. Genel güvenlik tavsiyeleri bu boşluğu kapatmaz. Statik bir kontrol listesi bir sistemin ne yaptığına özgü olmadığı için küçük bir projeyi alakasız maddelerle boğar ve yine de o projede önemli olan riski kaçırır. Sorun, dünyada güvenlik bilgisinin az olması değildir. Sorun, doğru bilgiyi kullanıcının önündeki gerçek sistemle eşleştirmek ve bunu ne isteyeceğini bilmeyebilecek biri için yapmaktır. SDH buna tek bir tersine çevirmeyle yanıt verir: **güvenlik bilgisi spesifikasyonda ve onun talep üzerine yüklenen uzmanlıklarında, yani her kullanıcının üzerine inşa edebileceği bir temelde bulunur**. Metodoloji bağlamı tespit eder, o bağlamın taşıdığı riskleri önceliklendirir ve düzeltmelere rehberlik eder, böylece geliştirici de geliştirici olmayan da aynı akıştan yararlanır. Bulgular ve öneriler sade bir dille kalır, bu yüzden okuyucunun teknik derinliği ne olursa olsun uygulanabilirler. Bu yaklaşım uzmanı kısıtlamaz, tersine güçlendirir. Bu ikiliği `§VI` bölümünde ele alıyoruz. > **Temel fikir** > > **Temel tersine çevirme:** Güvenlik bilgisi spesifikasyonda ve onun talep üzerine yüklenen uzmanlıklarında, yani her kullanıcının üzerine inşa edebileceği bir temelde bulunur. Metodoloji sistemin ne yaptığını öğrenir, güvenlik çalışmasını buna göre eşleştirir ve kullanıcının zaten bildiklerini genişletir. Bir yapay zeka asistanına "uygulamam kullanıcıların profil fotoğrafı yüklemesine izin veriyor" diyen bir geliştirici düşünün. Bir güvenlik incelemesi olmadan asistan, istemcinin gönderdiği her şeye sessizce güvenen, çalışan bir kod üretir: beyan edilen dosya türüne, dosya adına, boyuta. Yükleme özelliği yayına çıkar. Görsel kılığına girmiş bir dosya kod taşıyabilir, özel hazırlanmış bir ad depolama yolunun dışına çıkabilir, aşırı büyük bir dosya sunucuyu tüketebilir. Bunların hiçbiri bir demoda görünmez, bu yüzden yayına çıkar. Aynı kod SDH'den geçtiğinde farklı bir sonuç ortaya çıkar. SDH sistemin dışarıdan dosya kabul ettiğini tespit eder (tespit), bunu bir yüklemenin taşıdığı risklere göre önceliklendirir (önceliklendirme), gerçek dosya türünü ve boyutunu kontrol etmeyi, kaydederken yeniden adlandırmayı ve kodun çalışamayacağı bir yerde saklamayı önerir (giderme), ardından sonucu okuyup her kontrolün gerçekten işe yaradığını doğrular (doğrulama). Geliştiricinin "kısıtlamasız dosya yükleme" ifadesini bilmesi hiç gerekmedi. Metodoloji bunu onun yerine sağladı. Bu belgenin katkıları şunlardır: - SDH'nin herhangi bir uygulamadan bağımsız, tasarım ilkeleriyle birlikte bir metodoloji olarak kesin tanımı (`§III`). - Görev ayrımının kendisinin katkı olduğu beş fazlı bir savunma yaşam döngüsü: tespit asla uydurmaz, planlama asla kodu okumaz, kodu yalnızca tek bir faz değiştirir ve doğrulama kararını asla yumuşatmaz (`§IV`). - Metodolojik bir duruş olarak **kapatılabilirlik**: tek bir bulgunun sonsuz bir döngüsü değil, bir son durumu vardır (`§V`). - **Geliştirici bilgisini genişletme** ikiliği: yeni başlayanı koruyan ve uzmanı güçlendiren tek bir akış (`§VI`). - **Tek başına çağrılamayan uzmanlıklar ve talep üzerine prompt**: ajanın varsayılan olarak değil, yalnızca projenin bağlamı gerektirdiğinde yüklediği odaklı güvenlik bilgisi (`§VII`). - **Durumdan bağımsızlık** ve **dayatmayan uyarlanabilirlik**: SDH her geliştirme durumuna uyar ve sabit bir kapsam dayatmak yerine senaryoya uyum sağlar (`§VIII`). - **Önleyici mod**: sıradan iş geliştirilirken çalışan aynı savunma, böylece kod varsayılan olarak güvenli hâlde ortaya çıkar ve fazlara düzeltecek daha az şey kalır (`§IX`). - SDH'nin içinden çıktığı ve sonra ayrıldığı soy olan Spec-Driven Development ile ayrıntılı bir karşılaştırma (`§X`). - Metodolojinin yeniden düzenlemelere dayanmasını ve herhangi bir ajandan bağımsız kalmasını sağlayan mühendislik disiplinleri: ada dayalı kimlik takibi (`§XI`) ve ajandan bağımsız bir taşıyıcı (`§XII`). --- ## II. Arka plan ve ilgili çalışmalar SDH önceki çalışmaların üzerine kuruludur. Spec-first ve ajan güdümlü geliştirmeden `[1]`, `[2]`, `[3]` kanıtlanmış bir yapı devralır: şablonlar, bir ajanın kullandığı slash komutları, yönetici bir belge ve fazları çalıştıran bir ajan. Bu yapıyı savunma amacıyla yeniden uygular. Bu soy bilinçli bir tercihtir ve SDH'nin çalışma ilkelerinden biri bunu doğrudan adlandırır: iş akışını kanıtlanmış bir yapıdan kurun, ardından onu güvenlik için çerçeveleyin. SDH, genel önerilerden oluşan statik bir kontrol listesi değildir. Bir kontrol listesi genel olarak güvenlik hakkında çok şey bilir, ama önündeki proje hakkında hiçbir şey bilmez. SDH bu vurguyu tersine çevirir. İlk çabasını tespite, yani sistemin ne yaptığını öğrenmeye harcar ve ancak ondan sonra tespitin önemli kıldığı bilgiye başvurur. SDH, güvenlik uzmanlarının ya da özelleşmiş Blue Team araçlarının yerine geçmez. Geliştiricinin bilgisini genişletir (`§VI`). Özel bir güvenlik birimi olan bir ekip onu korumalıdır. SDH böyle bir ekibe yapılandırılmış bir taşıyıcı, böyle bir birimi olmayan ekibe de savunulabilir bir temel sağlar. SDH ayrıca deterministik güvenlik tarayıcılarının (statik analiz, linter'lar) `[4]`, `[5]` yanında durur. Bu araçlar tam da deterministik ve tekrarlanabilir oldukları için değerlidir. SDH ise büyük ölçüde ajanın akıl yürütmesine dayanır ve katı determinizmi bağlama duyarlılık karşılığında bırakır. Metodoloji bunun aksini iddia etmez. Determinizmin önemli olduğu yerde akıl yürütmenin içine deterministik bir motor yerleştirir (`§VII`): bir girdinin kontrol edilmeye değer olup olmadığına ajan, o girdinin tehlikeli olup olmadığına ise deterministik bir program karar verir. En doğrudan önceki çalışma, bir yapıyı çalıştırılabilir bir spesifikasyondan ileriye doğru inşa eden spec-first metodolojiler ailesi olan Spec-Driven Development'tır (SDD). SDD'yi bir sınıf olarak ele alıyoruz. Bir uygulayıcı metodolojisi olarak en açık ifadesi Piskala'nın raporu `[1]`, ajan güdümlü en görünür araç seti ise GitHub'ın Spec Kit'idir `[2]`. Aynı aileden ikinci bir araç olarak OpenSpec `[3]` de vardır. Bunlar `§X` bölümündeki karşılaştırmanın temel kaynaklarıdır. --- ## III. SDH: tanım ve tasarım ilkeleri **Security-Driven Hardening**, işi geçici düzeltmelerle değil ajanın çalıştırdığı bir spesifikasyondan yönlendirerek bir kod tabanını daha güvenli hâle getiren, yapılandırılmış ve yapay zeka güdümlü bir güvenlik metodolojisidir. Adı, güvenlikte savunma tarafını temsil eden **Blue Team**'lerden esinlenmiştir. SDH savunma, sıkılaştırma ve doğrulama ile ilgilidir, asla saldırıyla değil. > **Tanım** > > **Security-Driven Hardening (SDH):** Önce bir sistemin gerçekte ne yaptığını tespit eden, ardından bağlama özgü güvenlik çalışmasını yönlendiren, varsayılan olarak güvenli ilkelerle yönetilen ve sade bir dille ifade edilen, yapılandırılmış, yapay zeka güdümlü ve yalnızca savunma odaklı bir güvenlik metodolojisi. SDH bir dizi bağlayıcı ilkeyle tanımlanır. Her biri bir kuraldır ve her biri kullanıcıya belirli bir güvence verir. | İlke | Kural | Kullanıcıya sağladığı güvence | | ----------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Varsayılan olarak güvenli, sade bir dille, herkes için eşit | Her varsayılan, mesaj ve düzeltme kutudan çıktığı gibi güvenlidir ve geliştirici olsun olmasın her okuyucu için anlaşılırdır. Hiçbir kullanıcı grubu ayrıcalıklı değildir. | Yeni başlayan biri istemeden güvenli bir temel alır ve sonucu kendi anladığı dille okur. | | Genel yerine bağlama duyarlı | Her faz detect fazında tespit edilen bağlamdan başlar ve sistemin gerçekte ne yaptığına göre hareket eder. | Öneriler bir kontrol listesine değil, projeye uyar. Güvenlik bilgisi spesifikasyonda ve onun talep üzerine yüklenen uzmanlıklarında bulunur ve kullanıcının getirdiklerini genişletir. | | Katı yerine esnek | İlkeler, gereksinimler ve öneriler birer başlangıç noktasıdır. Kullanıcı her şeyi yeniden ifade edebilir, çıkarabilir, ekleyebilir ya da kapsamını daraltabilir. | Metodoloji projeye ve kullanıcıya uyar, asla kullanıcının istediğinden daha katı olmaz. Esneklik, varsayılan olarak güvenli temeli asla zayıflatmaz. | | Uzlaştır, asla yalnızca ekleme | Artefaktlar günlük değil, yaşayan belgelerdir. Her çalıştırma her girdiyi yeniden kontrol eder: geçerli olanı korur, değişeni yeniden yazar, artık geçerli olmayanı kaldırır. | Kayıt her zaman bugünü yansıtır, böylece asla güncelliğini yitirmiş bir iş yığınına dönüşmez. | | Yalnızca savunma | SDH denetler, sıkılaştırır ve doğrular. Asla saldırı aracı, kötü amaçlı kullanım için exploit ya da zarar vermek için tespitten kaçınma yöntemi üretmez. | Metodoloji bir silaha dönüştürülemez. Çift kullanımlı içerik yalnızca açıkça savunma amaçlı bir çerçevede yer alır. | | Spec-first, ajan güdümlü, güvenlik için çerçevelenmiş | İş akışı şablonlardan, komutlardan, yönetici bir charter'dan ve fazları çalıştıran bir ajandan oluşur. | Ajanın asıl güvenlik işini yapacağı şekilde yeniden amaçlandırılmış, kanıtlanmış bir geliştirme yapısı. | **Tablo 1.** SDH'nin tasarım ilkeleri ve her birinin kullanıcıya sağladığı güvence. Bu ilkeler süs değildir. Aşağıdaki her fazın uyması gereken kısıtlardır ve `§XV` bölümündeki tartışma, metodolojinin sınırlarını belirlemek için onlara geri döner. Belgenin geri kalanı adı konmuş dokuz temel sütunu ele alır. Bunlar okuyucunun aklında tutabilmesi gereken parçalar ve başka bir ekibin SDH uyguladığını söyleyebilmek için yeniden uygulaması gereken parçalardır. | Sütun | Sağladığı | Bölüm | | --------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- | | Bağlama duyarlı tersine çevirme | Güvenlik bilgisi spesifikasyonda ve onun talep üzerine yüklenen uzmanlıklarında bulunur, böylece yeni başlayan da uzman da tek bir akışı paylaşır. | `§I`, `§VI` | | Beş fazlı savunma yaşam döngüsü | Görev ayrımı: politika, tespit, önceliklendirme, giderme, doğrulama, her birinin tek bir görevi vardır. | `§IV` | | Kapatılabilirlik | Bir bulgunun sonsuz bir döngüsü değil, bir son durumu vardır. Kapanan iş takipten çıkarılır. | `§V` | | Geliştirici bilgisini genişletme ikiliği | Yeni başlayanı koruyan ve uzmanı güçlendiren, hiçbirinin yerini almayan tek bir akış. | `§VI` | | Talep üzerine prompt, tek başına çağrılamayan bilgi | İlgili güvenlik bilgisi varsayılan olarak değil, projenin ne olduğuna göre yüklenir. | `§VII` | | Durumdan bağımsızlık ve dayatmayan uyarlanabilirlik | Her teknoloji yığınında her geliştirme durumuna uyar ve bir kapsam dayatmak yerine senaryoya uyum sağlar. | `§VIII` | | Önleyici mod | Aynı savunma yeni iş geliştirilirken çalışır, böylece kod varsayılan olarak güvenli hâlde ortaya çıkar. | `§IX` | | Ada dayalı kimlik takibi | Bir bulgu fazlar boyunca tek bir öğe olarak kalır ve bir yeniden adlandırma bağlantıyı yalnızca tek bir yerde koparır. | `§XI` | | Ajandan bağımsız taşıyıcı | Güvenlik değeri bir kez yazılır ve hiçbir ajana ya da teknoloji yığınına bağlı değildir. | `§XII` | **Tablo 2.** SDH'nin adı konmuş dokuz sütunu ve her birinin ele alındığı bölüm. --- ## IV. 5 fazlı Blue Team akışı SDH işi beş fazlı bir savunma yaşam döngüsü olarak yapılandırır (Şekil 1). Her faz savunma etrafında kurgulanır, her biri bir öncekinin üzerine inşa edilir ve fazlar gerçek Blue Team faaliyetini izler: politika belirleme, tespit, önceliklendirme, giderme, doğrulama. ```mermaid flowchart TB charter["1 · charter (politika)
okur: projeyi ve varsa kullanıcının açıklamasını
yazar: charter'ı
ilkeler önledikleri riski sade bir dille taşır"] detect["2 · detect (tespit)
okur: kullanıcının kodunu
yazar: tespit haritasını
uydurma değil tespit: yalnızca kodun desteklediğini kaydet"] plan["3 · plan (önceliklendirme)
okur: tespit haritasını, asla kodu değil
yazar: savunma planını
her düzeltme detect fazının gerçekten belirlediği bir şeye işaret eder"] harden["4 · harden (giderme)
okur: savunma planını ve dokunduğu kodu
yazar: kodu ve sıkılaştırma kaydını
kodu değiştiren tek faz, her seferinde tek düzeltme, işe yarayan en küçük değişiklik"] verify["5 · verify (doğrulama)
okur: kodu ve sıkılaştırma kaydını
yazar: her açık kararı sıkılaştırma kaydına
kodun kayıtla statik olarak karşılaştırılması, asla yumuşatılmadan"] charter --> detect --> plan --> harden --> verify verify -.->|"reddedildi: harden için yeniden açılan iş,
kaydedilen gerekçeye göre yeniden uygulanır"| harden verify -.->|"kapanış: kapandığını kanıtladığını
tüm zincirde takipten çıkarır,
geçmişte tek bir satır"| detect ``` **Şekil 1.** Beş fazlı akış: her fazın ne okuduğu, ne yazdığı ve dayandığı değişmez kural. Verify her iki dönüşü de yönetir: reddedilen bir kontrol harden fazını yeniden açar, kapandığı kanıtlanan bir bulgu ise tüm zincirde takipten çıkarılır ve geçmişte tek bir satır olarak kalır. Görev ayrımı katkının ta kendisidir. Her fazın tek bir görevi olduğu için bir hata tek bir yerde sınırlı kalır ve okuyucu her artefaktın iddia ettiğine güvenebilir. > **Temel fikir** > > **Applied, doğrulanmış demek değildir:** Harden bir düzeltmenin uygulandığını kaydeder. Verify ise kodu bu kayıtla karşılaştırarak onu doğrular ve karar asla kayda uysun diye yumuşatılmaz. Bir kontrol kodda bulunup yine de riski erişilebilir bırakabilir. O durumda dürüst karar "risk not closed" olur. ### charter (politika) Charter, projenin güvenlik ilkelerini, yani sonraki her fazın uyması gereken kuralları belirler. Yönetici katmandır, projenin güvenlik duruşu için bir tür derleme zamanı kontrolüdür. Her ilkenin açık bir adı, koda karşı kontrol edilebilen pazarlığa kapalı bir kuralı ve yalnızca düzeltmeyi değil, önlediği riski de belirten bir `Why:` satırı vardır. Charter her zaman projenin kendisini (manifestlerini, yapısını ve bağımlılıklarını) okur. Kullanıcı bir açıklama verdiğinde bu bir yöndür ve okuma, kullanıcının adını koyduğu şeylerin ötesine genişler. Açıklama yoksa tek kaynak projedir. İkisi birbiriyle yarışmaz, birbirini tamamlar ve charter kodun durumunu değil, projenin uyması gereken politikayı kaydeder. Geliştirici olmayan biri onu okuyup hem kuralı hem de riski anlayabilmelidir. ### detect (tespit) Detect kodu okur ve sistemin güvenlik açısından ağırlık taşıyan, gerçekte yaptığı şeyleri belirler. Yol gösteren talimat "uydurma değil, tespit"tir: yalnızca kodun desteklediğini, sonraki fazların ihtiyaç duyduğu kanıtla birlikte kaydet. Detect tarafsızdır. Bulgularını charter'a uydurmaya zorlamaz, çünkü riskleri charter'ın kurallarıyla eşleştirmek plan fazının işidir. Her bulgu üç parça taşır: ne olduğu (sade bir dille açıklama), neden önemli olduğu (yalnızca olgu değil, risk) ve kanıt (bulunduğu fonksiyon ya da rota). Kanıt dosya yolu içermez. Yol yalnızca takip haritasında bulunur (`§XI`), böylece metin asla güncelliğini yitirebilecek bir yol barındırmaz. ### plan (önceliklendirme) Plan her bulguyu, risk sınıfıyla adlandırılmış (dayanak oldukları yerde yerleşik kaynaklara, CWE ve OWASP'a atıf yaparak) ve düzeltmenin koruduğu charter ilkesine bağlı bir düzeltmeye dönüştürür. Öncelik (Critical, High, Medium, Low) serbest bir seçim değildir: plan her bulguyu CVSS v4.0 Base ve Environmental yöntemiyle puanlar. Böylece öncelik bandı, puanın sade kelimelerle ifadesidir, maruziyeti ve riskteki değeri anlatan sade bir satırla gerekçelendirilir ve iki çalıştırma aynı sıralamaya ulaşır. Vektör uzman için kesin dayanaktır, bant ve gerekçesi ise herkesin izleyebileceği aynı puanlamadır. Plan yalnızca tespit haritasından çalışır ve kodu asla okumaz. Bu bir sınırlama değil, bilinçli bir kısıttır: her düzeltmeyi detect fazının gerçekten tespit ettiği bir şeye işaret etmeye zorlar. Bir kapsam hiç haritalanmamışsa plan tahmin yürütmek yerine durur ve kullanıcıyı detect fazına geri yönlendirir. ### harden (giderme) Harden kodu değiştiren tek fazdır, bu yüzden dikkatli ilerler. Bir düzenlemenin kullanıcı onayı gerektirip gerektirmediğine ajan ve onun çalıştığı izin modu karar verir, bu yüzden harden kendine ait bir onay adımı eklemez. Düzeltmeleri teker teker uygular, önce bağımlılıkları, sonra en yüksek önceliği ele alır, böylece her değişiklik küçük, incelenebilir ve kolayca geri alınabilir kalır. Yeni bir düzeltmeyi sığdırmak için mevcut bir kontrolü asla zayıflatmaz ve bir charter ilkesini asla çiğnemez. Bir düzeltme bir ilkeyle çatışacaksa harden onu uygulamak yerine durur ve çatışmayı ortaya koyar. Her blok Applied, Partial ya da Blocked olarak kaydedilir. "Applied henüz doğrulanmış demek değildir" ve bir sonraki faz tam olarak bu endişeyi ele alır. ### verify (doğrulama) Verify, uygulanan her kontrolü kodu okuyup harden fazının kaydettikleriyle karşılaştırarak doğrular. Doğrulama bu karşılaştırmanın, kodun kayda karşı sınanmasının kendisidir ve statiktir: bir kontrolün kodda bulunduğunu ve doğru olduğunu teyit eder, çalışan bir sistemde saldırı altında işe yaradığını değil. Canlı sisteme karşı gerçek ya da simüle saldırılar yürüten bu tür çalışma zamanı kontrolü, tasarım gereği kapsam dışındadır. Verify üç karardan birini döndürür: risk closed, risk not closed ya da cannot tell from the code. Kendine ait bir artefakt üretmez: harden ve verify sıkılaştırma kaydını paylaşır, yapılanlar harden fazına, karar ve gerekçesi verify fazına aittir ve hiçbiri asla diğerinin alanlarına yazmaz. Reddedilen bir kontrol harden için yeniden açılan iştir. Harden bir sonraki çalıştırmasında bu kararı kodu kendi okumasının önüne koyar ve gerekçenin adını koyduğu boşluğa karşı düzeltmeyi yeniden uygular. Verify kayıt yerine koda güvenir, çünkü bir kayıt kodun sağladığından fazlasını iddia edebilir. Kullanıcının kodunda yalnızca okuma yapar ve bir kararı kayda uysun diye asla yumuşatmaz. Bir kontrol mevcut olup riski başka bir yoldan erişilebilir bırakabilir ve bu durumda dürüst karar "risk not closed" olur. Verify okurken tespit haritasının hiç kapsamadığı bir güvenlik sorunu fark ederse, tespit detect fazının işi olduğu için onun için bir karar uydurmaz: sorunu ortaya koyar ve kullanıcıyı detect fazına geri yönlendirir, böylece bulgu akışı atlamak yerine aynı akıştan girer. > **Örnek akış: dosya yükleme.** Tek bir bulgu, akışın omurgasını baştan sona gösterir. > > - **detect** onu bulur: sistem kullanıcılardan dosya kabul eder ve yükleme işleyicisi, dosyanın gerçek türünü kontrol etmeden istemcinin gönderdiği MIME türüne güvenir. _Neden önemli:_ görsel kılığına girmiş bir dosya kötü amaçlı kod gizleyebilir. > - **plan** düzeltmeye karar verir, öncelik **Critical**, korunan ilke "Doğrulanana kadar her girdi güvenilmezdir": dosyanın gerçek türünü ve boyutunu kontrol et, kaydederken yeniden adlandır ve yüklemeleri kod olarak çalıştırılamayacakları bir yerde sakla. > - **harden** düzeltmeyi uygular, durum **Applied**: işleyici artık gerçek türü içerikten tespit eder, bir boyut sınırı uygular, beklenmeyen her şeyi reddeder, kaydederken yeniden adlandırır ve kodun çalışamayacağı bir yerde saklar. > - **verify** işleyiciyi okur, kayıtla karşılaştırır ve **risk closed** döndürür: kod tam olarak kaydın iddia ettiğini yapar. > > Aynı bulgu adı tespit haritası, plan ve sıkılaştırma kaydı boyunca taşınır ve verify o kayıt üzerinde aynı adla işlem yapar: açık bir karar bulgunun bloğuna yazılır, kapandığı kanıtlanan bir bulgu ise takipten çıkarılır (`§V`). Bu ortak ad, bulgunun kimliğidir (`§XI`). --- ## V. Kapatılabilirlik: bir bulgunun son durumu vardır Güvenlik araçlarının çoğu kullanıcıyı yalnızca büyüyen bir iş yığınıyla baş başa bırakır. SDH farklı bir tutum benimser: **bir bulgu kapatılabilir, bu yüzden sonsuz bir iş yığınında yaşamak yerine bir son durumu vardır** (Şekil 2). Bu, doğrudan uzlaştırma ilkesinden çıkar. > **Tanım** > > **Kapatılabilirlik:** Kapandığı doğrulanan bir risk tüm akışta takipten çıkarılır, böylece o bulgu durgun bir duruma ulaşır ve yalnızca kod değiştiğinde yeniden açılır. Güvenlik programının kendisi sürekli olsa da bir bulgunun bir son durumu vardır. SDH artefaktları günlük değil, yaşayan belgelerdir. Bir faz her yeniden çalıştığında mevcut her girdiyi güncel gerçeğe göre yeniden kontrol eder ve üç şeyden birini yapar: hâlâ geçerli olanı korur, değişeni yeniden yazar ya da artık geçerli olmayanı kaldırır. Kodun artık çözüldüğünü gösterdiği bir bulgu doğrudan kaldırılır. Çalışma kaydı geçmişi değil, bugünü yansıtır. Kapanış, aynı uzlaştırmanın sonuca ulaşmasıdır. Verify bir riskin kapandığını doğruladığında bulguyu tüm akışta takipten çıkarır: tespit haritasında, planda, sıkılaştırma kaydında ve takip haritasında. Verify fazının diğer fazların artefaktlarına yazan tek faz olmasının nedeni budur: döngüyü kapatan fazdır. Bulgu zincirden ayrılırken takipten çıkarma işlemi onu, çalışma zincirinin dışında duran ve asla yeniden işlenmeyen bir geçmiş kaydında kısa bir girdiye dönüştürür. Kaybolmakla kapanmak arasındaki çizgi budur: artık doğru olmadığı için uzlaştırmanın kaldırdığı bir bulgu geride hiçbir şey bırakmaz, kapandığı kanıtlanan bir bulgu ise geçmişte kendi satırını hak eder. Takipten çıkarılan bir bulgu bundan sonra hiçbir çalışma artefaktında yer almaz ve bu yokluk kopuk bir zincir değil, beklenen bir durumdur. ```mermaid stateDiagram-v2 direction TB [*] --> OPEN: detect tespit eder OPEN --> Plan: plan Plan --> Harden: harden Harden --> Verify: verify Verify --> StoodDown: risk closed StoodDown --> SETTLED SETTLED --> OPEN: kod değişikliği bir bulguyu yeniden açar Plan: plan Harden: harden Verify: verify StoodDown: TAKİPTEN ÇIKARILDI · geçmişte tek bir satır ``` **Şekil 2.** Kapatılabilirlik durum makinesi. Bir bulgu OPEN → TAKİPTEN ÇIKARILDI → SETTLED yolunu izler ve yalnızca kod değiştiğinde yeniden açılır. Kapsamdaki her şey takipten çıkarıldığında döngü durgun hâle gelir ve bu durgun durumun somut bir biçimi vardır: son bulgusu kapanan bir artefakt bütünüyle kaldırılır, böylece tamamen kapanmış bir zincirde yalnızca charter ve geçmiş, yani politika ve kanıt kalır. Döngü yalnızca kod değiştiğinde yeniden açılır. Metodoloji her bulguya kesin bir son verir ve sonsuz bir iş yığınının yapamadığı da tam olarak budur. --- ## VI. Geliştirici bilgisini genişletme ikiliği SDH insanların yerini almaz ve özelleşmiş Blue Team araçlarının da yerini almaz. **Geliştiricinin kendi bilgisini genişletir**. Geliştirici güvenliği ne kadar iyi anlarsa akışı o kadar hassas yönlendirebilir ve o kadar fazla özerkliğe sahip olur. Az şey bilen bir geliştirici de güvenli bir sonuç alır, çünkü otomatik mod onu korur. `§I` bölümündeki tersine çevirme, yani güvenlik bilgisinin spesifikasyonda bulunması, iki yönde de geçerlidir. Yeni başlayan için bu bir korumadır: ne isteyeceğini bilmesi gerekmez, çünkü öneriyi spesifikasyon yapar. Uzman için ise bir güçlendirmedir: aynı spesifikasyon, sabit bir kontrol listesiyle boğuşmak yerine akışı hassasiyetle yönlendirmesini sağlar. Her faz bu ikiliği kendi işleyişinde taşır (Şekil 3). Girdi verilmeden çalıştırıldığında kullanıcı adına tüm kapsam üzerinde işlem yapar. Bir yön verildiğinde aynı faz, kullanıcının hedeflediği şeye tam olarak daralır. ```mermaid flowchart TB inversion["tek tersine çevirme, iki yön:
güvenlik bilgisi spesifikasyonda bulunur"] inversion --> auto["otomatik mod (girdi yok)
faz önerir ve tüm kapsam
üzerinde işlem yapar"] inversion --> directed["yönlendirilmiş mod (girdi var)
faz, kullanıcının hedeflediği
şeye tam olarak daralır"] auto --> novice["yeni başlayan, korunur:
ne isteyeceğini bilmeden
güvenli bir sonuç"] directed --> expert["uzman, güçlenir:
sabit bir kontrol listesi değil,
hassasiyetle yönlendirilen akış"] novice -.-> phases["aynı beş faz ikisine de hizmet eder:
charter · detect · plan · harden · verify"] expert -.-> phases ``` **Şekil 3.** Geliştirici bilgisini genişletme ikiliği. Tek bir tersine çevirme iki kitleye hizmet eder: otomatik mod yeni başlayanı korur, yönlendirilmiş mod ise aynı beş faz üzerinden uzmanı güçlendirir. Talep üzerine yüklenen uzmanlıklar (`§VII`) bu ikiliği kendi metinlerinde açıkça ortaya koyar. Her biri ajana, bilgisinin "muhakemesini genişlettiğini" ve uzmanlığın sunduklarının ötesinde akıl yürütmeye devam etmesini söyler. Bilgi bir tavan değil, bir tabandır. Belgenin hedeflediği dengede iki kitleye de hizmet eden budur: geliştirici topluluğu güçlü bir araç kazanır, Blue Team uygulayıcısı ise kendi işini onun yerine yapıyormuş gibi davranmayan yapılandırılmış bir taşıyıcı kazanır. --- ## VII. Tek başına çağrılamayan uzmanlıklar ve talep üzerine prompt Bu, metodolojinin en yenilikçi kalıbıdır. SDH odaklı güvenlik bilgisini **yalnızca talep üzerine** yüklenen uzmanlıklar olarak taşır ve hangisinin yükleneceğine projenin bağlamıyla eşleştirerek ajanın kendisi karar verir. Buna **talep üzerine prompt** diyoruz: ajanın her kontrolü varsayılan olarak çalıştırmak yerine, içinde bulunduğu projenin kapsamına göre hangi bilgiyi etkinleştireceğini seçmesinin bir yolu. Uzmanlıklar evrimseldir ve herhangi biri her an değişebilir ya da başkasıyla değiştirilebilir. Katkı uzmanlıkların kendisi değil, kalıptır. > **Tanım** > > **Talep üzerine prompt:** Ajan, hangi güvenlik bilgisini etkinleştireceğini önündeki projenin kapsamıyla eşleştirerek seçer, böylece her kontrol varsayılan olarak çalışmak yerine projenin gerçekte ne olduğuna uygun bilgi devreye girer. > **Tanım** > > **Tek başına çağrılamayan uzmanlık:** Dosya yükleme ya da tarayıcıda çalışan kod gibi tek bir bağlam için odaklı ve dilden bağımsız bir güvenlik bilgisi birimi. Denetler ve açıklar, asla kodu yeniden yazmaz ve asla saldırı girdisi üretmez. Bir komut değildir: kapsadığı bağlam kapsamdayken ya da bir prompt onu adıyla istediğinde yüklenir. Her uzmanlık, kapsadığı riskler için daha güvenli biçimleri adlandırır ve ajana onu kullanan her fazda bir bulguya nasıl yaklaşacağını söyler: tespitte onu nasıl değerlendireceğini, gidermede düzeltmesini nasıl güvenle uygulayacağını ve doğrulamada onu nasıl kanıtlayacağını. Belirleyici özellik, bir uzmanlığın **tek başına çağrılamamasıdır**: bir komut değildir ve akışın içinde onu yükleyen şey bir eşleşmedir. Tespit fazı kataloğu bir kez listeler, projenin bağlamını her girdinin kapsadığı şeyle eşleştirir ve yalnızca bağlamı kapsamda bulunan uzmanlıkları yükler. Sonraki fazlar yeniden listelemek yerine bu eşleşen listeyi kullanır, böylece tek bir eşleşme tüm zincire hizmet eder. Önleyici mod (`§IX`) da aynı eşleştirmeyi inşa edilmek üzere olan işe karşı çalıştırır. Bağlamı bulunmayan bir uzmanlık atlanır ve atlama da yükleme kadar hesap verebilirdir: katalogdaki her girdi açık bir karar alır, uygulandı ya da gerekçesi koddan okunarak atlandı, böylece belirsiz bir alakasızlık hissi asla yokluğun yerini tutmaz. Hiçbirinin uygulanabilir olmaması da geçerli bir sonuçtur. Katalog veridir ve büyüme asla yeni bir komut değil, bir bilgi dosyası ile bir katalog satırıdır. Yerleşik uzmanlıklar OWASP, bir programlama dili ya da yapay zeka entegrasyonları gibi kategorilerde gruplanır ve bir projenin kullandığı katalog, seçtiği kategorilerin yerleşik uzmanlıklarını ve projenin kendi uzmanlıklarını içerir. Proje bu seçimi durumunun geri kalanıyla birlikte kaydeder, böylece tüm ekip aynı katalogla eşleştirme yapar. Bu, fazlardaki bağlama duyarlılık ilkesinin bilgiye uygulanmış hâlidir: her kontrol varsayılan olarak çalışmak yerine projenin gerçekte ne olduğuna uygun bilgi devreye girer. Aynı özellik, kataloğu yalnızca bakımcının değil kullanıcının da büyütmesine imkân verir: kullanıcının sağladığı bir güvenlik kaynağının ya da konunun özü çıkarılarak projeye ait yeni bir uzmanlık oluşturulur. Bu uzmanlık kategoriler ne olursa olsun projenin kataloğuna katılır, tıpkı yerleşik bir uzmanlık gibi yüklenir ve aynı adı taşıyan yerleşik uzmanlığın yerini alır. Bir uzmanlık yazmak da yalnızca savunma odaklıdır ve uzmanlıkların uyguladığı sınıra uyar: kaynak bir saldırı yazısı olabilir, ama ondan çıkan uzmanlık denetler ve açıklar, asla çalışan bir exploit üretmez. Böylece `§I` bölümündeki tersine çevirme, yani zekânın spesifikasyonda bulunması, kullanıcının kod yazmadan kendi bağlamı için derinleştirebileceği kataloğun kendisine kadar uzanır. Kısa bir örnek talep üzerine prompt'u açıklar. Detect, tarayıcıda çalışan kodlardan oluşan bir klasörü okur. Bu bağlamı katalogda eşleştirir, onu kapsayan uzmanlığı yükler ve detect fazının normal adımlarıyla istemci tarafı bir bulguyu ortaya koyar. Bağlamı bu kapsamda bulunmayan uzmanlıklar eşleşmez, bu yüzden hiç yüklenmez ve her biri atlandı olarak kaydedilir. Hangi bilginin ilgili olduğuna sabit bir yapılandırma değil, proje karar verdi. Determinizm tam da önemli olduğu yerde ortaya çıkar. Bir uzmanlık yalnızca metin değil, deterministik bir denetleyici de taşıyabilir: bir risk sınıfının net bir karar prosedürü olduğu yerde küçük bir program, verilen bir girdi için sabit bir karar döndürür, örneğin `safe`, `unsafe` ya da `invalid input` gibi kısa bir kelime kümesi. Bazı risk sınıfları tam olarak bu şekilde deterministik olarak karara bağlanabilir ve karar prosedürünün arkasında önceki çalışmalardan oluşan bir birikim vardır `[9]`, `[10]`, `[11]`. Denetleyici ya ajanın sağladığı adayları puanlar ya da onları bulmak için kapsamı kendisi tarar ve her iki durumda da kararı ajan değil denetleyici verir. Yeterince evrensel bir uzmanlık katalogda zorunlu olarak işaretlenebilir ve o zaman her zaman uygulanır, denetleyicisi tüm kapsam üzerinde çalışır. Bilginin bağlam eşleşmesi olmadan yüklendiği tek durum budur ve bu durum asla o anda ajan tarafından kararlaştırılmaz, katalog verisinde beyan edilir. SDH, akışın tamamının deterministik olduğunu iddia etmeden, ajanın akıl yürütmesini burada tekrarlanabilir bir şeye dayandırır. Son olarak uzmanlıklar **bağımsız kullanılabilir**. Bilgi kendi başına ayakta durduğu için kullanıcı bir uzmanlığı, SDH akışının tamamıyla hiçbir ilgisi olmayan bir prompt'ta doğrudan çalıştırabilir ve güvenliği sıradan geliştirmenin yanında tutabilir. Örneğin deterministik bir denetleyici taşıyan bir uzmanlık, sıradan kodlama sırasında üretilen her adayı eleyip yalnızca güvenli olanları tutabilir. Bu bağımsızlık, SDH'nin bu kadar çok duruma uyum sağlamasının nedenlerinden biridir ve `§VIII` bölümünün konusudur. En eksiksiz ifadesi ise aynı bilginin sıradan geliştirmeyi baştan sona koruduğu önleyici moddur (`§IX`). --- ## VIII. Durumdan bağımsızlık ve dayatmayan uyarlanabilirlik İki özellik SDH'yi katı spesifikasyon metodolojilerinden ayırır. ### Durumdan bağımsızlık > **Tanım** > > **Durumdan bağımsızlık:** Metodoloji geliştirme durumuna bağlı değildir. Başlangıç noktasını okuyarak öğrendiği için boş bir dizine, devam eden bir projeye, tek bir pull request'e ya da büyük ve eski bir kod tabanına, her teknoloji yığınında uyar. Her faz, proje yepyeni de olsa zaten var da olsa aynı şekilde çalışır. Charter mevcut koddan ilkeler çıkarır. Detect, çok az da olsa orada bulunan kodu haritalar. Varsayılan bir başlangıç noktası yoktur. ### Dayatmayan uyarlanabilirlik > **Tanım** > > **Dayatmayan uyarlanabilirlik:** Metodoloji, kullanıcının izlemesi gereken sabit bir kapsam dayatmak yerine senaryoya uyum sağlar. Kullanıcı ne söyleyeceğini bilmediğinde çağrıldığı ortamı okur, bağlam üretir ve bir sonraki adımını şekillendiren soruları sorar. En açık örnek charter'ın öneri modudur: SDH projeyi analiz ederek varsayılan olarak güvenli bir charter çıkarır, kullanıcıya yalnızca bir boşluk sonucu gerçekten değiştirdiğinde soru sorar, ardından charter'ı yazar ve her ilkeyi önlediği riskle birlikte sade bir dille sunar. Charter, bir onay isteminin arkasına kilitlenmiş bir sözleşme değil, kullanıcının yeniden çalıştırarak üzerinde çalıştığı yaşayan bir belgedir, bu yüzden kullanıcının ne isteyeceğini bilmesini asla gerektirmez. Bu uyarlanabilirlik, girdinin biçimine duyarlılık olarak kendini gösterir: aynı faz kendisine verileni okur ve bir mod seçer (Şekil 4). Prompt'taki bir dosya, listeden bir bulgu, bir endişe, bilinen bir zayıf noktaya karşı odaklı bir görev ya da tam kapsamlı bir kaba kuvvet taraması talebi: her biri kullanıcının ihtiyacına uyar, çünkü akış tasarım gereği dayatmaz. Bunların hiçbiri varsayılan olarak güvenli temeli zayıflatmaz. Esneklik temelin nasıl uygulanacağını şekillendirir, onu asla düşürmez. ```mermaid flowchart TB shape["faz kendisine verilenin
biçimini okur"] shape --> none["girdi yok"] shape --> paths["bir ya da daha fazla yol"] shape --> concern["anlatılan bir endişe"] shape --> finding["adı verilen bir bulgu"] shape --> band["bir öncelik bandı"] none --> auto["otomatik mod:
öner ya da tüm
kapsamı tara"] paths --> focus["yalnızca o dosyalara
ya da dizinlere odaklan"] concern --> scoped["kapsamı o tek
endişeyle sınırla"] finding --> item["yalnızca o takip
edilen öğe üzerinde çalış"] band --> priority["yalnızca Critical, High,
Medium ya da Low üzerinde çalış"] ``` **Şekil 4.** Dayatmayan uyarlanabilirlik. Aynı faz girdisinin biçimini okur ve bir mod seçer, böylece kapsam her zaman kullanıcınındır, asla dayatılmaz. --- ## IX. Evrensel önleyici mod: iş inşa edilirken aynı savunma SDH tamamlayıcı bir mod taşır: kod yazılırken aynı savunmanın etkin olduğu sıradan geliştirme. Kullanıcı işin kendisini, bir oturum açma sayfasını, bir yüklemeyi, bir uç noktayı ister ve metodoloji inşa sürecini olduğu anda korur, böylece sonuç sonradan yapılacak bir sıkılaştırma geçişinden sonra değil, ortaya çıktığı anda varsayılan olarak güvenlidir. > **Tanım** > > **Önleyici mod:** SDH'nin yönetici katmanı ve bilgisi altında yürütülen sıradan geliştirme. Charter inşa sürecini bağlar, oluşturulmak üzere olan şeyle ilgili uzmanlıklar talep üzerine yüklenir ve iş bitti denmeden önce sonuç, tam olarak kullanılan savunmayla karşılaştırılır. Mod, fazların zaten taşıdığı her parçayı yeniden kullanır, ama bunları henüz var olmayan koda yöneltir. Bağlam tespiti koddan niyete döner: ajan inşa etmek üzere olduğu şeyi ve o işin geçtiği sınırları düşünür (bir oturum açma özelliği kimlik bilgilerini, bir oturumu ve dışarıdan gelen girdiyi gerektirir) ve bilgi kataloğu bu akıl yürütmeyle eşleştirilir. Talep üzerine prompt (`§VII`) burada genelleşir: bağlam yalnızca var olan kodda değil, kodun planında da tespit edilebilir. Charter her zamanki gibi yönetir ve bir ilkeyi çiğneyecek bir istek asla inşa edilmez, bir çatışma olarak ortaya konur. Savunma satır içinde, her parçanın yazıldığı anda uygulanır: sınırda doğrulama yapılır ve ilk seferde güvenli yapıya başvurulur, böylece düzeltilmesi gereken, çalışan ama güvensiz bir sürüm hiç var olmaz. Mod, verify fazının başladığı şekilde biter. İş bitti denmeden önce inşa eden, kendi sonucunu kullandığı savunmayla karşılaştırır: kontrol riskin yanında değil, yolunun üzerinde durmalı ve eksiksiz olmalıdır. Bir uzmanlık deterministik bir denetleyici taşıyorsa denetleyicinin kararı ajanın kendi okumasının önüne geçer. Burada bulunan bir boşluk aynı işin parçası olarak kapatılır, çünkü işi bitirmek onu güvenli biçimde bitirmek demektir. Modun reddettikleri de yaptıkları kadar bilinçlidir. Yalnızca isteneni inşa eder ve çevresindeki hiçbir şeyi denetlemez: var olanı denetlemek fazların işidir. Hiçbir artefakt yazmaz ve hiçbir bulguyu takip etmez, çünkü bir bulgu var olan şeyde tespit edilmiş bir risktir ve bu modun amacı güvensiz sürümün hiç ortaya çıkmamasıdır. İki yön birbirini tamamlar: fazlar zaten orada olanı kapatır (`§V`), önleyici mod ise yeni işin onu yeniden açmasını engeller. Durgun bir zincir, geliştirme durduğu için değil, durgunken inşa edilen her şey savunmalı inşa edildiği için durgun kalır. --- ## X. Security-Driven Hardening ile Spec-Driven Development karşılaştırması Security-Driven Hardening (SDH), Spec-Driven Development (SDD) temelinden doğdu ve ardından ondan keskin biçimde ayrıldı. Yapısal miras gerçektir ve kabul edilir: spec-first, ajan güdümlü, yönetici bir belge ve ajanın çalıştırdığı fazlara ayrılmış bir komut kümesi. SDH bu yapıyı bilinçli olarak yeniden kullanır. Farklı olan amaç, yetki modeli, varsayılan durum ve bitiş koşuludur. SDD'yi bir sınıf olarak ele alıyoruz: metodolojinin temel ifadesi olarak Piskala'nın raporunu `[1]`, temel ajan araç seti olarak GitHub'ın Spec Kit'ini `[2]` ve aynı aileden ikinci bir araç olarak OpenSpec'i `[3]` kullanıyoruz. SDD, spesifikasyonları çalıştırılabilir kılarak geleneksel geliştirmeyi tersine çevirir: spesifikasyon uygulamaya yalnızca rehberlik etmekle kalmaz, doğrudan çalışan bir uygulama üretir `[1]`. Faz kümesi bir inşa sürecini ileriye doğru yürütür `[2]` (yönetici ilkeleri belirle, ne inşa edileceğini tanımla, teknoloji yığınını planla, planı görevlere böl, ardından uygula). Yönetici belgesi, bir ilkeler anayasası, ajanın baştan sona uyması gereken temel parçadır. Farkın özü buradadır. SDD'de yetki spesifikasyondan inşa sürecine akar ve uygulamanın ona uyması beklenir. SDH bu sözleşmenin neredeyse her eksenini tersine çevirir (Tablo 3). > **Temel fikir** > > **Temel fark:** SDD'de yetki spesifikasyondan inşa sürecine akar ve uygulamanın ona uyması beklenir. SDH dayatmaz ve ters yönde, sistemin tespit edilen bağlamından içeriye doğru akar ve zaten orada olanı sıkılaştırır. | Eksen | SDD | SDH | | ------------------ | ------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | | Amaç | Özellik teslim etmek. Spesifikasyon çalışan bir uygulamaya dönüşür. | Var olanı ya da inşa edilmekte olanı sıkılaştırmak. Her faz savunma için çerçevelenir. | | Yetki modeli | Dayatır. Spesifikasyon ve anayasa, inşa sürecini uyması gereken bir kapsama hapseder. | Dayatmaz. SDH senaryoya uyum sağlar ve kullanıcı yeniden ifade edebilir, çıkarabilir ya da kapsamı daraltabilir. | | Durum varsayımı | Bir spesifikasyondan ileriye doğru inşa. | Durumdan bağımsız: boş dizin, devam eden proje, tek bir PR ya da eski kod. | | Bitiş koşulu | Özellik inşa edildiğinde biter. | Kapatılabilir. Bir bulgu durgun bir duruma ulaşır ve yalnızca kod değiştiğinde yeniden açılır. | | Yönetici belge | Ajanın uyması gereken bir ilkeler anayasası. | Riske göre çerçevelenmiş ilkelerden oluşan bir charter (her biri bir `Why:` satırı taşır), açıkça sabit bir sözleşme değildir. | | Bilginin büyümesi | Bir komut eklemek (ya da faz kümesini genişletmek). | Ajanın talep üzerine yüklediği, tek başına çağrılamayan bir uzmanlık eklemek: bir dosya ve bir katalog satırı, yeni komut yok. | | Kime hizmet eder | Bir özelliği ileriye taşıyan bir geliştiriciye. | Geliştirici olsun olmasın, aynı akıştan yararlanan her kullanıcıya. | | Kodu ne değiştirir | Uygulama fazı inşa sürecini üretir. | Kodu yalnızca harden fazı değiştirir, her seferinde tek bir düzeltme. | **Tablo 3.** Sekiz eksende SDD ile SDH. Ödünç alınmış yapı, tersine çevrilmiş sözleşme. Bu soya hakkını vermek gerekirse: SDD kanıtlanmış bir önceki çalışmadır ve SDH üzerinde çalıştığı yapıyı ona borçludur. Ayrışma, farklı bir sorunu (ileriye doğru inşayı) iyi çözen SDD'ye yönelik bir eleştiri değildir. SDH aynı kanıtlanmış mekanizmayı alır ve savunmaya, uyarlanabilirliğe ve kapanışa yöneltir. Değişiklik önerileri, görev listeleri ve değişiklik başına spesifikasyonlar etrafında düzenlenen OpenSpec `[3]` de bu kalıbı doğrular: aile bir yapıyı spesifikasyondan ileriye doğru inşa eder, SDH ise bir sistemi tespit edilen bağlamından içeriye doğru sıkılaştırır. SDH'nin ileriye doğru bir inşaya eşlik ettiği tek yer olan önleyici mod (`§IX`) bile tersine çevrilmiş sözleşmeyi korur: işin nasıl inşa edileceğini yönetir, neyin inşa edileceğine asla karar vermez. --- ## XI. Mühendislik titizliği: takip disiplini Uzlaştır, asla ekleme disiplini (`§V`), yeniden düzenlemelere dayanan bir altyapıya ihtiyaç duyar. Bir bulgu, ona dokunan her fazda tek bir öğe olarak kalmalı ve yeniden adlandırılan ya da taşınan bir dosya zinciri koparmamalıdır. SDH bunu **ada dayalı kimlik** ve **yalnızca takipte tutulan yollar** ile çözer. > **Tanım** > > **Ada dayalı kimlik:** Bir bulgunun kimliği, her artefaktta aynı şekilde yazılan adıdır. Metin adı taşır, asla bir yolu değil. Dosya yolları yalnızca takip haritasında bulunur, böylece bir yeniden adlandırma ya da taşınan bir dosya bağlantıyı tam olarak tek bir yerde koparır. Her detect bulgusu takip edilen tek bir öğedir. Kimliği, tespit haritasında, planda ve sıkılaştırma kaydında aynı şekilde yazılan bölüm başlığı, yani **adıdır**. Sonraki fazlar aynı öğe üzerinde çalışırken bu adı kelimesi kelimesine yeniden kullanır ve verify kararını sıkılaştırma kaydına aynı adla yazar. Takip haritası takipten başka bir şey tutmaz, her öğe için tek bir girdi: ```json { "name": "File uploads", "paths": ["src/routes/upload.ts"] } ``` Harita metin, not, ayrı bir tanımlayıcı ya da faz kaydetmez. Metin artefaktları ifadeyi, harita ise yalnızca kimliği ve yolları taşır. Dosya yolları tek değişken şeydir ve yalnızca burada bulunur. Bir yeniden adlandırma ya da taşınan bir dosya bağlantıyı tam olarak tek bir yerde koparabilir, asla birbirinden ayrışan iki kopyada değil. ```mermaid flowchart TB detect["tespit haritası"] --> name plan["savunma planı"] --> name harden["sıkılaştırma kaydı
verify kararını buraya yazar"] --> name name["name = "File uploads"
metin adı taşır, asla bir yolu değil"] name -.-> tracking tracking["takip haritası
{ name: "File uploads",
paths: ["src/routes/upload.ts"] }
yol yalnızca burada bulunur, bu yüzden bir yeniden adlandırma yalnızca bu girdiyi düzeltir"] ``` **Şekil 5.** Kimlik taşıyıcısı. Tek bir bulgu adı her artefakttan geçer, yolu ise yalnızca takip haritasında bulunur, böylece bir yeniden adlandırma tek bir yerde düzeltilir. Haritayı normal akışta iki işlem korur, üçüncüsü ise bakım işlemi olarak ayrı durur. **Track** eklemeli bir kayıttır: bir faz yazdığı bulguları bildirir, motor yenilerini kaydeder ve geri kalanlar için yeniden adlandırılmış bir yolu izler, her birini yeni, taşınmış ya da değişmemiş olarak sınıflandırır. Fazın bildirmediği hiçbir şeyi asla kaldırmaz. **Untrack**, verify fazının kapattığı bulguları takipten çıkarır: tek bir deterministik geçişte her birini geçmiş girdisine dönüştürür, bölümünün tamamını artefaktlardan kaldırır, son bulgusu kalmayan bir artefaktı siler ve takip girdisini düşürür, böylece ajan bunların hiçbirini elle yapmaz. Deterministik geçişin güvenle gidemediği yerde, örneğin takipten çıkarılan bir ad başka bir bulgunun metninde hâlâ anılıyorsa, bir düzenleme tahmin etmek yerine o noktayı ajan için işaretler. Fazların çalışırken çağırdığı bu ikisidir. **Repair** bakım işlemidir: bir faz kendi uzlaştırması takibi tutarsız bulduğunda (kaydedilmiş bir yol artık yoksa) işi otomatik olarak ona devreder, bunun dışında talep üzerine çalıştırılır. Tüm haritayı bir kerede yeniden hizalar, her artefaktı ve güncel kodu okur, her öğenin yollarını düzeltir ve tek başına karar veremediği şeyleri ortaya koyar: bir sahipsiz öğe (artık hiçbir artefaktın adını anmadığı, takip edilen bir öğe) ya da bir yeniden adlandırma adayı (yolları bildirilen farklı bir adla eşleşen bir öğe). Repair bir bakım işlemidir, altıncı bir faz değildir. Ne kullanıcının koduna ne de metin artefaktlarına dokunur, yalnızca takibe dokunur. Kullanıcının kaynak kodunu tek bir nedenle, yeniden adlandırılmış bir dosyanın yeni yolunu öğrenmek için okur ve asla güvenlik içeriği yazmaz. Motorun tahmin etmeyi reddettiği tek konuda, yani kaybolan bir öğenin çözülüp çözülmediği ya da yalnızca yeniden adlandırılıp adlandırılmadığı konusunda son sözü insan söyler. Tahmin etmek yerine sormak tercih edilir, çünkü yanlışlıkla düşürülen bir öğe zinciri koparır. Metodoloji kendi savunma disiplinini kendisine de uygular. Deterministik motorlar komut satırı programları olarak çağrılır ve her girdi kendi süreç argümanı olarak aktarılır. Bu, girdiyi etkisiz tutar, böylece tırnak ya da ters tırnak içeren bir değer komuta asla enjekte edilemez. Bilinmeyen bir kontrol yanıt vermek yerine başarısız olur, böylece yanlış yazılmış bir kontrol asla temiz bir sonuç gibi okunmaz. SDH kendi altyapısını varsayılan olarak güvenli ilkesinden muaf tutmaz. --- ## XII. Taşıyıcı: taşınabilirliğin kanıtı olarak ajandan bağımsız mimari SDH'nin başkalarının benimsediği bir yaklaşım olabilmesi için tek bir ajana ya da tek bir teknoloji yığınına bağlı olmaması gerekir, bu yüzden taşıyıcısı üç sorumluluğu birbirinden ayrı tutar (Şekil 6). Lagune bunun başarılabilir olduğunu kanıtlar. **Güvenlik değeri** bir kez yazılır ve onu hangi ajanın çalıştırdığı hakkında hiçbir şey bilmez: faz talimatları ve doldurdukları şablonlar, bilgi kataloğu ve deterministik motorlar. **Dağıtım** incedir: tek görevi bu değeri belirli bir ajana, ajanın beklediği biçimde ve yerde ulaştırmaktır ve kendine ait hiçbir güvenlik mantığı taşımaz. **Projenin durumu** projeye aittir: charter, faz artefaktları, takip haritası, seçtiği kategoriler ve kendi uzmanlıkları, kodunun herhangi bir parçası gibi commit edilir ve incelenebilir. ```mermaid flowchart TB value["bir kez yazılan güvenlik değeri
faz talimatları · şablonlar · bilgi kataloğu · deterministik motorlar
onu hangi ajanın çalıştırdığını bilmez"] delivery["dağıtım
bu değeri her ajana beklediği biçimde ulaştırır
güvenlik mantığı taşımaz"] agent["ajan
fazları çalıştırır"] project["projenin durumu
koduyla birlikte commit edilir
charter · faz artefaktları · takip · kategoriler · kendi uzmanlıkları"] value --> delivery --> agent agent -->|"okur ve yazar"| project ``` **Şekil 6.** Ajandan bağımsız taşıyıcı. Güvenlik değeri bir kez yazılır, ince bir dağıtım katmanı onu her ajana ulaştırır ve durum projede kalır. Dağıtım hiçbir güvenlik mantığı taşımadığı için nasıl inşa edildiği SDH'de hiçbir şeyi değiştirmez. Bir taşıyıcı dağıtımı kendisi inşa edebilir ya da referans uygulamanın yaptığı gibi ajan becerilerini zaten dağıtan bir ekosisteme devredebilir. Fazlar, artefaktları ve güvenceleri aynı kalır. Bunların hiçbiri bir programlama diline ya da çalışma ortamına da özgü değildir. Referans uygulama tesadüfen tek bir teknoloji yığınıyla yazılmıştır, ama metodoloji bu sorumluluklar arasındaki sınırdır, onları inşa eden araç zinciri değil. Aynı tasarım SDH'nin ne olduğunu değiştirmeden tamamen başka bir dilde yeniden uygulanabilir. --- ## XIII. Uygulamalı örnek: baştan sona SDH > **Uygulamalı örnek** > > **Bir yükleme ve yönetim yüzeyinin savunma amaçlı sıkılaştırılması.** > **Bağlam:** kullanıcıların dosya yüklemesini kabul eden ve bunları bir yönetim sayfasında listeleyen küçük bir uygulama. > **Kalıp:** charter → detect (bağlamla etkinleşen talep üzerine bilgiyle) → plan → harden → verify, bir kapanış ve bir gerçek başarısızlıkla. > **Sonuç (yetenek):** kapandığı doğrulanıp tüm zincirde takipten çıkarılan bir risk ve kapanmadığı doğrulanıp harden fazına geri gönderilen bir kontrol. Karar kaydı değil, kodu yansıtır. _Bu, metodolojinin işleyişini gösteren açıklayıcı bir örnektir, sahada ölçülmüş bir çalışma değildir ve hiçbir etkinlik ölçümü bildirmez._ Tek ve kesintisiz bir anlatım, metodolojinin yalnızca parçalarını değil, işleyişini de gösterir. `§IV` bölümündeki dosya yükleme örneğini talep üzerine bir bilgi etkinleştirmesi ve bir kapanışla genişletiyor ve bir gerçek başarısızlığı da dahil ediyoruz. 1. **charter**, riskini sade bir dille belirterek "Doğrulanana kadar her girdi güvenilmezdir" ilkesini önerir: kontrol edilmeyen girdi, bir sistemin kırılmasının en yaygın yoludur. 2. **detect**, yükleme rotasını ve yüklenen dosyaları listeleyen küçük yönetim sayfasını tarar. Yükleme bulgusunu tespit eder (işleyici istemcinin MIME türüne güvenir). Yönetim sayfası tarayıcıda çalışır ve talep üzerine prompt (`§VII`) bu bağlamı tanır, bu yüzden detect o bağlamın uzmanlığını yükler ve ikinci bir bulguyu ortaya koyar: bir dosya adının sayfaya metin olarak değil işaretleme (markup) olarak yazıldığı bir yer. Bu yüzden özel hazırlanmış bir ad, ziyaretçinin tarayıcısında betik olarak çalışabilir. Bağlamı bu kapsamda bulunmayan uzmanlıklar hiç yüklenmez ve her atlama, koddan okunan yoklukla birlikte kaydedilir. 3. **plan**, ilkeye bağlı olarak yükleme düzeltmesine Critical önceliğini verir: dosyanın gerçek türünü ve boyutunu kontrol et, kaydederken yeniden adlandır, kodun çalışamayacağı yerde sakla. İkinci düzeltmeye High önceliğini verir: dosya adını işaretleme olarak değil, metin olarak göster. 4. **harden** önce yükleme düzeltmesini (en yüksek öncelik) uygular ve Applied olarak kaydeder, ardından ikincisini uygular, Applied. 5. **verify** her noktayı okur ve kodu kayıtla karşılaştırır. Yükleme kontrolü işe yarar: işleyici gerçek türü içerikten tespit eder, bir boyut sınırı uygular ve geri kalanı reddeder. Karar: risk closed. Verify yükleme bulgusunu tüm zincirde takipten çıkarır ve bulgunun özeti geçmişe geçer. Ardından gerçek başarısızlık gelir. Harden fazının ikinci düzeltmesinin güvenli bir metin gösterme yardımcısı eklediğini, ama işaretleme yazan eski çağrıyı başka bir kod yolunda hâlâ erişilebilir bıraktığını varsayalım. Verify sayfayı okur, güvenli yardımcıyı görür ve güvensiz yolun hâlâ etkin olduğunu da görür. Kontrol mevcuttur, ama risk kapanmamıştır. Verify kararı kayda uysun diye yumuşatmayı reddeder. "risk not closed" döndürür, boşluğu kaydeder ve harden fazına geri işaret eder. Riski tam olarak ele almayan bir kontrol geçer not almaz. Metodolojinin karakteri bu tek örnekte görülür: bağlama duyarlı tespit, ilkelere bağlı ve önceliklendirilmiş düzeltmeler, dikkatli uygulama ve kayıt ne derse desin kodun gerçek durumunu bildiren bir doğrulama. --- ## XIV. SDH ne zaman kullanılır ve sınırları SDH, ağır bir sürecin olabileceği gibi orantısız hâle nadiren gelir, çünkü durumdan bağımsız ve kapatılabilirdir: tek bir dosyaya ve tek bir endişeye kadar küçülebilir ve kalıcı bir yük bırakmak yerine durgun bir duruma ulaşır. Sınırı proje boyutu değil, **güvence derinliğidir**. ```mermaid flowchart TB q1{"Kod güvenlikle ilgili bir şey yapıyor mu?
(girdi, kimlik doğrulama, veri, gizli bilgiler, dış çağrılar)"} q1 -->|hayır| little["SDH burada pek bir şey katmaz."] q1 -->|evet| q2{"SDH'yi çalıştırın. Bir uyumluluk çıtası
ya da özel bir güvenlik birimi var mı?"} q2 -->|hayır| baseline["SDH savunulabilir bir temeldir."] q2 -->|evet| carrier["SDH yapılandırılmış taşıyıcıdır:
uzman incelemesini ve denetimi destekler,
onların yerini almaz."] ``` **Şekil 7.** SDH ne zaman kullanılır. Ayrım önce güvenlikle ilgililiğe, sonra güvence derinliğine göre yapılır, asla proje boyutuna göre değil. SDH'nin sınırına ulaştığı yerler: yalnızca sistem çalışırken ortaya çıkan davranışlar (verify kodu okur, sistemi çalıştırmaz), ajanın okuyamadığı bir yapılandırmaya ya da ortama bağlı riskler ve ne olursa olsun uzman incelemesinin gerektiği yüksek riskli bağlamlar. Bunların her birinde SDH yapılandırılmış bir ilk geçiş olarak yine değer katar, ama bir tavan değil, bir tabandır. > **Temel fikir** > > **Sınır:** SDH'nin sınırı proje boyutu değil, güvence derinliğidir. Neredeyse her yerde savunulabilir bir temel olarak hizmet edebilir ve risklerin gerektirdiği yerde uzman incelemesini destekler, ama çalışan sistem testlerinin ya da bir güvenlik profesyonelinin muhakemesinin yerini almaz. --- ## XV. Tartışma: konumlandırma, sınırlar ve SDH'nin iddia etmedikleri SDH sınırları konusunda nettir. ### Genişletir, yerini almaz SDH güvenlik profesyonellerinin ya da özelleşmiş Blue Team araçlarının yerini almaz. Geliştiricinin bilgisini genişletir (`§VI`). Doğru iddia ölçülü olandır: iyi uygulandığında SDH, özellikle aksi hâlde hiçbir güvenlik incelemesinden geçmeyecek projelerde, gerçek riskleri etkili biçimde **kapatabilir**. Bu bir garanti değildir ve risklerin gerektirdiği yerde uzman incelemesinin yerine geçmez. ### Yapısı gereği yalnızca savunma SDH denetler, sıkılaştırır ve doğrular. Asla saldırı aracı, exploit ya da zarar vermek için tespitten kaçınma yöntemi üretmez. Çift kullanımlı güvenlik içeriği yalnızca açıkça savunma amaçlı ve yetkilendirilmiş bir çerçevede kabul edilebilir. Bu bir tercih değil, kesin bir sınırdır. ### Doğrulama göstermelik değil, özlüdür Verify sistemi çalıştırarak değil, kodu okuyup kayıtla karşılaştırarak doğrular. Bu statik doğrulamadır: bir kontrolün kodda bulunduğunu ve doğru olduğunu teyit eder, kontrolün çalışma zamanında saldırı altında işe yaradığını kanıtlamaz. Bu yüzden "cannot tell from the code", başarılı bir sonucun arkasına gizlenmiş bir başarısızlık değil, meşru bir karardır. Kanıt kodda bulunmadığında (bir yapılandırmaya ya da ajanın okuyamadığı bir yola bağlıysa) SDH tahmin etmek yerine bunu açıkça söyler. ### Determinizmin kapsamı belirlidir ve adı konmuştur SDH'nin büyük kısmı ajanın akıl yürütmesine dayanır ve bağlama duyarlılığını mümkün kılan da budur. Determinizm deterministik motorlara ayrılmıştır: bir uzmanlığın taşıyabileceği denetleyiciler (`§VII`) ve takip motoru (`§XI`). Belge bu çizgiyi bulanıklaştırmaz. Bir sonuç deterministikse bir programın sonucudur. Akıl yürütmeye dayanıyorsa ajanın kodu okuyuşudur ve son söz kullanıcıya aittir. ### Maliyet ve ölçek Tam bir tarama çok token tüketir. Manuel modlar (`§VI`, `§VIII`) kısmen maliyeti endişeyle orantılı tutmak için vardır. ### Son söz kullanıcınındır SDH, yeniden adlandırma ile çözülme arasındaki kararı insana bırakır ve kod düzenlemelerinin onayı, kullanıcının ajanını zaten yönettiği yerde, ajanı çalıştırdığı izin modunda kalır. Metodoloji önerir ve doğrular. Kişinin kararını çiğnemez. ### İtirazlar ve yanıtlar Adil bir şüpheci birkaç itiraz dile getirecektir. Esaslı olanları kendi sözleriyle sormaya değer. **"Bu, üzerine LLM eklenmiş bir statik analizci değil mi?"** Hayır. Bir statik analizci sahip olduğu her kuralı varsayılan olarak çalıştırır. SDH önce sistemin ne olduğunu tespit eder, sonra ilgili bilgiye başvurur (`§II`, `§VII`) ve deterministik bir denetleyiciyi yalnızca bir risk sınıfının net bir karar prosedürü olduğu yerde _yerleştirir_. Akıl yürütme bağlamı önceler, determinizm hedeflidir. **"Bu sadece bir güvenlik kontrol listesi değil mi?"** Hayır. SDH kontrol listesini tersine çevirir: önce tespit gelir ve bilgi, projenin gerçekte ne yaptığına göre devreye girer (`§II`, `§VII`). **"Bu, güvenlik için yeniden markalanmış SDD değil mi?"** Hayır. SDH, SDD'nin yapısını ödünç alır ve sözleşmesini tersine çevirir: yetki, durum varsayımı, bitiş koşulu ve kime hizmet ettiği tamamen farklıdır (`§X`). Aynı mekanizma, ters yön. **"Yapay zekanın akıl yürütmesine dayanan bir yöntem bulgu uydurmaz mı?"** Tasarım, modelin düzgün davranacağına güvenmek yerine uydurmayı kısıtlar. Detect yalnızca kodun desteklediğini kaydeder ("uydurma değil, tespit", `§IV`), verify kodu kayıtla karşılaştırır ve "cannot tell from the code" yanıtını verebilir (`§XV`), deterministik denetleyiciler karara bağlanabilen durumları sağlam bir zemine oturtur (`§VII`) ve son söz kullanıcınındır. Bu, ajanı yanılmaz kılmaz, iddialarını kontrol edilebilir kılar. Konumlandırma üzerine bir not. SDH burada referans uygulamasından bağımsız olarak tanımlanmıştır. Beş faz, riske göre çerçevelenmiş charter, uzlaştır-asla-ekleme ilkesi ve onun getirdiği kapatılabilirlik, talep üzerine bilgi, önleyici mod, ada dayalı kimlik takibi ve yalnızca savunma sınırı metodolojinin kendisidir. Başka bir ekip bunları başka bir teknoloji yığınında ve başka bir ajan ekosisteminde uygulayabilir ve sonuç yine SDH olur. Lagune onun tanımı değil, kanıtıdır. --- ## XVI. Tuzaklar ve SDH'nin onlardan yapısal olarak nasıl kaçındığı Bu ailedeki metodolojiler bilinen bir dizi başarısızlık biçimini paylaşır. SDH'nin bunların çoğuna yanıtı yapısaldır, disipline bırakılmak yerine akışın içine yerleştirilmiştir. | Tuzak | Başarısızlık | SDH'nin yapısal yanıtı | | ----------------------------------------- | -------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------- | | Spesifikasyon çürümesi, eskiyen iş yığını | Artefaktlar kimsenin güvenmediği ölü girdiler biriktirir | Uzlaştır, asla ekleme (`§V`): her çalıştırma her girdiyi yeniden kontrol eder ve çözüleni kaldırır | | Sahte güven, başarılı sonuç | Mevcut bir kontrolün riski kapattığı varsayılır | Verify kodu kayıtla karşılaştırır, böylece "risk not closed" ve "cannot tell" birinci sınıf kararlardır (`§IV`, `§XV`) | | Kontrol listesi seli | Genel maddeler önemli olan tek riski gölgede bırakır | Genel yerine bağlama duyarlı, talep üzerine prompt ile yalnızca kapsamın gerektirdiği yüklenir (`§VII`) | | Araca kilitlenme | Yöntem tek bir sağlayıcıya ya da ajana kaynaklanmıştır | Ajandan bağımsız taşıyıcı: güvenlik değeri bir kez yazılır ve her ajana dağıtımı hiçbir güvenlik mantığı taşımaz (`§XII`) | | Sonsuz döngü | İş yığını hiç kapanmaz, iş hiç durulmaz | Kapatılabilirlik ve durgun durum (`§V`) | **Tablo 4.** Bu metodoloji ailesindeki bilinen tuzaklar ve SDH'nin her birine yapısal yanıtı. Önemli olan tuzağı adlandırmak ve mekanizmayı göstermektir: bunlar dikkatli olma uyarıları değil, akışın özellikleridir. --- ## XVII. Gelecek çalışmalar Metodolojinin ve referans uygulamasının net sonraki adımları vardır. - **Bilgi kataloğunu büyütmek:** Her ekleme `§VII` biçimini korur: bir bilgi dosyası ve bir katalog satırı, yeni komut yok. Kullanıcı tarafındaki yol zaten mevcuttur: kullanıcı kendi uzmanlıklarının özünü talep üzerine çıkarır. Her biri bir kategoriye katılan daha fazla yerleşik dil, çalışma ortamı ve risk sınıfı bakımcı tarafındaki yöndür ve uzmanlıkların evrilmesi beklenir. - **Daha fazla deterministik denetleyici:** Bir risk sınıfının net bir karar prosedürü olduğu yerde bir uzmanlık, ajanın akıl yürütmesini tekrarlanabilir bir karara dayandıran deterministik bir denetleyici taşıyabilir. Bunu daha fazla risk sınıfına genişletmek doğal bir yöndür. - **Ampirik değerlendirme:** En güçlü açık soru ölçülmüş etkinliktir: gerçek kod tabanlarında kapanış kalitesi ve hatalı karar oranları. SDH'nin güvenlik sonuçlarına dair bir çalışma gelecek işidir ve buradaki iddiaların kapsamı buna göre belirlenmiştir. --- ## XVIII. Sonuç Yapay zeka destekli geliştirme, genel kontrol listelerinin dolduramayacağı bir güvenlik boşluğu açtı, çünkü önemli olan risk bir sistemin gerçekte ne yaptığına özgüdür ve onu yayına alan kişi ne isteyeceğini bilmeyebilir. SDH bu boşluğu, güvenlik bilgisinin metodolojide ve onun talep üzerine yüklenen uzmanlıklarında, yani her kullanıcının üzerine inşa edebileceği bir temelde bulunduğu, bağlama duyarlı, yalnızca savunma odaklı ve kapatılabilir bir akışla kapatır. Sistemin gerçek bağlamını tespit eder, o bağlamın taşıdığı riskleri önceliklendirir, düzeltmeleri dikkatle uygular ve her birini doğrular, ardından kapattığı şeyleri takipten çıkarır, böylece her bulgu bir son duruma ulaşır. Aynı savunma yeni iş inşa edilirken önleyici olarak da çalışır, böylece akışın kapattığı şey kapalı kalır. Her teknoloji yığınında her geliştirme durumuna uyum sağlar ve bu işi zaten yapan insanların ve araçların yerini almak yerine geliştiricinin bilgisini genişletir. Lagune kanıttır, ama katkı yaklaşımın kendisidir. SDH, yapay zekayla geliştirme çağı için temel güvenlik akışı olarak, başkalarının benimsemesi, geliştirmesi ve kendi teknoloji yığınlarında uygulaması için sunulur. --- ## Kaynaklar **[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. (Submitted to AIWare 2026.) [Online]. Available: https://arxiv.org/abs/2602.00180 **[2]** GitHub, "Spec Kit: Toolkit for Spec-Driven Development." [Online]. Available: https://github.com/github/spec-kit. Accessed: 2026. **[3]** Fission AI, "OpenSpec: Spec-Driven Development for AI Coding Assistants." [Online]. Available: https://github.com/Fission-AI/OpenSpec. Accessed: 2026. **[4]** B. Chess and 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]. Available: https://owasp.org/www-community/Source_Code_Analysis_Tools. Accessed: 2026. **[6]** OWASP Foundation, "OWASP Top 10:2021." [Online]. Available: https://owasp.org/Top10/. Accessed: 2026. **[7]** MITRE, "Common Weakness Enumeration (CWE)." [Online]. Available: https://cwe.mitre.org/. Accessed: 2026. **[8]** N. Perry, M. Srivastava, D. Kumar, and 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]. Available: https://arxiv.org/abs/2211.03622 **[9]** J. Davis and contributors, "safe-regex: Detect Possibly Catastrophic, Exponential-Time Regular Expressions." [Online]. Available: https://github.com/davisjam/safe-regex. Accessed: 2026. **[10]** D. Soshnikov, "regexp-tree: Regular Expressions Processor in JavaScript." [Online]. Available: https://github.com/DmitrySoshnikov/regexp-tree. Accessed: 2026. **[11]** T. Jenkinson, "redos-detector: A CLI and Library to Score How Vulnerable a Regex Pattern Is to ReDoS Attacks." [Online]. Available: https://github.com/tjenkinson/redos-detector. Accessed: 2026. --- ## Ek A: İlkeler, olduğu gibi 1. **Varsayılan olarak güvenli, sade bir dille, herkes için eşit:** Her varsayılan, mesaj ve düzeltme kutudan çıktığı gibi güvenli olmalı ve geliştirici olsun olmasın her kullanıcı için anlaşılır olmalıdır. Hiçbir kullanıcı grubu diğerinden ayrıcalıklı değildir. 2. **Genel yerine bağlama duyarlı:** Her faz detect fazında tespit edilen bağlamdan başlamalı ve sistemin gerçekte ne yaptığına göre hareket etmelidir. Genel kontrol listeleri yerine o bağlama özgü önerileri tercih edin. Güvenlik bilgisi spesifikasyonda ve onun talep üzerine yüklenen uzmanlıklarında bulunur ve kullanıcının getirdiklerini genişletir. 3. **Katı yerine esnek:** SDH projeye ve kullanıcıya uyum sağlar. İlkeler, gereksinimler ve öneriler sabit bir sözleşme değil, birer başlangıç noktasıdır. Kullanıcının her şeyi yeniden ifade etmesine, çıkarmasına, eklemesine ya da kapsamını daraltmasına izin verin. Esneklik varsayılan olarak güvenli temeli asla zayıflatmaz, yalnızca kullanıcının onun nasıl uygulanacağını şekillendirmesine izin verir. 4. **Uzlaştır, asla yalnızca ekleme:** Artefaktlar günlük değil, yaşayan belgelerdir. Bir faz yeniden çalıştığında mevcut her girdiyi güncel gerçeğe göre uzlaştırın: hâlâ geçerli olanı koruyun, değişeni yeniden yazın ve artık geçerli olmayanı kaldırın. Kapanış, aynı uzlaştırmanın sonuca ulaşmasıdır. 5. **Yalnızca savunma:** SDH denetler, sıkılaştırır ve doğrular. Asla saldırı aracı, kötü amaçlı kullanım için exploit ya da zarar vermek için tespitten kaçınma yöntemi üretmez. Çift kullanımlı güvenlik içeriği yalnızca açıkça savunma amaçlı ve yetkilendirilmiş bir çerçevede kabul edilebilir. 6. **Spec-first, ajan güdümlü, güvenlik için çerçevelenmiş:** İş akışını kanıtlanmış bir yapıdan kurun: şablonlar, komutlar, yönetici bir charter ve fazları çalıştıran bir ajan. Bu yapıyı savunma amacıyla yeniden uygulayın. --- # Lagune sözlüğü: SDH, charter, bulgular ve kontroller > Lagune ve Security-Driven Hardening terimlerinin her birinin sade bir dille tanımı: SDH, charter, detect, bulgu, kontrol, harden, verify, takipten çıkarma, kapatılabilirlik, uzmanlıklar, kategoriler ve katalog. Kanonik URL: https://lagune.ai/tr-TR/docs/references/glossary Dil: tr-TR Orijinal: https://lagune.ai/docs/references/glossary Son güncelleme: 2026-11-03 Lagune'nin ve Security-Driven Hardening metodolojisinin temel taşı olan her terim, bir kez ve sade bir dille tanımlanmış hâliyle. ### Security-Driven Hardening (SDH) Lagune'nin uyguladığı metodoloji: bir sistemin bağlamını tespit eden, bu bağlamın taşıdığı riskleri önceliklendiren ve düzeltmelere yön veren, bağlama duyarlı bir Blue Team yaklaşımı. Güvenlik bilgisi, spesifikasyonda ve talep üzerine yüklenen uzmanlıklarında bulunur. Böylece geliştirici olan da olmayan da aynı akışla hizmet alır. ### Lagune SDH'nin referans uygulaması: bir yapay zeka ajanının bir kod tabanını sıkılaştırmak için çalıştırdığı, her biri doldurduğu şablonla birlikte gelen dokuz ajan komutu. Her ajan bu komutları [kurulum sayfasında](https://lagune.ai/tr-TR/docs) gösterildiği gibi kendi eklenti yükleyicisiyle ya da [**skills.sh**](https://www.skills.sh/wellwelwel/lagune) üzerinden kurar ve komutlar her deterministik adım için Lagune'nin motorunu çalıştırır. ### Charter Lagune'nin yönetici katmanı: sonraki her fazın uyması gereken, güvenliği öne koyan ilkeler. Bunu, bir projenin güvenlik duruşu için derleme zamanı denetimi gibi düşünebilirsiniz. `.lagune/memory/charter.md` dosyasında saklanır. ### Geliştirme akışı Kodu yazılırken sıkılaştıran evrensel `/lagune` komutu. Herhangi bir aşamada herhangi bir prompt alır, istediğinizi oluşturur ve size teslim etmeden önce güvenli varsayılanlarla sıkılaştırır. Bir charter varsa ona göre yön alır. Lagune'nin takibine hiçbir şey yazmaz, bu yüzden tek ürünü sıkılaştırılmış koddur. Charter (öncesinde) ve Blue Team akışıyla (sonrasında) birlikte, Lagune'nin geliştirme sırasında koruma sağlama biçimidir. ### Blue Team akışı Lagune'nin merkezindeki beş fazlı denetim: charter, detect, plan, harden, verify. Her faz bir öncekinin üzerine kurulur. "Blue Team", saldırgan Red Team'in karşısında yer alan savunucuların güvenlik geleneğidir. ### Bulgu Tespit edilmiş tek bir risk. Her bulgu ne olduğunu, neden önemli olduğunu ve koddaki kanıtını taşır. Bulgu, plan, harden ve verify fazlarının ileriye taşıdığı, her artefaktta adıyla tanınan tek takip birimidir. ### Kontrol Bir riski kapatmak için uygulanan güvenlik önlemi. Harden kontrolleri uygular, verify işe yaradıklarını kanıtlar. Lagune bir prompt'u karşılamak için bir kontrolü asla zayıflatmaz. ### Detect Kodu okuyup sistemin ne yaptığını ve risklerin nerede olduğunu belirleyen faz. Yönetici kuralı uydurmak değil tespit etmektir: yalnızca kodun desteklediğini kaydeder. ### Harden Kodunuza dokunan tek faz. Planın düzeltmelerini birer birer uygular ve her birini Applied, Partial ya da Blocked olarak kaydeder. Applied, henüz kanıtlandığı anlamına gelmez. ### Verify Kodu okuyup harden fazının kaydettikleriyle karşılaştırarak uygulanan her düzeltmenin işe yaradığını kanıtlayan faz. Üç karardan birini verir: Risk closed, Risk not closed ya da Cannot tell from the code. ### Takipten çıkarma Verify bir riskin kapandığını kanıtladığında, bulgu takipten çıkarılır: sizin onayınızla tüm zincirden kaldırılır, böylece yeniden işlenmez. ### Kapatılabilirlik Güvenlik çalışmasının bir son durumu olması özelliği. Kapandığı kanıtlanan bir bulgu takipten çıkarıldığı için akış durgunlaşabilir ve yalnızca kod değiştiğinde yeniden açılır. SDH kapatılabilirdir, sonsuz bir döngü değildir. ### Motor **npm** üzerindeki `lagune` paketi. Komutlar onu her deterministik adım için `npx` ile çalıştırır: hook'lar, katalog ve kategoriler. ### Uzmanlık Yalnızca talep üzerine yüklenen, asla varsayılan olarak yüklenmeyen, odaklı ve dilden bağımsız bir güvenlik bilgisi modülü. Uzmanlık bir komut değildir. Herhangi bir prompt'a motorun `read catalog ` komutuyla bir uzmanlık yükleyin, örneğin `npx lagune read catalog regex`. ### Kategori `owasp` kategorisinden `javascript`, `python`, `go` ve `rust` gibi dile özgü kategorilere kadar, adı olan bir yerleşik uzmanlık grubu. Projenin kullandığı ve `.lagune/configs.json` dosyasına kaydedilen kategoriler, hangi yerleşik uzmanlıkların kataloğa katılacağını belirler. Hiçbiri kaydedilmemişken proje yalnızca `owasp` kategorisini kullanır. ### Katalog Projenin kullandığı uzmanlıkların kümesi: kategorilerinin yerleşik uzmanlıkları ve `/lagune-specialize` komutuyla yazılmış kendi uzmanlıkları. Motorun `read catalog` komutu kataloğu listeler, fazlar da onu kodla eşleştirir. ### Talep üzerine prompt Her denetimin varsayılan olarak çalışması yerine, ilgili güvenlik bilgisinin projenin gerçekte ne olduğuna göre çağrılması ilkesi. ### Ada göre kimlik Lagune'nin takip modeli: her artefaktta aynı şekilde bölüm başlığı olarak yazılan bulgu adı, zincirin tamamında o bulgunun kimliğidir. Takip haritası (`.lagune/tracking.json`) yalnızca takip bilgisini tutar, asla düz metin tutmaz. ## Sıkça sorulan sorular ### Security-Driven Hardening (SDH) nedir? SDH, bağlama duyarlı bir Blue Team güvenlik metodolojisidir. Bir sistemin bağlamını tespit eder, bu bağlamın taşıdığı riskleri önceliklendirir ve her bulguyu sade bir dille tutarak düzeltmelere yön verir. Lagune onun referans uygulamasıdır. ### Lagune'de charter nedir? Charter, Lagune'nin yönetici katmanıdır: sonraki her fazın uyması gereken, güvenliği öne koyan ilkeler. .lagune/memory/charter.md dosyasında saklanır. ### Bir bulguyu takipten çıkarmak ne demek? Verify bir riskin kapandığını kanıtladığında, bulgu takipten çıkarılır: sizin onayınızla tüm zincirden kaldırılır, böylece yeniden işlenmez. --- # Yapılandırma şeması > Bir Lagune projesinin yapılandırması için JSON Schema: düzenleyicinizde otomatik tamamlama ve doğrulama sağlar, güncel Lagune'yi izler ya da bir sürüme sabitlenir. Kanonik URL: https://lagune.ai/tr-TR/docs/references/configs-schema Dil: tr-TR Orijinal: https://lagune.ai/docs/references/configs-schema Son güncelleme: 2026-11-03 `.lagune/configs.json` dosyası, projenin kullandığı [**kategorileri**](https://lagune.ai/tr-TR/docs/categories) kaydeder ve projenin kendi [**uzmanlıklarını**](https://lagune.ai/tr-TR/docs/catalog) dizinler. JSON Schema'sı sayesinde düzenleyiciniz siz dosyayı düzenlerken her alanı otomatik tamamlar ve bir yazım hatasını ya da bilinmeyen bir kategoriyi işaretler. ## Güncel şema **Lagune** dosyayı her yazdığında, içinde `$schema` bulamazsa dosyayı güncel şemaya yönlendirir: ```json { "$schema": "https://lagune.ai/schemas/configs.json", "categories": ["owasp", "javascript"] } ``` Bu adres her zaman güncel **Lagune**'yi izler. **Lagune** 0.16.0'dan önce yazılmış bir dosya bu adresi bir sonraki değişikliğinde alır ve o zamana kadar her faz bunu hatırlatır. ## Bir sürüme sabitleme **Lagune**'nin 0.16.0 ve sonraki her sürümü, şemayı o sürümdeki hâliyle taşır. Şema **npm** üzerinde yayımlanır ve **jsDelivr** üzerinden sunulur. Bir sürüme sabitlemek için sürümü, `lagune@` ifadesinden sonra gelecek şekilde `$schema` adresine yazın: ```json { "$schema": "https://cdn.jsdelivr.net/npm/lagune@0.16.0/schemas/configs.json" } ``` Sürüm, herhangi bir semver aralığını kabul eder: | Sürüm | Şema | | --------------------- | ---------------------------- | | `0.16.0` | 0.16.0 sürümündeki şema | | `0.16.x` ya da `0.16` | En son 0.16 sürümündeki şema | | `0.x` ya da `0` | En son 0.x sürümündeki şema | | `latest` | En son sürümdeki şema | ## Sıkça sorulan sorular ### Lagune'nin şemaya ihtiyacı var mı? Hayır. Şema yalnızca düzenleyicinize yardımcı olur ve Lagune dosyayı $schema olsa da olmasa da aynı şekilde okur. ### Lagune sabitlenmiş bir şemanın üzerine yazar mı? Hayır. Lagune $schema alanını yalnızca dosyada hiç yoksa yazar ve sizin belirlediğiniz adresi korur. ### Bir sürüme ne zaman sabitlemeliyim? Proje belirli bir Lagune sürümüyle çalışıyorsa sabitleyin. Böylece düzenleyiciniz dosyayı o sürümün kabul ettiklerine göre doğrular. --- # Lagune ve Deepsec: yapay zeka destekli iki güvenlik yaklaşımı yan yana > Lagune'yi ve Vercel'in Deepsec'ini çalışma biçimi, yaşam döngüsü, tespit, maliyet, bulgular ve kapatma açısından karşılaştıran bir başvuru sayfası. Kanonik URL: https://lagune.ai/tr-TR/docs/references/deepsec Dil: tr-TR Orijinal: https://lagune.ai/docs/references/deepsec Son güncelleme: 2026-11-03 [Lagune](https://github.com/wellwelwel/lagune) ve [Deepsec](https://github.com/vercel-labs/deepsec) (`v2.2.1`), aynı soruna verilmiş iki savunma odaklı yanıttır: yapay zeka destekli geliştirme çağında güvenlik. Çıkış noktaları, başları, ortaları ve sonları, ayrıca kullanıcıya kendilerini nasıl sundukları, mekanikleri örtüştüğü yerlerde bile bilinçli olarak ayrışır. **İpucu** Lagune, Deepsec'ten mi esinlendi? Hayır. Lagune sıfırdan yazıldı ve Spec-Driven Development ile Security Hardening'den esinlendi. İki proje birbirinden bağımsız geliştirildi ve buradaki karşılaştırma, kullanıcıların aralarındaki farkları anlamasına yardımcı olmak içindir. ## Bir bakışta | Yön | Lagune | Deepsec | | ------------------- | -------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------- | | Türü | Referans uygulaması olan bir metodoloji (SDH) | Bir ürün: ajan destekli bir güvenlik açığı tarayıcısı | | Ağırlık merkezi | Ajanı bir charter ve talep üzerine yüklenen bilgi yönlendirir, deterministik hook'lar da zemin sağlar | Geniş bir regex ağı, zorunlu bir yapay zeka incelemesini besler | | Ne üretir | Sıkılaştırılmış kod, ispatlar ve takip edilen bir bulgu zinciri | Önem derecesine göre sıralanmış, önceliklendirilmiş bir bulgu raporu | | Kodunuza dokunur mu | Evet: `harden` kodunuzu düzenler | Hayır: yalnızca statik analiz yapar, bulgular ve öneri metni üretir | | Çalışma ortamı | Zaten kullandığınız ajan ve modelle, her seviyede çalışır | Kendi model hattını çalıştırır, varsayılan olarak öncü seviyede bir modelle | | Başlangıç | Tek bir eklenti kurulumu ya da `npx skills add`, ardından sade bir dille yönlendirme, ayağa kaldırılacak yeni bir araç yok | Bir `.deepsec/` çalışma alanı kurulur, bağımlılıklar yüklenir ve bir model anahtarı eklenir | ## Nasıl çalışır Lagune ajan önceliklidir: ajan yönetir, kodun ne olduğuna göre bilgiyi talep üzerine çağırır ve karara bağlanabilen bir dilimi deterministik hook'lara devreder. Deepsec deterministik önceliklidir: geniş bir tarama adayları işaretler ve bu adaylar, zorunlu bir modele neyi inceleyip yargılayacağını gösterir. | Yön | Lagune | Deepsec | | -------------------- | ------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------- | | Sıra | Charter ve eşleşen bilgi ajanı yönlendirir, ajan hook'lara devreder ve gerisini kendisi yargılar | Eşleştiriciler adayları işaretler, model her birini inceleyip yargılar | | Deterministik rol | Bir karar döndüren ya da ajanı hedefe yönelten çok dilli hook'lar, kategori bilgisiyle birlikte | Zorunlu modelin yargılayacağı adayları işaretleyen eşleştiriciler | | Geliştirme akışı | `/lagune` siz kodlarken güvenli kodu yerinde oluşturur | Kodu inceler, yazmaz | | Denetim akışı | `charter` → `detect` → `plan` → `harden` → `verify` | `scan` → `process` → `triage` → `revalidate` → `report` | | Yapay zekanın görevi | Bilgiden yola çıkarak akıl yürütmek, düzeltmeyi uygulamak ve işe yaradığını kanıtlamak | Her adayı incelemek ve bulguları raporlamak | ## Yaşam döngüsü Lagune kod yazılmadan önce, yazılırken ve yazıldıktan sonra çalışır. Deepsec ise kod var olduktan sonra bir depoyu inceler. | An | Lagune | Deepsec | | ---------------- | ------------------------------------------------------------------------------------ | --------------------------------------------------------------- | | Kod yokken | `charter`, belirtilen niyetten bir güvenlik politikası çıkarır | Mevcut koddan başlar: `init` bir dizin ister | | Geliştirirken | `/lagune` varsayılan olarak güvenli kodu yerinde oluşturur, geride artefakt bırakmaz | Geliştirme sırasında değil, sonrasında inceler | | Mevcut kodda | `detect` → `plan` → `harden` → `verify` | `scan` → `process`, temel akış | | Sürekli inceleme | Fazlar kapsama göre yeniden çalıştırılır, paketlenmiş bir CI kapısı yok | Artımlı yeniden tarama, CI çıkış kapısı olarak `process --diff` | ## Tespit katmanı İki deterministik katman doğası gereği zıttır: biri karar verir, diğeri işaretler. | Yön | Lagune | Deepsec | | ----------------- | ---------------------------------------------------------------------------------- | ----------------------------------------------------------------------- | | Gruplama | Kategorilerde gruplanmış hook'lar ve uzmanlıklar | Desen ya da framework başına eşleştiriciler | | Çıktı | Sabit metinli bir karar (finding / review / advisory) ve bir sınıflandırma etiketi | Kararsız bir aday (slug, satırlar, kod parçası, eşleşen desen) | | Ayar | Kesinlik: yorumları dikkate alır, yer tutucu ve pencere korumaları vardır | Duyarlılık: geniş ağlar, yanlış pozitifleri sonradan yapay zeka ayıklar | | Derinlik | Ortak sınıflarda daha derin | Daha geniş, ortak sınıflarda daha az derin | | Yanlış pozitifler | Kaynakta düşük tutulur, ardından bağlam içinde yargılanır | Bilerek fazla üretilir, bir `revalidate` geçişiyle azaltılır | ## Bilgi ve yargı İkisi de regex'in taşıyamadığı güvenlik bilgisini taşır. Farkları, bu bilginin nerede durduğunda ve onu kimin şekillendirebildiğindedir. | Yön | Lagune | Deepsec | | ---------------- | ---------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- | | Biçim | Düzenlenebilir markdown modülleri, birkaçının arkasında deterministik bir hook var | Kısa bir prompt ve teknolojiye özel vurgular, modelin kendi bilgisine dayanır | | Seçim | Kodla eşleştirilir, yalnızca bağlamı mevcut olduğunda yüklenir | Her yapay zeka grubuna eklenir, tespit edilen teknoloji için vurgular da eklenir | | Kim yazar | Kullanıcı modülleri düzenler ve `specialize` ile yenilerini ekler | Prompt'un sahibi bakımcıdır, kullanıcı bir `INFO.md` doldurur | | Yargı nerede | Hook'lar kendi tabanlarına karar verir, ajan gerisini bilgiye dayanarak yargılar | Merkezi: tek bir yapay zeka işlemcisi her adayı yargılar | | Yeniden kullanım | Tek bir modül hem `detect` hem `verify` fazına yön verir | Tek bir prompt, tek `process` aşamasını yönetir | ## Bulgular ve kapatma En çok, bir bulgunun çözüldükten sonra neye dönüştüğünde ayrışırlar. | Yön | Lagune | Deepsec | | ---------------- | --------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------- | | Önem derecesi | Maruziyete ve risk altındaki değerlere göre ayarlanmış bir CVSS v4.0 puanı | Yapay zekanın verdiği bir önem derecesi ve istismar edilebilirlik ile etkiye göre P0 / P1 / P2 önceliklendirmesi | | Kararlar | Risk closed, not closed ya da cannot tell from the code | true-positive, false-positive, fixed, uncertain, accepted-risk, duplicate | | Kalıcılık | Çalışan zincir uzlaştırılır, kapanan bulguların özü bir geçmişe çıkarılır | Dosya başına yalnızca eklenen kayıtlar, hiçbir şey silinmez | | Son durum | Kapatılabilir: kanıtlanmış bir bulgu takipten çıkar, zincir durgunlaşabilir | Her bulgu kalıcı olarak saklanır, çözüldüğünde görünümlerden gizlenir | | Geçmiş ayrıntısı | Riskin ne olduğuna dair kısa bir özet | Nasıl düzeltildiği dahil tüm karar geçmişi | ## Maliyet | Yön | Lagune | Deepsec | | ------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Deterministik taban | Ücretsiz: hook'lar yapay zeka ve anahtar olmadan çalışır, kararları zaten üretir | Ücretsiz: `scan` yapay zeka olmadan çalışır, ama tek başına karar üretmez | | Tipik fatura | Zaten kullandığınız ajanın içinde kalır: yerel bir modelle $0'a kadar iner, zaten kullandığınız planın fiyatıdır ya da API tabanlı kullanımda yineleme başınadır | [100 ile 2.000 dosya için çalıştırma başına kabaca $25 ile $1.200 arası, ölçek büyüdükçe daha fazla](https://github.com/vercel-labs/deepsec/blob/f75a16803ec5250938bacfe41571d929e8564f45/docs/getting-started.md#run-the-ai-investigation) | | En ucuz yol | Ücretsiz yerel bir model dahil herhangi bir model döngüyü kapatır | Daha ucuz ücretli seviyeler var, ama bulgular ücretli yapay zeka aşamasını gerektirir | ## Genişletilebilirlik ve yönetişim Her biri, diğerinin kapalı tuttuğu katmanı açar. | Yön | Lagune | Deepsec | | -------------------- | --------------------------------------------------------------- | -------------------------------------------------------------- | | Neyi genişletirsiniz | Modülleri düzenler ya da `specialize` ile yenilerini eklersiniz | Eşleştiriciler, ajanlar, bildirimciler ve sahiplik eklersiniz | | Politika katmanı | Charter her fazı yönetir ve sürümlenir | Yapılandırma operasyoneldir (eşleştiriciler, modeller, yollar) | | Adla geçersiz kılma | İyileştirilmiş bir modül yerleşik olanı gölgeler | Bir eşleştirici slug çakışmasında sizin eşleştiriciniz kazanır | ## Arayüzler Deepsec bir güvenlik ekibi için teslim edilecek çıktılar üretir. Lagune ise onu çalıştıran kişi için canlı bir görünüm sunar. | Yön | Lagune | Deepsec | | ----------------------- | ---------------------------------------------------------------------- | ----------------------------------------------------------------------------------- | | İnsana dönük yüzey | Tüm zincirin sade bir dille sunulduğu canlı, yerel bir gösterge paneli | Rapor, dışa aktarma, metrik ve PR yorumu dosyaları, ayrıca bir dokümantasyon sitesi | | Sorumluluk | Dosyaları ve uygulanan uzmanlıkları gösterir | Önerilen bir sorumluya yönlendirir: nöbetçi, yönetici ya da commit'i yapan kişi | | Tekrarlanabilir ispat | `prove` çalıştırılabilir testler ve bir ifşa bülteni yazar | Tasarımı gereği statik kalır, hedefi asla çalıştırmaz | | Aracın kendini koruması | Gösterge panelindeki yerel bir yazma API'sini sıkılaştırır | Kendi yapay zeka yürütmesini güvenilmeyen hedef koda karşı sıkılaştırır | ## Ölçek ve dağıtım | Yön | Lagune | Deepsec | | ---------- | ------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------- | | Kurulum | Ajanınızın eklentisinden ya da **skills** CLI aracından dokuz komut, hiçbir iskelet oluşturulmaz | Kendi paketi ve bağımlılıkları olan bir `.deepsec/` çalışma alanı | | Ölçek yönü | Herhangi bir dilime, bir bağlama, tek bir dosyadan tüm projeye kadar kapsam daraltır | Büyük monorepo'lara kadar tüm depoları tarar | | Dağıtım | Yalnızca yerel, tek sunucu loopback'e bağlanır | Vercel Sandbox çalışan VM'lerine isteğe bağlı dağıtım | ## Kullanıcı deneyimi Her birinin, onu çalıştıran kişiyle nasıl buluştuğu: ilk çalıştırmanın ne gerektirdiği ve kullanıcının onu nasıl hedeflediği. ### İlk kurulum Lagune zaten açık olan ajan üzerinden çalışır. Deepsec ise önce kendi çalışma alanını ve model erişimini hazırlar. | Yön | Lagune | Deepsec | | ------------------------------- | -------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------- | | İlk komut | Eklenti kurulumu ya da `npx skills add wellwelwel/lagune`, ardından ajanda `/lagune-*` | `npx deepsec init`, ardından `cd .deepsec`, `pnpm install`, `scan`, `process` | | Çalıştırmak için kimlik bilgisi | Ayrı bir anahtar yok, mevcut ajanınızı kullanır | Bir model anahtarı (örneğin AI Gateway, 12 saatlik bir Vercel OIDC token'ı ya da bir Anthropic token'ı) | ### Yönlendirme İkisi de yön alır. Lagune girdinin biçimini her fazda okur. Deepsec ise aynı incelemenin üzerinde çalıştığı dosya kümesini daraltır. | Yön | Lagune | Deepsec | | ----------------- | ------------------------------------------------------------------------------------------- | -------------------------------------------------------------- | | Tüm proje | Girdisi olmayan bir faz tüm kapsamı tarar | `scan` ve `process` depoyu tarar | | Bir dilim | Her faz verilen dosyalara ya da dizinlere göre kapsam daraltır | `--files`, `--files-from` ya da `--diff` çalıştırmayı daraltır | | Bir endişe | Bir faz, tarif edilen bir endişeye göre kapsam daraltır | İnceleme prompt'u sabittir | | Bir öncelik bandı | `harden` ve `verify`, Critical, High, Medium ya da Low düzeyine göre kapsam daraltır | Bulgular çalıştırmadan sonra etiketlenir | | Tek bir değer | Bir hook tek bir kod parçasını, deseni ya da URL'yi doğrudan puanlar (`--pattern`, `--url`) | İş birimi bir dosyadır | ## Sıkça sorulan sorular ### Lagune'nin Deepsec'ten farkı nedir? Lagune ajan önceliklidir ve kod yazılmadan önce, yazılırken ve yazıldıktan sonra çalışır: koddan önce politikayı belirler, geliştirirken kodu yerinde sıkılaştırır, zaten yazılmış kodu da denetler, sıkılaştırır ve doğrular. Deepsec deterministik önceliklidir: geniş bir regex taraması, mevcut kodu inceleyip değiştirmeden bulguları raporlayan zorunlu bir öncü model incelemesini besler. ### İkisinden birini ücretsiz çalıştırabilir miyim? Lagune'nin tüm akışı ücretsiz yerel bir modelle $0'a çalışabilir ve deterministik hook'ları hiç yapay zeka kullanmadan karar üretir. Deepsec'in taraması ücretsizdir ama karar üretmez, bu yüzden her bulgu ücretli yapay zeka aşamasını gerektirir. ### İkisinden biri kodumu değiştirir mi? Lagune değiştirir: harden düzeltmeleri kodunuza uygular. Deepsec değiştirmez: yalnızca statik analiz yapar ve bir kişinin ya da ajanın ayrıca uygulayacağı bulgular ve öneri metni üretir. --- # OWASP kaynakları > Yerleşik OWASP uzmanlıklarının bilgisinin nereden geldiği, OWASP'ın resmi saldırı ve Cheat Sheet sayfalarıyla eşleştirilmiş hâlde. Kanonik URL: https://lagune.ai/tr-TR/docs/references/owasp-sources Dil: tr-TR Orijinal: https://lagune.ai/docs/references/owasp-sources Son güncelleme: 2026-11-03 Bu belge, OWASP'ın her **saldırı** (`www-community`) ve **Cheat Sheet** (`CheatSheetSeries`) sayfasını bir güvenlik kategorisiyle eşleştirir ve her birini resmi, herkese açık sayfasına bağlar. Bir kategori içinde eşdeğer öğeler tek bir liste satırını paylaşır: aynı riski ele alan saldırılar ve cheat sheet'ler virgülle ayrılarak birlikte listelenir. Doğrudan bir karşılığı olmayan öğeler kendi satırında durur. - Emek OWASP'a aittir. Saldırılar `https://owasp.org/www-community/attacks/` adresinde, cheat sheet'ler ise `https://cheatsheetseries.owasp.org/cheatsheets/.html` adresinde bulunur. --- ## 1. Enjeksiyon (genel) - [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. SQL ve veritabanı enjeksiyonu - [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. İşletim sistemi ve komut enjeksiyonu - [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. LDAP, XPath ve XML enjeksiyonu - [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) ve 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. Yönlendirmeler ve iletmeler - [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. Erişim kontrolü ve yetkilendirme - [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. Kimlik doğrulama ve kimlik bilgileri - [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. Oturum yönetimi - [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. Kimlik federasyonu (OAuth, SAML, 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 ve aktarım güvenliği - [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 ve dosya işleme - [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. HTTP protokolünün kötüye kullanımı (başlıklar, önbellekleme, 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) (browser, transport, http-request ve access-control arasında bölündü) - [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. Kodlama ve 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. CSV ve elektronik tablo enjeksiyonu - [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. Hizmet reddi - [x] [Regular expression Denial of Service (ReDoS)](https://owasp.org/www-community/attacks/Regular_expression_Denial_of_Service_-_ReDoS) (regex) --- ## 20. Bellek güvenliği ve yerel kod - [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. Mobil kod ve güvenilmeyen kod yürütme - [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. Deserialization - [x] [Deserialization](https://cheatsheetseries.owasp.org/cheatsheets/Deserialization_Cheat_Sheet.html) (python, ruby, php, java ve dotnet arasında bölündü) --- ## 23. Kötü amaçlı yazılımlar ve istemci tarafı tehditler - [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. Günlük kaydı, inkâr ve hata işleme - [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. İş mantığı ve işlevselliğin kötüye kullanımı İş mantığının ve işlevselliğin kötüye kullanımının, yüzey başına bir uzmanlığın savunabileceği tek bir kod yüzeyi yoktur: savunma, uygulamaya özgü tasarımdır ve projenin tehdit modellemesinin yönlendirdiği akıl yürütmenin aynısıdır. "Kapsam dışında" bölümüne taşındı. --- ## 26. Yapay zeka, LLM ve ajan güvenliği - [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 ve cross-site leak'ler - [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'ler ve dil platformları - [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. Web ön yüzü ve tarayıcı - [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) (access-control ve browser arasında bölündü) --- ## 30. API'ler ve servisler - [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. Bulut, container'lar ve altyapı Container ve iş yükü yapılandırması, geliştiricinin uygulamayla birlikte yayınladığı kod olarak yapılandırmadır (`Dockerfile`, Compose, Pod `securityContext` ayarı). `harden` fazının düzelttiği ve `verify` fazının kanıtladığı gerçek bir yüzeydir, bu yüzden kapsam içindedir. Küme yönetimi (RBAC, etcd, API sunucusu, admission, ağ segmentasyonu) operatörün alanıdır ve kapsam dışında kalır. - [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: iş yükü ve Pod kısmı. Küme yönetimi kapsam dışında kalır) - [x] [Serverless / FaaS Security](https://cheatsheetseries.owasp.org/cheatsheets/Serverless_FaaS_Security_Cheat_Sheet.html) (serverless) --- ## 32. Tedarik zinciri ve 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. Gizli bilgiler ve yapılandırma Gizli bilgi yönetimi operasyonel bir konudur: kasalar (vault), CI/CD, bulut yapılandırması, rotasyon. Kod düzeyindeki tek yönü (kaynak koda gömülü bir gizli bilgi) bir risk uzmanlığı değil, deterministik bir taramadır. "Kapsam dışında" bölümüne taşındı. --- ## 34. Süreç, tasarım ve yönetişim Kullanıcı gizliliğinin korunması bir uzmanlığın savunduğu bir kod yüzeyi değil, politika ve tasarım konusudur (veri minimizasyonu, şeffaflık, saklama). "Kapsam dışında" bölümüne taşındı. --- ## 35. Ödemeler ve uyumluluk - [x] [Secure Integration of Third-Party Payment Gateways](https://cheatsheetseries.owasp.org/cheatsheets/Third_Party_Payment_Gateway_Integration_Cheat_Sheet.html) (payment) --- ## 36. Gömülü sistemler, IoT ve özel alanlar Otomotiv ve drone güvenliği gömülü sistem alanlarıdır (CAN bus, OTA firmware, sensör ve radyo bütünlüğü, fiziksel erişim), **Lagune**'nin denetlediği web ve API uygulama kaynak kodu değildir. "Kapsam dışında" bölümüne taşındı. --- ## Kapsam dışında (kod yüzeyi yok) Bunlar uzmanlık alanları değildir ve onay kutusu taşımaz: yüzey başına bir uzmanlığın savunabileceği tek bir kod yüzeyi olmayan yönetişim, süreç, operasyonel sıkılaştırma ya da framework kullanımıdır. Güvenlik değerleri gerçektir, ama bu katalogla gelen bir savunmada değil, süreçte ve mimaride (ya da bir framework için o dilin kendi becerisinde) bulunur. İş olarak değil, başvuru için listelenmiştir. - [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) (SOAP ve WS-Addressing üzerinden amplifikasyon, kod yüzeyi olmayan operasyonel bir DoS türü) - [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) (son kullanıcıyı hedefleyen kötü amaçlı yazılım, denetlenen projede bir kod yüzeyi değil. Tarayıcı içinden iletim yönü `browser` uzmanlığında yer alır) - [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) (tasarım ve ödünleşimler: IAM ile imzalı URL'ler, herkese açık ve özel VPC'ler, güven sınırları, paylaşılan sorumluluk. `container` uzmanlığından farklı olarak bir uzmanlığın kontrol edeceği somut bir yapılandırması yoktur) - [Infrastructure as Code Security](https://cheatsheetseries.owasp.org/cheatsheets/Infrastructure_as_Code_Security_Cheat_Sheet.html) (adına rağmen IaC'yi _yönetmek_ için SDLC süreci ve araçlarıdır: IDE eklentileri, statik analiz, imaj tarama, CI/CD, imzalama. Bir Terraform ya da CloudFormation dosyasında güvensiz kalıptan güvenli biçime bir geçiş sunmaz) - [Kubernetes Security](https://cheatsheetseries.owasp.org/cheatsheets/Kubernetes_Security_Cheat_Sheet.html) (_yalnızca küme yönetimi kısmı_: RBAC, etcd, API sunucusu, admission. İş yükü ve Pod kısmı `container` altında kapsam içindedir) - [Network Segmentation](https://cheatsheetseries.owasp.org/cheatsheets/Network_Segmentation_Cheat_Sheet.html) (ağ mimarisi ve güvenlik duvarı politikası) - [Subdomain Takeover Prevention](https://cheatsheetseries.owasp.org/cheatsheets/Subdomain_Takeover_Prevention_Cheat_Sheet.html) (DNS yaşam döngüsü ve izleme, kod değil) - [Secrets Management](https://cheatsheetseries.owasp.org/cheatsheets/Secrets_Management_Cheat_Sheet.html) (kasalar, CI/CD, rotasyon. Koda gömülü gizli bilgi yönü bir risk uzmanlığı değil, deterministik bir taramadır) - [C-Based Toolchain Hardening](https://cheatsheetseries.owasp.org/cheatsheets/C-Based_Toolchain_Hardening_Cheat_Sheet.html) (derleyici, bağlayıcı ve derleme bayrakları, kaynak kodda sink yok) - [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) (her teknoloji yığını için genel hata işleyici yapılandırması. Sızıntı, hata işlemenin zaten yönettiği ifşanın aynısıdır) - [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) (uygulamaya özgü tasarım, tek bir kod sink'i yok) - [User Privacy Protection](https://cheatsheetseries.owasp.org/cheatsheets/User_Privacy_Protection_Cheat_Sheet.html) (veri minimizasyonu, şeffaflık, saklama politikası) - [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) (gömülü sistem alanları: CAN bus, OTA firmware, sensör ve radyo bütünlüğü, web ya da API kaynak kodu değil) - [Mobile Application Security](https://cheatsheetseries.owasp.org/cheatsheets/Mobile_Application_Security_Cheat_Sheet.html) (Android ve iOS platform sıkılaştırması: depolama, biyometri, pinning, kişisel veriler. Tek bir kod yüzeyi yoktur ve güvenilmeyen kod yükleme yönü `interpreter` uzmanlığına taşındı) - [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: bozulan bulgu takibini onarın > Bir yeniden adlandırma ya da taşınan bir dosya Lagune'nin takibini karıştırdığında zinciri onarın. Kanonik URL: https://lagune.ai/tr-TR/docs/commands/repair Dil: tr-TR Orijinal: https://lagune.ai/docs/commands/repair Son güncelleme: 2026-11-03 🧰 Bir yeniden adlandırma ya da taşınan bir dosya zinciri karıştırdığında onu onarın. **Dahili bakım, bir güvenlik fazı değil** Repair, doğrusal akıştaki altıncı bir faz değildir. Görevi takibi tutarlı tutmaktır. ```prompt # Girdi almaz: her zaman tüm zinciri onarır /lagune-repair ``` ## Nasıl çalışır Her detect bulgusu, plan, harden ve verify fazlarının ileri taşıdığı, her birinin üzerinde işlem yapıp adıyla yeniden raporladığı tek bir takip edilen öğedir. Her artefaktta bölüm başlığı olarak birebir aynı yazılan bu ad, baştan sona onun kimliğidir. Takibin sakladığı tek değişken şey, öğenin işaret ettiği dosya yollarıdır. Bu yollar başka hiçbir yerde bulunmaz, bu yüzden bir yeniden adlandırma ya da taşınan bir dosya bağlantıyı yalnızca orada bozabilir, asla birbirinden ayrışan iki kopyada bozmaz. Bu olduğunda repair, kimlik yeniden adlandırmadan sağ çıksın diye haritayı (`.lagune/tracking.json`) düzeltir. Artefaktları ve takip haritasını okur, kaynak kodunuzu yalnızca yeniden adlandırılan bir dosyanın yeni yolunu öğrenmek için okur ve asla güvenlik içeriği yazmaz. Aynı geçişte her bellek artefaktını kendi şablonuyla karşılaştırır ve sapmaları raporlayarak her birini onu düzeltecek faza yönlendirir. **İpucu** - Ne kodunuza ne de metin artefaktlarına dokunur, yalnızca takibe dokunur. - Onu nadiren elle çalıştırırsınız. Bir faz zincirin tutarsız olduğunu fark ettiğinde repair'i sizin için çalıştırır ve devam eder. - Sürdürdüğü takip, asla elle düzenlemediğiniz dahili bir durum olan `.lagune/tracking.json` dosyasında tutulur. --- # Migrate: manifest tabanlı bir Lagune projesini becerilere ve eklentilere taşıyın > Manifest tabanlı bir Lagune projesini güvenlik ilkelerinizi, artefaktlarınızı, takibinizi ve kendi uzmanlıklarınızı koruyarak beceri tabanlı Lagune'ye taşıyın. Kanonik URL: https://lagune.ai/tr-TR/docs/commands/migrate Dil: tr-TR Orijinal: https://lagune.ai/docs/commands/migrate Son güncelleme: 2026-11-03 🔀 Manifest tabanlı bir **Lagune** projesini, yazdığınız her şeyi koruyarak beceri tabanlı **Lagune**'ye taşıyın. **Kullanımdan kaldırma bildirimi** Manifest içeren bir proje `v1.x` sürümüne kadar olduğu gibi çalışmaya devam eder: `npx lagune`, `init`, `pull`, `update`, `add`, `remove`, `list` komutlarını ve gösterge panelini manifest tabanlı son sürüm olan `lagune@0.15.0` sürümüne devreder. ## Taşıma 1. Mevcut çalışmanızın commit edildiğinden emin olun, ardından proje kök dizininden migrate komutunu çalıştırın: ```bash npx lagune migrate ``` 2. Taşıma incelenebilir tek bir değişiklik olarak kalsın diye yalnızca onun değiştirdiklerini commit edin. 3. [Kurulum sayfasında](https://lagune.ai/tr-TR/docs) gösterildiği gibi komutları ajanınız için kurun. 4. Projede zaten bir detect, plan ya da harden artefaktı varsa, bunlardaki ve kendi uzmanlıklarınızdaki eski referansları uzlaştırması için [`/lagune-repair`](https://lagune.ai/tr-TR/docs/commands/repair) komutundan yardım isteyin: ```prompt /lagune-repair `.lagune/memory/` altındaki artefaktlarda (`detect.md`, `plan.md` ve `harden.md`) uygulanan uzmanlıkları (eski adıyla sub-skills) yeni kataloğun listelediği adlarla uzlaştır ve `.lagune/catalog/` içindeki kendi uzmanlıklarımın `.lagune/hooks/` içindeki eski hook'lara yaptığı her çağrıyı `lagune_read` ya da `lagune_write` aracına yapılan bir çağrı olarak yeniden yaz. ``` ## Neler değişir | Önce | Sonra | | ---------------------------------------------------------------------- | ---------------------------------------------------------------------------------- | | `.lagune/templates/`, `.lagune/hooks/` ve `.lagune/specializations.md` | Kaldırıldı: her beceri kendi şablonunu taşır, hook'ları ise motor çalıştırır | | `.lagune/skills/` içindeki yerleşik uzmanlık kopyaları | Kaldırıldı: yerleşik uzmanlıkları motor sunar | | `.lagune/skills/` içindeki kendi uzmanlıklarınız | `.lagune/catalog/` klasörüne taşındı | | Kendi uzmanlıklarınızın dizini olan `.lagune/skills.json` | `.lagune/configs.json` ile birleştirildi | | Manifestteki kategoriler | `.lagune/configs.json` dosyasına kaydedildi | | `/lagune.detect` gibi eski ajan komutları | Kaldırıldı: [**Lagune**'yi kurmak](https://lagune.ai/tr-TR/docs) `/lagune-detect` gibi yenilerini getirir | | `.gitignore` içindeki **Lagune** bloğu | Kaldırıldı, başka bir şey içermiyorsa dosyayla birlikte | | O bloğun yok saydığı `.lagune/proofs/` | Kendi `.gitignore` dosyasıyla commit'lerin dışında tutulur | | `.lagune/manifest.json` | En son silindi | Güvenlik çalışmanız olduğu gibi kalır: güvenlik ilkeleri, her fazın ürettiği artefakt ve her bulgunun işaret ettiği yollarla birlikte takip haritası. ## Sıkça sorulan sorular ### Taşıma yapmak zorunda mıyım? Evet. Manifest tabanlı projeler kullanımdan kaldırılmıştır ve yalnızca v1.x sürümüne kadar çalışmaya devam eder, bu yüzden projenizi taşımak için npx lagune migrate komutunu çalıştırın. ### Migrate neleri korur? Güvenlik ilkelerinizi, her faz artefaktını, takip haritasını, kategorilerinizi ve kendi uzmanlıklarınızı. Uzmanlıklar .lagune/catalog/ klasörüne taşınır, dizinleri ise kategorilerinizle birlikte .lagune/configs.json dosyasına eklenir. ### Yeni komutları ne zaman kurarım? Migrate komutundan sonra, kurulum sayfasında ajanınız için gösterildiği gibi. Migrate yeni /lagune komutunu koruduğu için önce kurmak da işe yarar. ### Bir ekip arkadaşım taşımayı zaten yaptı. Ne çalıştırmalıyım? Taşıma değişikliğini çekin, ardından npx lagune migrate komutunu bir kez çalıştırın. Komut, manifest tabanlı Lagune'nin kendi kopyanızda bıraktığı ve sürüm kontrolünün hiç taşımadığı dosyaları kaldırır ve ispatlarınızı commit'lerin dışında tutar.