## Django Güvenliği: 10 Kritik Best Practice [2026 Rehberi] Siber saldırılar, 2026 yılında da web uygulamalarını hedef almaya devam ediyor ve her yıl milyonlarca dolarlık zarara yol açıyor. Günümüzün dijital dünyasında, geliştirilen her uygulamanın güvenlik katmanları, kullanıcı verilerini ve iş sürekliliğini korumak adına kritik bir öneme sahip. Özellikle Django gibi popüler ve güçlü bir web framework kullanırken bile, yerleşik güvenlik mekanizmalarına ek olarak proaktif önlemler almak zorunludur. Bu kapsamlı rehberde, 2026 yılı itibarıyla Django web uygulamalarınızı siber tehditlere karşı korumanın en etkili yollarını keşfedecek, en güncel güvenlik best practice'lerinden ileri seviye tekniklere, pratik kod örneklerinden yaygın hataların çözümlerine kadar her şeyi öğrenerek uygulamanızın güvenliğini sağlamlaştıracaksınız. Ekibimizde edindiğimiz 10 yılı aşkın tecrübeyle, bu rehberin size 2026'nın en güncel ve pratik bilgilerini sunacağından eminim. ## Django Güvenliği Nedir? Django'nun yerleşik güvenlik mekanizmaları ve geliştiricilerin alması gereken ek önlemleri kapsayan, 2026 itibarıyla güncel tehditlere karşı koruma sağlayan prensip ve uygulamalar bütünüdür. Web uygulamalarını XSS, CSRF, SQL enjeksiyonu gibi saldırılardan korumayı hedefler. Django'nun "güvenlikli varsayılanlar" felsefesi, geliştiricilerin güvenlik açıklarını istemeden oluşturmasını zorlaştırırken, kapsamlı bir koruma için ek adımlar atmak şarttır. Django, web geliştiricilerine hızlı ve verimli bir şekilde uygulama oluşturma imkanı sunarken, güvenlik konusunda da güçlü bir temel sağlar. Çoğu web framework'ünün aksine, Django birçok yaygın güvenlik açığına karşı yerleşik korumalarla gelir. Örneğin, Cross-Site Request Forgery (CSRF), Cross-Site Scripting (XSS) ve SQL Enjeksiyonu gibi saldırılar, Django'nun mimarisi ve varsayılan ayarları sayesinde büyük ölçüde engellenir. Ancak 2026 yılında siber tehditlerin sürekli evrim geçirdiği bir ortamda, yalnızca varsayılan ayarlara güvenmek yeterli değildir. Geliştiricilerin, Django'nun sunduğu araçları doğru bir şekilde yapılandırması ve ek güvenlik katmanları eklemesi gerekmektedir. Bu, uygulamanın tüm yaşam döngüsü boyunca güvenlik bilincini sürdürmeyi ve en güncel best practice'leri uygulamayı içerir. ## Neden Django Güvenliği Kritik? Bir Django uygulamasının güvenliğini sağlamak, sadece kodun doğru çalışmasını garanti altına almakla kalmaz, aynı zamanda kullanıcıların verilerini korur, şirketin itibarını sürdürür ve yasal uyumluluk gereksinimlerini karşılar. 2026 yılında veri ihlallerinin maliyeti ve yasal sonuçları hiç olmadığı kadar ağırlaşmıştır. Bu nedenle, Django güvenlik önlemleri, herhangi bir projenin ayrılmaz bir parçası olmalıdır. ### Somut Faydalar ve Problemler * **Veri İhlali Önleme**: Şirketler için en büyük risklerden biri olan veri sızıntılarını engeller. Hassas kullanıcı bilgilerinin (parolalar, kişisel veriler, finansal bilgiler) kötü niyetli kişilerin eline geçmesini önleyerek büyük finansal ve itibar kaybının önüne geçilir. Production ortamında karşılaştığım birçok veri ihlali girişimi, genellikle temel güvenlik açıklarından kaynaklanıyordu. Bu nedenle, proaktif güvenlik uygulamaları hayati önem taşır. * **İtibar Koruma**: Bir güvenlik ihlali, şirketin müşterileri nezdindeki güvenilirliğini ciddi şekilde zedeleyebilir. Güvenli bir uygulama, kullanıcıların markaya olan inancını pekiştirir. * **Yasal Uyumluluk**: GDPR, KVKK gibi veri koruma düzenlemeleri, şirketlerin kullanıcı verilerini güvenli bir şekilde saklamasını ve işlemesini zorunlu kılar. Django güvenlik best practice'lerini uygulamak, bu yasal yükümlülükleri yerine getirmeye yardımcı olur. * **Finansal Kayıpları Engelleme**: Veri ihlalleri, yasal para cezaları, müşteri tazminatları ve güvenlik iyileştirmeleri için yüksek maliyetlere yol açabilir. Güvenliğe yatırım yapmak, uzun vadede bu tür maliyetlerden kaçınmayı sağlar. * **Hizmet Sürekliliği**: DDoS (Distributed Denial of Service) saldırıları veya yetkisiz erişimler, uygulamanın hizmet dışı kalmasına neden olabilir. Güçlü güvenlik önlemleri, bu tür kesintileri minimize eder. ### Kimler İçin Uygundur? Django güvenlik best practice'leri, küçük bir blog uygulamasından büyük ölçekli kurumsal sistemlere kadar her türlü Django projesi için uygundur. Özellikle finans, sağlık, e-ticaret gibi hassas verilerle çalışan veya yüksek kullanıcı trafiğine sahip uygulamalar için bu önlemler olmazsa olmazdır. Ekibimizde, finansal teknolojiler alanında geliştirdiğimiz projelerde Django 5.x ile güvenlik standartlarını en üst düzeyde tutmak için bu yaklaşımları uyguladık ve başarılı sonuçlar elde ettik. ### Ekosistem Büyüklüğü ve Güvenlik Desteği 2026 itibarıyla Django, hala aktif ve geniş bir geliştirici topluluğuna sahiptir. Bu topluluk, framework'ün sürekli olarak güncellenmesini, güvenlik açıklarının hızlıca tespit edilip düzeltilmesini ve yeni güvenlik özelliklerinin eklenmesini sağlar. Django'nun resmi dökümantasyonu, güvenlik konusunda çok değerli bilgiler sunar ve düzenli olarak güncellenir. Ayrıca, `pip-audit` gibi araçlar ve GitHub'daki güvenlik danışmanlığı özellikleri sayesinde bağımlılıklarınızdaki güvenlik açıklarını kolayca tespit edebilirsiniz. Bu aktif ekosistem, 2026'da Django'yu güvenli bir tercih yapmaya devam etmektedir. ## Django Güvenliği vs Alternatifler Django'nun güvenlik konusundaki yerleşik gücünü daha iyi anlamak için, popüler Python web framework'leri Flask ve FastAPI ile bir karşılaştırma yapalım. Bu karşılaştırma, 2026 yılındaki güncel durumları yansıtmaktadır. | Özellik | Django (2026) | Flask (2026) | FastAPI (2026) | | :--------------------- | :---------------------------------------------------- | :--------------------------------------------------------- | :--------------------------------------------------------- | | **Yerleşik Güvenlik** | CSRF, XSS, SQL Enjeksiyonu, Parola Hashing, Session Güvenliği. Kapsamlı. | Minimalist. Güvenlik için ek kütüphaneler (Flask-Security, WTForms) gerektirir. | Pydantic ile veri validasyonu. Starlette ile middleware tabanlı güvenlik. | | **Öğrenme Eğrisi** | Güvenlik varsayılanları sayesinde başlangıç kolaylığı. İleri seviye ayarlamalar için derinleşme. | Güvenlik modüllerini manuel entegre etme gereği nedeniyle orta. | Asenkron yapı ve Pydantic nedeniyle başlangıçta biraz daha yüksek. | | **Ekosistem & Kütüphane** | Zengin kütüphane desteği (`django-allauth`, `djangorestframework-simplejwt`), aktif güvenlik yamaları. | Flask-Security, Flask-WTF gibi popüler eklentiler. Topluluk desteği güçlü. | Hızlı büyüyen ekosistem. `python-jose`, `fastapi-users` gibi kütüphaneler. | | **Topluluk Desteği** | Çok geniş ve olgun topluluk. Güvenlik odaklı forumlar ve kaynaklar. | Geniş ve aktif topluluk. Güvenlik konularında Stack Overflow'da çok kaynak. | Hızla büyüyen, modern yaklaşımlara odaklı topluluk. | | **Kurumsal Destek** | Büyük ölçekli kurumsal projelerde yaygın kullanım. Güvenlik denetimleri için iyi dokümantasyon. | Daha küçük ve orta ölçekli projelerde tercih edilir. Güvenlik için modüler yaklaşım. | Mikroservisler ve yüksek performanslı API'lar için tercih edilir. | | **Kullanım Alanı** | Monolitik uygulamalar, CMS, CRM, e-ticaret siteleri. Güvenlik kritik sistemler. | Mikroservisler, küçük API'lar, prototipleme. | Yüksek performanslı API'lar, asenkron uygulamalar, mikroservisler. | Django, güvenlik konusunda başlangıçtan itibaren güçlü bir temel sunarken, Flask ve FastAPI daha fazla manuel konfigürasyon ve üçüncü taraf kütüphane entegrasyonu gerektirir. 2026'da her üç framework de güçlü güvenlik çözümleri sunsa da, Django'nun yerleşik yapısı ve "güvenlikli varsayılanlar" felsefesi, özellikle büyük ölçekli ve kurumsal projelerde geliştiricilere önemli bir avantaj sağlamaktadır. Bu durum, özellikle güvenlik standartlarının yüksek olduğu sektörlerde Django'yu öne çıkarmaktadır. ## Kurulum ve İlk Adımlar (Güvenli Başlangıç) Güvenli bir Django projesi geliştirmenin ilk adımı, doğru bir kurulum ve temel güvenlik ayarlarıyla başlamaktır. 2026 itibarıyla Django 5.x sürümlerini kullanmanız, en güncel güvenlik yamalarından ve özelliklerinden faydalanmanızı sağlayacaktır. ### 1. Sanal Ortam Oluşturma Her Django projesi için izole bir sanal ortam (`venv`) kullanmak, bağımlılık çakışmalarını önler ve projenizin güvenliğini artırır. Global paketi kirletmekten kaçınırsınız. ```bash # Proje dizini oluşturma mkdir django_secure_app_2026 cd django_secure_app_2026 # Sanal ortam oluşturma python -m venv venv # Sanal ortamı etkinleştirme # Linux/macOS source venv/bin/activate # Windows virtual_env\Scripts\activate ``` ### 2. Django Kurulumu Etkinleştirdiğiniz sanal ortamda Django'nun en güncel kararlı sürümünü (2026 itibarıyla Django 5.x) kurun. ```bash pip install Django==5.0.4 # 2026'nın güncel kararlı sürümünü kullanın pip install djangorestframework django-environ # Ek kütüphaneler ``` ### 3. Yeni Proje Oluşturma Django projenizi oluşturun. ```bash django-admin startproject mysecureproject . ``` ### 4. Temel Güvenlik Ayarlarını Yapılandırma (`settings.py`) `mysecureproject/settings.py` dosyasında aşağıdaki kritik güvenlik ayarlarını yapılandırmak, projenizin temelini güçlendirecektir. * **`SECRET_KEY`**: Bu anahtar, Django'nun kriptografik imzalama için kullandığı çok hassas bir bilgidir. Asla doğrudan `settings.py` içinde tutulmamalı ve versiyon kontrol sistemine (`git`) dahil edilmemelidir. Bunun yerine ortam değişkenlerinden okunmalıdır. `django-environ` kütüphanesi bu konuda çok yardımcı olur. ```python # mysecureproject/settings.py import os from environ import Env # environ nesnesini başlat env = Env() Env.read_env() # .env dosyasını oku # SECRET_KEY'i ortam değişkeninden al SECRET_KEY = env('DJANGO_SECRET_KEY') ``` Proje kök dizininde `.env` adında bir dosya oluşturun ve içine: ``` # .env DJANGO_SECRET_KEY='çok-güçlü-ve-rastgele-bir-anahtar-buraya-gelmeli-2026' ``` > **Pro Tip**: `SECRET_KEY`'i her dağıtımda farklı ve rastgele oluşturmak, güvenliği artırır. Online araçlar veya `os.urandom(50).hex()` gibi Python kodları ile oluşturabilirsiniz. * **`DEBUG = False`**: Üretim ortamında `DEBUG` modunu `True` bırakmak, hassas bilgilerin (stack trace, ortam değişkenleri) potansiyel saldırganlara ifşa olmasına neden olur. **Asla üretimde `DEBUG=True` kullanmayın.** ```python # mysecureproject/settings.py DEBUG = env.bool('DJANGO_DEBUG', default=False) ``` `.env` dosyanıza: ``` # .env DJANGO_DEBUG=False ``` * **`ALLOWED_HOSTS`**: Django, bu ayarda belirtilen host'lar dışında gelen HTTP isteklerini kabul etmez. Bu, HTTP Host başlığı saldırılarına karşı koruma sağlar. Üretim ortamında uygulamanızın çalıştığı domain adlarını listelemelisiniz. ```python # mysecureproject/settings.py ALLOWED_HOSTS = env.list('DJANGO_ALLOWED_HOSTS', default=['127.0.0.1', 'localhost']) ``` `.env` dosyanıza: ``` # .env DJANGO_ALLOWED_HOSTS='example.com,www.example.com' ``` * **Veritabanı Güvenliği**: Django'nun `settings.py` dosyasında veritabanı bağlantı bilgilerini de ortam değişkenlerinden okumak en iyi yaklaşımdır. Ayrıca, veritabanı kullanıcılarınızın minimum yetki prensibine göre yapılandırıldığından emin olun. ```python # mysecureproject/settings.py DATABASES = { 'default': env.db('DATABASE_URL', default='sqlite:///db.sqlite3') } ``` `.env` dosyanıza (örnek PostgreSQL için): ``` # .env DATABASE_URL='postgres://user:password@host:port/dbname' ``` Bu ilk adımlar, 2026'da Django uygulamanızın temel güvenlik duruşunu önemli ölçüde güçlendirecektir. Ekibimizde her yeni projeye bu adımlarla başlarız ve bu, birçok potansiyel güvenlik sorununu daha en başta engellememizi sağlar. ## Temel Güvenlik Uygulamaları Django, birçok yaygın web güvenlik açığına karşı yerleşik korumalar sunar. Bu bölümde, bu temel mekanizmaları ve bunları nasıl doğru kullanacağınızı inceleyeceğiz. 2026'nın siber tehdit ortamında bu korumaların önemi daha da artmıştır. ### 1. Cross-Site Request Forgery (CSRF) Koruması CSRF, bir saldırganın, kullanıcının bilgisi veya izni olmadan, kullanıcının kimlik doğrulanmış oturumunu kullanarak web uygulamasına istek göndermesi durumudur. Django, bu tür saldırılara karşı güçlü bir koruma mekanizması sağlar. * **Nasıl Çalışır**: Django'nun `CsrfViewMiddleware`'i, her POST formuna benzersiz bir token (`csrf_token`) ekler. Sunucu, gelen isteğin bu token'ı içerip içermediğini ve geçerli olup olmadığını kontrol eder. Geçersizse istek reddedilir. * **Kullanım**: Çoğu durumda, Django'nun template sistemini kullanıyorsanız, `{% csrf_token %}` etiketini formlarınızın içine eklemeniz yeterlidir. ```html

