Modern AppSec süreçleri için DAST, IAST ve SAST Mimarileri

"Bu teknik dökümantasyonu paylaşmaktaki temel motivasyonum; uygulama güvenliği (AppSec) ekosistemine ilgi duyan yetkin profesyonellerin, kendi bilgi birikimlerini sofistike çözüm mimarilerine dönüştürmeleri yolunda bir teşvik görevi görmektir. Amacım, bu tarz kompleks sistemlerin geliştirilme süreçlerini teşvik etmek ve bu alana topluluk katkılarının artmasını sağlamak. Çünkü kendim de hem kendi yazdığım native kodlarımı hem de açık kaynaklı projelerden beslenerek kendi DAST aracımı geliştirmeye çalışarak ilerletiyorum ve topluluğun büyümesi hepimiz için iyi olabilir."


# Genel DAST Workflow Dokümantasyonu

## İçindekiler

1. [Genel Bakış](#1-genel-bakış)
2. [Sistem Mimarisi](#2-sistem-mimarisi)
3. [Tarama Başlatma Akışı](#3-tarama-başlatma-akışı)
4. [Session Yönetimi](#4-session-yönetimi)
5. [Crawling ve DOM Exploration](#5-crawling-ve-dom-exploration)
6. [Platform Fingerprinting](#6-platform-fingerprinting)
7. [IAST Entegrasyonu](#7-IAST-entegrasyonu)
8. [Audit Süreci](#8-audit-süreci)
9. [Dağıtık Mimari](#9-dağıtık-mimari)
10. [Raporlama](#10-raporlama)

---

## 1. Genel Bakış

Modern yazılım geliştirme dünyasında, uygulamaların hızı ve karmaşıklığı arttıkça, güvenlik testleri de bu hıza ayak uydurmak zorunda kalmıştır.
Uygulama güvenliği (AppSec) ekosisteminin iki temel taşı olan DAST ve IAST, yazılımları farklı perspektiflerden korumak için tasarlanmıştır.


**DAST** (Dynamic Application Security Testing) web uygulama güvenlik tarayıcısı framework'üdür.
DAST, bir uygulamayı çalışır durumdayken (runtime) dışarıdan test eden "kara kutu" (black-box) güvenlik testi yöntemidir.
Test aracı, uygulamanın iç yapısını veya kaynak kodunu bilmez; bunun yerine bir saldırgan gibi davranarak HTTP istekleri gönderir ve gelen yanıtları analiz eder.


Nasıl Çalışır?
Tarama (Crawling): Uygulamanın tüm sayfalarını, formlarını ve giriş noktalarını (endpoint) haritalandırır.

Saldırı Simülasyonu: SQL Injection, XSS ve CSRF gibi yaygın saldırı paternlerini kullanarak uygulamaya test verileri gönderir.

Analiz: Uygulamanın bu saldırılara verdiği tepkileri (hata mesajları, gecikmeler, içerik değişiklikleri) inceleyerek zafiyetleri tespit eder.



Avantajları

1- Çoklu dil kullanılabilir. DAST mimarisinde kullanılacak diller için çok dikkatli olmak gerekir.
Tüm araç tek bir dil örneğin python tabanlı olursa DAST çok verimsiz olacaktır. Bu yüzden farklı dil modelleri gerekir.

2- Kimlik doğrulama ve sunucu yapılandırma hatalarını bulur.

3- Yanlış pozitif (false positive) oranı nispeten düşüktür.


Dezavantajları

1- Kaynak kodun hangi satırında hata olduğunu söyleyemez.

2- Tarama süresi uzun olabilir. Örneğin benim DAST aracım 50 alive subdomainlik bir hedef için ortalama 30-40 saat arasında tamamlayabiliyor

3- Geliştirme sürecinin son aşamalarında (staging/prod) uygulanabilir.

4- Mimari büyük ve karmaşık olursa çok fazla çakışma ve çökme ile karşılaşılabilir Ortalama bir tarama 1-2 milyon arası request gönderebilir.
Proxyler round robin kullanılıp verimli şekilde kullanılsalar bile çok fazla proxy banlanabilir, bu yüzden çok fazla Residental, Mobil, ISP
proxy ihtiyacı doğurur ve Datacenter ve CDN proxyleri kullanılamaz. Proxyler çok maaliyet oluşturur.



**IAST** (Interactive Application Security Testing)

IAST, DAST ve SAST (Statik Analiz) yöntemlerinin güçlü yanlarını birleştiren "hibrit" bir yaklaşımdır.
Uygulamanın içine yerleştirilen bir ajan (agent) veya sensör aracılığıyla çalışır.
Yazılım çalışırken hem dış trafiği hem de içerideki kod akışını eş zamanlı olarak izler.


Nasıl Çalışır?
Gözlem: Ajan, uygulama içindeki veri akışını, kütüphane çağrılarını ve veritabanı sorgularını gerçek zamanlı izler.

Etkileşim: Bir kullanıcı veya otomatize bir test aracı uygulamayı kullandığında, IAST zafiyetin kod seviyesindeki kaynağını anında tespit eder.



Avantajları

1- Zafiyetin tam olarak kodun hangi satırında olduğunu gösterir.

2- CI/CD süreçlerine entegrasyonu çok hızlıdır.

3- Yanlış pozitif oranı en düşük yöntemdir.


Dezavantajları

1- Uygulama performansını az da olsa etkileyebilir.

2- Her programlama dili için özel ajan gerektirir.

3- Uygulama mimarisine bağımlıdır.

4- Geliştirmekte beni en çok yoran aşamaydı, İnternette yeterince detaylı kaynak yok ve aracımın bu modülleri hala istediğim maksimum verimle çalışmıyor.



Özetle; DAST kapıyı dışarıdan zorlayarak kilidin sağlamlığını kontrol eder, IAST ise evin içinde dolaşarak tesisatın ve yapının durumunu içeriden raporlar.
Tam kapsamlı bir güvenlik için her iki bakış açısı da kritiktir.



**SAST** (Static Application Security Testing)

SAST (Static Application Security Testing), bir uygulamanın kaynak kodunu, bytecode'unu veya derlenmiş binary dosyalarını, uygulama çalıştırılmadan analiz eden bir "Beyaz Kutu" (White-box) güvenlik testi metodolojisidir.

Yazılım geliştirme dünyasında "Shift Left" (Güvenliği sola, yani geliştirme aşamasına kaydırma) yaklaşımının en güçlü temsilcisidir. Geliştirici kodu yazdığı anda veya kod deposuna (repository) gönderdiği anda devreye girer.



SAST Nasıl Çalışır? (Teknik Süreç)

SAST araçları, kodu sadece bir metin belgesi gibi okumaz; uygulamanın mantıksal yapısını anlamak için şu adımları izler:

1- Model Oluşturma: Kodun bir Soyut Sözdizimi Ağacı (AST - Abstract Syntax Tree) oluşturulur.

2- Veri Akışı Analizi (Data Flow Analysis): Kullanıcıdan gelen "kirli" verinin (tainted data) uygulama içinde hangi değişkenlere ve fonksiyonlara gittiği izlenir (Taint Analysis).

3- Kontrol Akışı Analizi (Control Flow Analysis): Kodun hangi koşullarda hangi yolları izlediği analiz edilir.

4- Kural Eşleştirme: Hazırlanan bu modeller; SQL Injection, Buffer Overflow veya güvensiz şifreleme kullanımı gibi bilinen zafiyet paternlerine sahip devasa bir veritabanı ile karşılaştırılır.


Avantajları

1- Erken Teşhis (Shift-Left): Zafiyetleri daha kod yazım aşamasında bulur. Bir açığı geliştiricinin bilgisayarında bulup düzeltmek, canlı ortamda (production) bulup düzeltmekten kat kat daha ucuz
ve zahmetsizdir.

2- Kod Satırı Hassasiyeti: Zafiyetin tam olarak hangi dosyada ve hangi satırda olduğunu gösterir. Bu, geliştiriciler için "aksiyon alınabilir" (actionable) veri demektir.

3- Yüksek Kapsam: Çalışan bir uygulamada tüm sayfaları veya fonksiyonları tetiklemek zordur (örneğin nadiren girilen hata blokları). SAST ise kodun her satırına baktığı için mantıksal olarak ulaşılamaz
görünen "köşe vakaları" (edge cases) bile görebilir.

4- Çalıştırma Gerektirmez: Uygulamanın çalışır bir ortamına (veritabanı, sunucu, API bağlantıları vb.) ihtiyaç duymaz. Sadece kaynak kodun olması yeterlidir.

5- Geliştirici Eğitimi: Modern SAST araçları, IDE (VS Code, IntelliJ vb.) entegrasyonu sayesinde geliştiriciye anlık uyarı vererek, güvenli kod yazma alışkanlığı kazandırır.


Dezavantajları

1- Yüksek Yanlış Pozitif (False Positive) Oranı: SAST araçları genellikle "şüpheli" gördüğü her şeyi raporlar. Kodun bağlamını (context) tam anlayamadığı için, aslında güvenli olan bir kod parçasını
zafiyetli olarak işaretleyebilir. Bu da güvenlik ekipleri için ciddi bir ayıklama yükü oluşturur.

2- Çalışma Zamanı (Runtime) Körlüğü: Uygulama çalışmadığı için; kimlik doğrulama (auth) mekanizmalarındaki hataları, hatalı sunucu yapılandırmalarını, yetki yükseltme (privilege escalation) açıklarını veya
zayıf TLS sertifikalarını tespit edemez.

3- Dil ve Framework Bağımlılığı: Her dilin (Java, Ruby, Rust, C# vb.) sözdizimi farklıdır. Bir SAST aracının etkili olması için o dili ve kullanılan kütüphaneleri (framework) derinlemesine desteklemesi
gerekir.

4- Mantıksal Hatalarda Zayıflık: İş mantığına dayalı (Business Logic) hataları (örneğin; bir kullanıcının başkasının sepetini görebilmesi) anlamakta zorlanır; çünkü bu durum kodun sözdizimi açısından doğru,
ancak kurgu açısından yanlıştır.

5- Tarama Süresi: Kod tabanı (codebase) milyonlarca satıra ulaştığında, tam bir SAST taraması saatler hatta günler sürebilir. Bu da hızlı CI/CD süreçlerini yavaşlatabilir.




### 1.1 Temel Özellikler

| Özellik | Açıklama |
|---------|----------|
| **Modüler Mimari** | Checks, Plugins, Fingerprinters, Reporters ayrı bileşenler |
| **Dağıtık Çalışma** | Agent, Scheduler, Grid ile yatay/dikey ölçekleme |
| **Browser Tabanlı** | Chromium ile gerçek DOM analizi |
| **IAST** | Kaynak kod izleme (Java, Ruby, .NET) |
| **Incremental Scan** | Sadece yeni input vectorlerini tara |
| **Script API** | Özelleştirilebilir tarama scriptleri |

### 1.2 Desteklenen Platformlar

**İşletim Sistemleri:** Linux, Windows, BSD, Solaris, AIX

**Veritabanları:** MySQL, PostgreSQL, MSSQL, Oracle, SQLite, MongoDB, DB2, Firebird, HSQLDB...

**Web Sunucuları:** Apache, Nginx, IIS, Tomcat, Jetty, Gunicorn

**Programlama Dilleri:** PHP, ASP, ASPX, Java, Python, Ruby, JavaScript

**Framework'ler:** Rails, Django, ASP.NET MVC, Spring, Express, CakePHP, Symfony...

---


## 2. Sistem Mimarisi






### 2.1 Bileşen Detayları

#### Checks (Güvenlik Kontrolleri)

```ruby
# Active Check Yapısı
module DAST::Engine::Checks
class XSS < Base
def run
each_element do |element|
element.taint_analysis(
payloads: payloads,
callback: methodcheck_and_log)
)
end
end
end
end
```

| Tip | Açıklama | Örnekler |
|-----|----------|----------|
| **Active** | Hedefle aktif etkileşim | XSS, SQLi, OS Command, SSTI, Path Traversal |
| **Passive** | Pasif analiz | Headers, Cookies, Information Disclosure |

#### Plugins

| Plugin | Açıklama |
|--------|----------|
| `login_form` | Form tabanlı otomatik giriş |
| `login_script` | Script tabanlı özel giriş |
| `proxy` | HTTP trafiği yakalama ve training |
| `vector_feed` | Önceden export edilmiş vectorleri import |
| `autothrottle` | Sunucu stresine göre otomatik hız ayarlama |

---

## 3. Tarama Başlatma Akışı

### 3.1 CLI ile Başlatma

```bash
# Basit tarama
bin/DAST http://target.com

# Gelişmiş tarama
bin/DAST http://target.com \
--checks=active/* \
--platforms=linux,mysql,php \
--audit-links --audit-forms --audit-cookies \
--http-request-concurrency=10 \
--dom-pool-size=4 \
--script=custom_config.rb \
--scope-exclude-pattern=logout
```

### 3.2 Başlatma Sırası

```
1. OPTIONS PARSING
└── Komut satırı argümanları parse edilir

2. COMPONENT LOADING
├── Checks yüklenir (--checks ile filtreleme)
├── Plugins yüklenir (--plugin ile yapılandırma)
├── Fingerprinters yüklenir
└── Reporters hazırlanır

3. SCRIPT EXECUTION (varsa)
└── --script ile belirtilen scriptler çalıştırılır

4. SESSION SETUP
├── Login plugin aktifse giriş yapılır
└── Session check yapılandırılır

5. INITIAL REQUEST
├── Hedef URL'ye ilk istek
├── Response analizi
└── Platform fingerprinting başlar

6. CRAWLING PHASE
├── BrowserPool başlatılır
├── DOM exploration başlar
└── Input vectorleri toplanır

7. AUDIT PHASE
├── Her input vector için checks çalıştırılır
├── Payload injection
└── Response analizi

8. REPORTING
├── Issues toplanır
└── Rapor oluşturulur
```

## 4. Session Yönetimi


### 4.1 Oturum Akışı








### 4.2 Login Script Örneği

```ruby
# login_script.
browser.goto 'http://target.com/login'

form = browser.form(id: 'loginForm')
form.text_field(name: 'username').set 'admin'
form.text_field(name: 'password').set 'secret123'
form.submit

# Session check yapılandırması
DAST::Engine::Options.session.check_url = browser.url
DAST::Engine::Options.session.check_pattern = /Welcome.*admin/
```

### 4.3 HTTP Client ile Login

```ruby
response = http.post('http://target.com/api/login',
body: {
username: 'admin',
password: 'secret123'
}.to_json,
headers: {
'Content-Type' => 'application/json'
},
mode: :sync,
update_cookies: true
)

# Token extraction
token = JSON.parse(response.body)['token']
http.headers['Authorization'] = "Bearer #{token}"
```

---

## 5. Crawling ve DOM Exploration

### 5.1 BrowserPool Mimarisi






### 5.2 DOM Exploration Süreci

```ruby
# Her sayfa için DOM exploration
TracePoint.newcall, :line, :c_call) do |tp|
# Ruby'de execution flow izleme
end

# Browser tarafında:
# 1. Sayfa yüklenir
# 2. JS environment inject edilir (DAST monitoring)
# 3. DOM elementleri keşfedilir
# 4. Event'ler tetiklenir (click, submit, hover...)
# 5. AJAX istekleri izlenir
# 6. Yeni sayfalar/state'ler kaydedilir
```

### 5.3 Event Triggering






### 5.4 Transition Recording

Her DOM değişikliği bir "transition" olarak kaydedilir:

```ruby
# Transition örneği
{
event: :click,
element: '<button id="submit">',
clock: 1705612345.123,
time: 0.045 # saniye
}
```

---

## 6. Platform Fingerprinting

### 6.1 Fingerprinting Akışı







### 6.2 Platform-Specific Payload Seçimi

Fingerprinting sonucuna göre sadece ilgili payloadlar kullanılır:

```ruby
# MySQL tespit edildiğinde
payloads = [
"' OR '1'='1",
"' UNION SELECT NULL,NULL--",
"1' AND SLEEP(5)--"
]

# MSSQL tespit edildiğinde
payloads = [
"'; WAITFOR DELAY '0:0:5'--",
"' UNION SELECT NULL,NULL--",
"1'; EXEC xp_cmdshell('whoami')--"
]
```

---

## 7. IAST Entegrasyonu (Greybox Testing)

### 7.1 IAST Nedir?

IAST, web uygulamalarına eklenen bir **middleware**'dir . DAST taraması sırasında:
- **Execution Flow**: Hangi kod satırlarının çalıştığını izler
- **Data Flow**: Input verinin kod içinde nasıl aktığını izler (Taint Analysis)

### 7.2 Platform Desteği

| Platform | Teknoloji | Kurulum |
|----------|-----------|---------|
| **Java** | JVM Agent + Servlet Filter | `-javaagent:IAST.jar` |
| **Ruby** | Rack Middleware | `use DAST::IAST` |
| **.NET** | ASP.NET Middleware | `app.UseIAST()` |

### 7.3 Request/Response Akışı







### 7.4 Trace Output Yapısı

```json
{
"execution_flow": {
"points": [
{
"class_name": "UserController",
"method_name": "show",
"path": "app/controllers/user_controller.rb",
"line_number": 42,
"event": "call",
"source": " @user = User.find(params[:id])",
"file_contents": "class UserController < ApplicationController\n..."
},
{
"class_name": "User",
"method_name": "find",
"path": "app/models/user.rb",
"line_number": 15,
"event": "call",
"source": " where(id: id).first",
"file_contents": "..."
}
]
},
"data_flow": [
{
"object": "ActiveRecord::Base",
"method_name": "where",
"tainted_argument_index": 0,
"tainted_value": "1' OR '1'='1",
"backtrace": [
"app/models/user.rb:15",
"app/controllers/user_controller.rb:42"
]
}
],
"platforms": ["ruby", "linux", "rails", "pgsql"]
}
```

### 7.5 Java IAST Detayları

```java
// Agent başlatma
public static void premain(String agentArgs, Instrumentation inst) {
// Argümanları parse et
parseArguments(agentArgs);

// ClassTransformer'ı kaydet
inst.addTransformer(new ClassTransformer(inst), true);
}

// Bytecode enjeksiyonu
public byte[] transform(ClassLoader loader, String className, ...) {
// ASM ile bytecode manipülasyonu
ClassReader cr = new ClassReader(classfileBuffer);
ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES);
ClassVisitor cv = new TracingClassVisitor(cw, className);
cr.accept(cv, ClassReader.EXPAND_FRAMES);
return cw.toByteArray();
}

// Her satır için trace ekleme
mv.visitMethodInsn(INVOKESTATIC,
"com/executor/IAST/core/CodeTracer",
"traceLine",
"(Ljava/lang/String;Ljava/lang/String;ILjava/lang/StringV",
false);
```

---

## 8. Audit Süreci

### 8.1 Audit Pipeline

```




### 8.2 Audit Modu

```bash
--audit-mode=quick # Hızlı, az payload
--audit-mode=smart # Akıllı (varsayılan)
--audit-mode=catastrophic # Tüm payloadlar, daha fazla DOM probing, Karşı sistemi yorabilir.
```

### 8.3 Taint Analysis

```ruby
# Payload içeren request
element.with_input_value("<script>alert('XSS')</script>")
element.submit

# Response analizi
if response.body.include?("<script>alert('XSS')</script>")
log_issue(
proof: response.body,
vector: element,
response: response
)
end
```

---

## 9. Dağıtık Mimari

### 9.1 Bileşenler





### 9.2 Grid Strategies

| Strateji | Açıklama | Kullanım |
|----------|----------|----------|
| **Horizontal** | En az yüklü Agent'a yönlendir | Yük dağılımı için |
| **Vertical** | En çok yüklü Agent'a yönlendir | Maliyet optimizasyonu için |

### 9.3 Grid Oluşturma

```bash
# İlk Agent
bin/DAST_agent

# Diğer Agent'lar (peer belirterek)
bin/DAST_agent --port=7777 --peer=127.0.0.1:7776
bin/DAST_agent --port=7333 --peer=127.0.0.1:7777

# Multi-Instance tarama (tek taramayı paralelize et)
bin/DAST_spawn --agent-url=127.0.0.1:7777 \
http://target.com --multi-instances=5
```

### 9.4 Scheduler Kullanımı

```bash
# Scheduler başlat
bin/DAST_scheduler

# Tarama planla
bin/DAST_scheduler_push --scheduler-url=localhost:7777 http://target.com

# Durumu izle
bin/DAST_scheduler_list localhost:7777
```

---

## 10. Raporlama

### 10.1 Rapor Formatları

| Format | Komut | Açıklama |
|--------|-------|----------|
| HTML | `--report=htmlutfile=report.html.zip` | Görsel rapor |
| JSON | `--report=jsonutfile=report.json` | API entegrasyonu |
| XML | `--report=xmlutfile=report.xml` | CI/CD entegrasyonu |
| YAML | `--report=yamlutfile=report.yaml` | Okunabilir format |
| Text | `--report=txtutfile=report.txt` | Basit metin |
| STDOUT | `--report=stdout` | Terminal çıktısı |

### 10.2 Issue Yapısı

```ruby
{
name: "SQL Injection",
description: "SQL injection vulnerability detected...",
severity: :high, # :informational, :low, :medium, :high

vector: {
type: :form,
url: "http://target.com/login",
action: "http://target.com/auth",
affected_input_name: "username"
},

proof: "Error: near \"'\": syntax error",

page: {
url: "http://target.com/login",
response_code: 500
},

referring_page: {
url: "http://target.com/"
},

# IAST verileri (varsa)
execution_flow: [...],
data_flow: [...],

check: {
name: "SQL Injection",
shortname: "sqli"
},

platform_name: "mysql"
}
```

### 10.3 Incremental Scan

```bash
# İlk tarama
bin/DAST http://target.com

# Session dosyasını al
# Output: /home/user/.DAST/sessions/abc123.session

# Sadece yeni vectorleri tara
bin/DAST_restore /home/user/.DAST/sessions/abc123.session
```

******************** *************************