{% csrf_token %} Yeni Öğe: Ekle

``` > **Uyarı**: `@csrf_exempt` dekoratörünü yalnızca çok özel durumlarda ve riskleri tam olarak anladığınızda kullanın (örneğin, herkese açık bir API endpoint'i için). Genellikle bu dekoratör, güvenlik risklerini artırır. ### 2. Cross-Site Scripting (XSS) Koruması XSS, saldırganın kötü amaçlı istemci tarafı betiklerini (genellikle JavaScript) web sayfalarına enjekte etmesiyle gerçekleşir. Bu betikler, kullanıcının tarayıcısında çalışarak oturum çerezlerini çalabilir veya hassas bilgileri ele geçirebilir. * **Nasıl Çalışır**: Django'nun template sistemi, varsayılan olarak tüm değişkenleri otomatik olarak HTML'den kaçırır (escape eder). Bu, kullanıcı tarafından girilen verilerin HTML olarak yorumlanmasını engeller ve XSS saldırılarını önler. * **Kullanım**: Normalde herhangi bir ek işlem yapmanıza gerek yoktur. Ancak `mark_safe` gibi fonksiyonları kullanırken dikkatli olun. ```python # myapp/views.py from django.shortcuts import render def display_comment(request): user_comment = request.GET.get('comment', '

Yorum bulunamadı.

') # Django template motoru user_comment'i otomatik olarak escape eder return render(request, 'myapp/comment.html', {'comment': user_comment}) ``` ```html

Yorumunuz:

``` Eğer `mark_safe` kullanırsanız, içeriğin güvenli olduğundan emin olun: ```python from django.utils.safestring import mark_safe # ... safe_html = mark_safe('Bu metin güvenli.') # ... ``` ### 3. SQL Enjeksiyonu Koruması SQL enjeksiyonu, saldırganın veritabanı sorgularına kötü amaçlı SQL kodları ekleyerek veritabanına yetkisiz erişim sağlaması veya verileri manipüle etmesidir. * **Nasıl Çalışır**: Django'nun ORM (Object-Relational Mapper) sistemi, sorguları güvenli bir şekilde parametreleştirir. Bu, kullanıcı girdilerinin doğrudan SQL kodu olarak yorumlanmasını engeller. * **Kullanım**: Her zaman Django ORM'ini kullanın. Raw SQL sorguları yazmanız gerektiğinde, parametreleştirme yöntemlerini kullanın ve asla kullanıcı girdisini doğrudan sorgu string'ine eklemeyin. ```python # Güvenli ORM kullanımı from myapp.models import Item item_name = request.GET.get('name') items = Item.objects.filter(name=item_name) # ORM, parametreleri güvenli bir şekilde işler ``` ```python # Raw SQL kullanırken güvenli yaklaşım from django.db import connection user_input = request.GET.get('search_term') with connection.cursor() as cursor: cursor.execute("SELECT * FROM myapp_item WHERE name = %s", [user_input]) row = cursor.fetchone() ``` > **Anti-Pattern**: Asla `cursor.execute(f"SELECT * FROM myapp_item WHERE name = '{user_input}'")` gibi bir yapı kullanmayın. Bu, doğrudan SQL enjeksiyonu açığına yol açar. ### 4. Parola Hashing Parolaları açık metin olarak saklamak, büyük bir güvenlik riskidir. Django, parolaları güvenli bir şekilde hash'lemek için güçlü algoritmalar kullanır. * **Nasıl Çalışır**: `django.contrib.auth.hashers` modülü, parolaları karmaşık algoritmalarla (varsayılan olarak PBKDF2) hash'ler ve her parola için benzersiz bir salt (rastgele veri) kullanır. Bu, aynı parolaya sahip iki kullanıcının farklı hash'lere sahip olmasını sağlar ve rainbow table saldırılarını engeller. * **Kullanım**: Django'nun `User` modelini ve `create_user`, `set_password` gibi yöntemlerini kullandığınızda, parolalar otomatik olarak hash'lenir. ```python # myapp/models.py from django.contrib.auth.models import AbstractUser class CustomUser(AbstractUser): # Ek alanlar eklenebilir pass # Kullanıcı oluşturma (örnek) # from django.contrib.auth import get_user_model # User = get_user_model() # user = User.objects.create_user('john_doe', 'john@example.com', 'çokgüçlüparola2026!') # user.set_password('yeni_çokgüçlüparola2026!') # user.save() ``` Django 5.x, PBKDF2 algoritmasını kullanmaya devam etmektedir ve 2026 itibarıyla bu hala güçlü bir seçenektir. Ancak gelecekte daha yeni ve daha dirençli algoritmalar da desteklenebilir. ### 5. Session Güvenliği Kullanıcı oturumları, hassas bilgileri içerebilir ve çalınmaları durumunda ciddi güvenlik riskleri oluşturabilir. Django, session'ları güvenli bir şekilde yönetmek için çeşitli ayarlar sunar. * **`SESSION_COOKIE_SECURE`**: `True` olarak ayarlandığında, oturum çerezleri yalnızca HTTPS bağlantıları üzerinden gönderilir. Bu, çerezlerin Man-in-the-Middle (MITM) saldırılarıyla çalınmasını engeller. **Üretim ortamında daima `True` olmalıdır.** ```python # mysecureproject/settings.py SESSION_COOKIE_SECURE = env.bool('DJANGO_SESSION_COOKIE_SECURE', default=True) ``` * **`SESSION_COOKIE_HTTPONLY`**: `True` olarak ayarlandığında, oturum çerezlerine istemci tarafı JavaScript ile erişilemez. Bu, XSS saldırıları yoluyla çerez çalınmasını önlemeye yardımcı olur. **Daima `True` olmalıdır.** ```python # mysecureproject/settings.py SESSION_COOKIE_HTTPONLY = env.bool('DJANGO_SESSION_COOKIE_HTTPONLY', default=True) ``` * **`CSRF_COOKIE_SECURE` ve `CSRF_COOKIE_HTTPONLY`**: Aynı şekilde CSRF token'ı içeren çerezler için de bu ayarların `True` olması önemlidir. ```python # mysecureproject/settings.py CSRF_COOKIE_SECURE = env.bool('DJANGO_CSRF_COOKIE_SECURE', default=True) CSRF_COOKIE_HTTPONLY = env.bool('DJANGO_CSRF_COOKIE_HTTPONLY', default=True) ``` Bu temel güvenlik uygulamaları, Django projenizin omurgasını oluşturur ve 2026'nın zorlu siber ortamında sizi birçok yaygın tehditten korur. Ekibimizde bu ayarları her projenin başlangıcında standart olarak uygularız. ## İleri Seviye Güvenlik Teknikleri Temel güvenlik önlemleri önemli olsa da, 2026'nın karmaşık tehdit ortamında, Django uygulamalarınızı daha da güçlendirmek için ileri seviye tekniklere ihtiyaç duyulur. Bu bölümde, production seviyesinde güvenlik sağlamak için kullanabileceğiniz bazı gelişmiş yöntemleri inceleyeceğiz. ### 1. JWT (JSON Web Tokens) ve OAuth2 ile Kimlik Doğrulama Geleneksel session tabanlı kimlik doğrulamanın yanı sıra, özellikle API'lar için JWT ve OAuth2 tabanlı sistemler popülerdir. Django REST Framework (`djangorestframework`) ile bu sistemleri kolayca entegre edebilirsiniz. * **JWT Kullanımı**: `djangorestframework-simplejwt` kütüphanesi, JWT tabanlı kimlik doğrulamayı Django projenize hızla eklemenizi sağlar. ```bash pip install djangorestframework-simplejwt ``` `settings.py` içinde: ```python # mysecureproject/settings.py # ... diğer ayarlar ... REST_FRAMEWORK = { 'DEFAULT_AUTHENTICATION_CLASSES': ( 'rest_framework_simplejwt.authentication.JWTAuthentication', 'rest_framework.authentication.SessionAuthentication', # Opsiyonel, sadece tarayıcı için ), 'DEFAULT_PERMISSION_CLASSES': [ 'rest_framework.permissions.IsAuthenticated', ] } from datetime import timedelta SIMPLE_JWT = { 'ACCESS_TOKEN_LIFETIME': timedelta(minutes=5), # Kısa ömürlü access token 'REFRESH_TOKEN_LIFETIME': timedelta(days=1), # Daha uzun ömürlü refresh token 'ROTATE_REFRESH_TOKENS': True, 'BLACKLIST_AFTER_ROTATION': True, 'UPDATE_LAST_LOGIN': True, 'ALGORITHM': 'HS256', # 2026 itibarıyla hala güvenli bir seçenek 'SIGNING_KEY': SECRET_KEY, 'VERIFYING_KEY': None, 'AUDIENCE': None, 'ISSUER': None, 'JWK_URL': None, 'LEEWAY': 0, 'AUTH_HEADER_TYPES': ('Bearer',), 'AUTH_HEADER_NAME': 'HTTP_AUTHORIZATION', 'USER_ID_FIELD': 'id', 'USER_ID_CLAIM': 'user_id', 'USER_AUTHENTICATION_RULE': 'rest_framework_simplejwt.authentication.default_user_authentication_rule', 'AUTH_TOKEN_CLASSES': ('rest_framework_simplejwt.tokens.AccessToken',), 'TOKEN_TYPE_CLAIM': 'token_type', 'TOKEN_USER_CLASS': 'rest_framework_simplejwt.models.TokenUser', 'JTI_CLAIM': 'jti', 'SLIDING_TOKEN_REFRESH_EXP_CLAIM': 'refresh_exp', 'SLIDING_TOKEN_LIFETIME': timedelta(minutes=5), 'SLIDING_TOKEN_REFRESH_LIFETIME': timedelta(days=1), } ``` `mysecureproject/urls.py` içine JWT endpoint'lerini ekleyin: ```python # mysecureproject/urls.py from django.contrib import admin from django.urls import path, include from rest_framework_simplejwt.views import ( TokenObtainPairView, TokenRefreshView, TokenVerifyView, ) urlpatterns = [ path('admin/', admin.site.urls), path('api/token/', TokenObtainPairView.as_view(), name='token_obtain_pair'), path('api/token/refresh/', TokenRefreshView.as_view(), name='token_refresh'), path('api/token/verify/', TokenVerifyView.as_view(), name='token_verify'), # Diğer API endpoint'leriniz path('api/', include('myapp.urls')), # Örnek uygulama URL'leri ] ``` > **Experience**: Son projemde bu JWT yaklaşımını uyguladığımda, mobil uygulamalar ve tek sayfa uygulamaları (SPA) için çok daha esnek ve güvenli bir kimlik doğrulama mekanizması sağladık. Access token'ların kısa ömürlü olması ve refresh token'ların rotation'ı, potansiyel token çalınmalarına karşı ek bir güvenlik katmanı sunar. ### 2. Rate Limiting (Oran Sınırlama) Brute-force saldırılarını, API kötüye kullanımını ve hizmet reddi (DoS) saldırılarını önlemek için istek oranlarını sınırlamak önemlidir. Django REST Framework, yerleşik rate limiting mekanizmaları sunar. * **Kullanım**: `settings.py` içinde global olarak veya belirli view'lar için sınıf düzeyinde tanımlayabilirsiniz. ```python # mysecureproject/settings.py REST_FRAMEWORK = { # ... diğer ayarlar ... 'DEFAULT_THROTTLE_CLASSES': [ 'rest_framework.throttling.AnonRateThrottle', 'rest_framework.throttling.UserRateThrottle' ], 'DEFAULT_THROTTLE_RATES': { 'anon': '100/day', # Kimliği doğrulanmamış kullanıcılar için 'user': '1000/day' # Kimliği doğrulanmış kullanıcılar için } } ``` Belirli bir view için: ```python # myapp/views.py from rest_framework.views import APIView from rest_framework.response import Response from rest_framework.throttling import UserRateThrottle class CustomRateThrottle(UserRateThrottle): rate = '5/minute' class ProtectedDataView(APIView): throttle_classes = [CustomRateThrottle] def get(self, request, format=None): content = { 'status': 'OK', 'data': 'Bu, korunan veridir. 2026' } return Response(content) ``` ### 3. Güvenli Dosya Yükleme Dosya yükleme işlevleri, kötü amaçlı dosyaların sunucuya yüklenmesiyle ciddi güvenlik açıkları oluşturabilir. Bu riskleri azaltmak için aşağıdaki önlemler alınmalıdır: * **Dosya Türü Doğrulama**: Yalnızca izin verilen dosya türlerini kabul edin (MIME türü kontrolü). Sadece dosya uzantısına güvenmeyin. * **Boyut Sınırlaması**: Aşırı büyük dosyaların yüklenmesini engelleyin. * **Zararlı İçerik Taraması**: Yüklenen dosyaları virüs veya kötü amaçlı yazılım tarayıcısından geçirin (örn. ClamAV entegrasyonu). * **Dosya Adı Güvenliği**: Yüklenen dosyaların adlarını rastgele oluşturun veya sanitize edin. `path traversal` saldırılarını önlemek için kullanıcıdan gelen dosya adlarını doğrudan kullanmayın. * **Depolama Konumu**: Yüklenen dosyaları web sunucusunun doğrudan erişemeyeceği bir dizinde veya bir bulut depolama hizmetinde (S3 gibi) saklayın. Eğer sunucuda saklıyorsanız, yürütülebilir haklarını kaldırın. ```python # myapp/forms.py from django import forms from django.core.exceptions import ValidationError class DocumentUploadForm(forms.Form): document = forms.FileField() def clean_document(self): uploaded_file = self.cleaned_data['document'] # 2026 itibarıyla kabul edilen güvenli dosya türleri allowed_types = ['application/pdf', 'image/jpeg', 'image/png'] max_size_mb = 5 if uploaded_file.content_type not in allowed_types: raise ValidationError(f"Desteklenmeyen dosya türü. Yalnızca {', '.join(allowed_types)} kabul edilir.") if uploaded_file.size > max_size_mb * 1024 * 1024: raise ValidationError(f"Dosya boyutu {max_size_mb} MB'ı aşamaz.") # Ek olarak, bir virüs tarayıcı servisine gönderme mantığı eklenebilir # if not scan_for_viruses(uploaded_file): # raise ValidationError("Dosya zararlı içerik barındırıyor.") return uploaded_file ``` ### 4. Güvenlik Başlıkları ve Content Security Policy (CSP) HTTP güvenlik başlıkları, tarayıcıların web uygulamalarıyla nasıl etkileşime girdiğini kontrol ederek çeşitli saldırı türlerini önlemeye yardımcı olur. Django, `SecurityMiddleware` ile bu başlıkların çoğunu kolayca yönetmenizi sağlar. * **`django.middleware.security.SecurityMiddleware`**: Bu middleware, `settings.py` içinde etkinleştirildiğinde otomatik olarak bir dizi güvenlik başlığını ekler. ```python # mysecureproject/settings.py MIDDLEWARE = [ # ... diğer middleware'ler ... 'django.middleware.security.SecurityMiddleware', # ... ] # Güvenlik başlıkları ayarları SECURE_SSL_REDIRECT = env.bool('DJANGO_SECURE_SSL_REDIRECT', default=True) # HTTP'den HTTPS'e yönlendirme SECURE_HSTS_SECONDS = env.int('DJANGO_SECURE_HSTS_SECONDS', default=31536000) # 1 yıl SECURE_HSTS_INCLUDE_SUBDOMAINS = env.bool('DJANGO_SECURE_HSTS_INCLUDE_SUBDOMAINS', default=True) SECURE_HSTS_PRELOAD = env.bool('DJANGO_SECURE_HSTS_PRELOAD', default=True) SECURE_CONTENT_TYPE_NOSNIFF = env.bool('DJANGO_SECURE_CONTENT_TYPE_NOSNIFF', default=True) SECURE_BROWSER_XSS_FILTER = env.bool('DJANGO_SECURE_BROWSER_XSS_FILTER', default=True) # Eski tarayıcılar için X_FRAME_OPTIONS = 'DENY' # Clickjacking saldırılarını önler ``` > **Experience**: Ekibimizde bu güvenlik başlıklarını uyguladığımızda, özellikle `X-Frame-Options: DENY` ve `Strict-Transport-Security` (HSTS) başlıkları sayesinde clickjacking ve MITM saldırılarına karşı önemli bir koruma sağladık. 2026'da bu başlıklar hala kritik önem taşımaktadır. * **Content Security Policy (CSP)**: CSP, tarayıcıya hangi kaynaklardan (betikler, stil sayfaları, resimler vb.) içerik yükleyebileceğini söyleyen bir güvenlik mekanizmasıdır. XSS ve veri enjeksiyonu saldırılarını büyük ölçüde azaltır. `django-csp` gibi kütüphanelerle entegre edilebilir. ```bash pip install django-csp ``` `settings.py` içinde: ```python # mysecureproject/settings.py # ... MIDDLEWARE = [ # ... 'csp.middleware.CSPMiddleware', # ... ] CSP_DEFAULT_SRC = ("'self'",) CSP_SCRIPT_SRC = ("'self'", "'unsafe-inline'", "'unsafe-eval'", "https://cdn.example.com") # Örnek CSP_STYLE_SRC = ("'self'", "'unsafe-inline'") CSP_IMG_SRC = ("'self'", "data:", "https://images.example.com") CSP_REPORT_URI = '/csp-report/' # Raporları toplamak için bir endpoint CSP_REPORT_ONLY = env.bool('DJANGO_CSP_REPORT_ONLY', default=False) # Üretimde False olmalı ``` CSP'yi doğru yapılandırmak karmaşık olabilir, ancak sağladığı güvenlik faydaları göz ardı edilemez. 2026 itibarıyla modern web uygulamaları için olmazsa olmazlardandır. ## Best Practices & Anti-Patterns Django güvenlik best practice'lerini uygulamak, uygulamanızın dayanıklılığını artırırken, anti-pattern'lardan kaçınmak potansiyel zafiyetleri önler. İşte 2026'nın en kritik güvenlik önerileri ve kaçınılması gereken durumlar. * **✅ Bağımlılıkları ve Django Sürümünü Güncel Tutun**: Güvenlik açıkları genellikle eski yazılım sürümlerinde veya kütüphanelerde bulunur. Düzenli olarak `pip install --upgrade Django` komutunu kullanarak ve `pip-audit` veya `Snyk` gibi araçlarla bağımlılıklarınızı tarayarak güncel kalın. 2026'da Django 5.x kullanmak, en son güvenlik yamalarına sahip olduğunuz anlamına gelir. * **❌ `DEBUG = True` ile Üretim Ortamına Çıkmayın**: Daha önce de belirtildiği gibi, `DEBUG=True` hassas bilgilerin açığa çıkmasına neden olur. Bu, bir saldırgan için altın madenidir. Daima `DEBUG=False` olarak ayarlayın ve hata günlüklerini (logging) düzgünce yapılandırın. * **✅ Güçlü Parola Politikaları Uygulayın ve İki Faktörlü Kimlik Doğrulamayı (2FA) Zorunlu Kılın**: Kullanıcıların zayıf parolalar kullanmasını engelleyin. Django'nun `AUTH_PASSWORD_VALIDATORS` ayarı ile parola karmaşıklığını zorunlu kılabilirsiniz. Ayrıca, 2FA, çalınan parolaların bile yetkisiz erişimi en