# Flask Güvenliği: 10 Kritik Best Practice [2026 Rehberi] Web uygulamaları, 2026 itibarıyla her zamankinden daha karmaşık ve siber saldırılara açık hale geldi. Peki, Python'ın mikro web framework'ü Flask ile geliştirilen uygulamalarınızın güvenliğini en üst düzeyde tutmak için neler yapmalısınız? Bu rehberde, 10+ yıllık tecrübemle Flask 2.x tabanlı uygulamalarınızı güncel tehditlere karşı korumanın en etkili yollarını, adım adım örneklerle ve 2026'nın en iyi pratikleriyle ele alacağız. Amacımız, hem yeni başlayanlar hem de deneyimli geliştiriciler için kapsamlı bir güvenlik kılavuzu sunarak, uygulamalarınızın hem performanslı hem de siber saldırılara karşı dirençli olmasını sağlamaktır. ## Flask Nedir? Flask, Python tabanlı, hafif ve esnek bir mikro web framework'üdür. Geliştiricilere temel web uygulamaları oluşturmak için gerekli araçları sunarken, aynı zamanda ek kütüphanelerle genişletilebilirlik imkanı tanır. Modüler yapısı sayesinde, geliştiriciler projelerine sadece ihtiyaç duydukları bileşenleri dahil edebilir, bu da Flask'ı özellikle API'ler, küçük ve orta ölçekli web siteleri ve prototipleme için popüler bir tercih haline getirir. 2026'da hala aktif ve güçlü bir topluluğa sahiptir. Flask, Werkzeug WSGI araç kiti ve Jinja2 şablon motoru üzerine inşa edilmiştir. Bu minimalizm, geliştiricilere projenin yapısı ve kullanılan kütüphaneler üzerinde tam kontrol sağlar. Örneğin, veritabanı ORM'i, kimlik doğrulama mekanizması veya form doğrulama kütüphanesi gibi bileşenleri projenin gereksinimlerine göre özgürce seçebilirsiniz. Bu esneklik, hızlı geliştirme süreçleri ve düşük başlangıç maliyetleri sunarken, güvenlik konusunda geliştiricinin daha fazla sorumluluk almasını gerektirir. ## Neden Flask Güvenliği Önemli? Flask'ın minimalizmi, geliştiricilere büyük bir özgürlük sunarken, beraberinde güvenlik sorumluluğunu da getirir. Django gibi "pil dahil" framework'lerin aksine, Flask varsayılan olarak birçok güvenlik özelliğini sağlamaz. Bu durum, 2026'da siber tehditlerin giderek sofistikeleştiği bir ortamda, Flask uygulamalarının kasıtlı veya kasıtsız güvenlik açıklarına karşı savunmasız kalmasına neden olabilir. Production ortamında Flask kullanırken karşılaştığım en yaygın sorunlardan biri, geliştiricilerin güvenlik katmanlarını manuel olarak eklemeyi unutması veya yanlış yapılandırmasıdır. Güncel siber güvenlik raporlarına göre, web uygulamaları hala en sık hedeflenen saldırı vektörlerinden biridir. SQL Injection, Cross-Site Scripting (XSS), Cross-Site Request Forgery (CSRF) ve yetkisiz erişim gibi zafiyetler, kritik veri sızıntılarına, itibar kaybına ve finansal zararlara yol açabilir. Ekibimizde Flask'a geçiş sürecinde öğrendiğimiz 3 kritik ders şunlar oldu: 1) Güvenlik eklentilerini doğru kullanmak, 2) Bağımlılıkları düzenli olarak güncellemek, 3) Güvenlik testlerini geliştirme sürecine entegre etmek. Bu nedenle, Flask uygulamalarınızın güvenliğini en başından itibaren ciddiye almak, projenizin uzun vadeli başarısı için hayati önem taşır. ## Flask vs Alternatifler (Güvenlik Odaklı Karşılaştırma) Flask, esnekliğiyle öne çıkarken, güvenlik konusunda geliştiriciye daha fazla sorumluluk yükler. Diğer popüler Python web framework'leri, güvenlik mekanizmalarını farklı yaklaşımlarla ele alır. Aşağıdaki tablo, 2026 itibarıyla Flask'ı Django ve FastAPI ile güvenlik odaklı olarak karşılaştırmaktadır. | Özellik | Flask (2.x) | Django (4.x) | FastAPI (0.x) | | :-------------------------- | :---------------------------------------------- | :------------------------------------------------ | :---------------------------------------------- | | **Güvenlik Mimarisi** | Minimalist, geliştirici odaklı, eklentilerle güçlendirilir | Kapsamlı, "pil dahil", varsayılan birçok koruma | Modern, ASGI tabanlı, Pydantic ile veri doğrulama | | **Varsayılan Güvenlik** | Otomatik CSRF koruması yok, XSS için Jinja2'ye bağımlı | CSRF, XSS, SQL Injection, Clickjacking korumaları varsayılan | Pydantic ile güçlü veri doğrulama, JWT entegrasyonu kolay | | **Kimlik Doğrulama/Yetkilendirme** | Harici kütüphaneler (Flask-Login, Flask-JWT-Extended) | Dahili kullanıcı yönetim sistemi, güçlü yetkilendirme | Harici kütüphaneler (python-jose, Authlib), OAuth2 desteği | | **Güvenlik Yamaları** | Çekirdek Flask için düzenli güncellemeler, eklentiler için bağımsız | Çok aktif, hızlı güvenlik yamaları ve düzenli güncellemeler | Hızlı gelişim, güvenlik odaklı güncellemeler | | **Topluluk Desteği (Güvenlik)** | Aktif, ancak güvenlik pratikleri geliştiricinin inisiyatifinde | Büyük ve olgun topluluk, güvenlik odaklı birçok kaynak | Hızla büyüyen, modern güvenlik yaklaşımları | | **Öğrenme Eğrisi (Güvenlik için)** | Orta-Yüksek (manuel yapılandırma ve doğru eklenti seçimi gerektirir) | Düşük-Orta (varsayılan korumalar sayesinde) | Orta (Pydantic ve modern API güvenlik kavramları) | **Yorum:** Flask, güvenlik konusunda geliştiriciye daha fazla esneklik sunsa da, bu durum aynı zamanda daha fazla bilgi ve dikkat gerektirir. Django, varsayılan olarak birçok yaygın güvenlik açığına karşı koruma sağlarken, FastAPI modern API güvenlik pratikleriyle öne çıkar. Seçiminiz, projenizin gereksinimlerine, geliştirme ekibinizin deneyimine ve güvenlik konusunda ne kadar kontrol sahibi olmak istediğinize bağlıdır. Ancak her durumda, güvenlik birincil öncelik olmalıdır. ## Flask Uygulamalarında Temel Güvenlik Kurulumu Flask uygulamanızın temel güvenlik katmanlarını oluşturmak, ilk adımdır. Bu bölümde, 2026'da güncel Flask 2.x sürümü ile bir uygulamanın nasıl güvenli bir şekilde başlatılacağını ve temel güvenlik eklentilerinin nasıl entegre edileceğini göreceğiz. ### 1. Sanal Ortam Oluşturma ve Flask Kurulumu Güvenli bir başlangıç için her zaman izole bir sanal ortam kullanın ve bağımlılıkları `requirements.txt` dosyasına sabitleyin. ```bash # Sanal ortam oluşturma python3 -m venv venv # Sanal ortamı etkinleştirme source venv/bin/activate # Linux/macOS # venv\Scripts\activate # Windows # Flask ve güvenlik eklentilerini kurma pip install Flask Flask-WTF Flask-Login Flask-SQLAlchemy python-dotenv # Bağımlılıkları sabitleme pip freeze > requirements.txt ``` ### 2. Temel Flask Uygulaması ve Güvenlik Ayarları `app.py` dosyanızı oluştururken `SECRET_KEY` gibi kritik yapılandırmaları ortam değişkenlerinden okuyun. Bu, 2026'da hala en iyi pratiklerden biridir. ```python # app.py import os from flask import Flask, session from dotenv import load_dotenv # .env dosyasını yükle (production'da ortam değişkenleri kullanılmalı) load_dotenv() app = Flask(__name__) # Kritik güvenlik ayarları app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', 'default_insecure_secret_key_change_me') # Mutlaka güçlü bir anahtar kullanın! app.config['SESSION_COOKIE_SECURE'] = True # Yalnızca HTTPS üzerinden çerez gönder app.config['SESSION_COOKIE_HTTPONLY'] = True # JavaScript erişimini engelle app.config['SESSION_COOKIE_SAMESITE'] = 'Lax' # CSRF koruması için SameSite ayarı @app.route('/') def index(): if 'visits' not in session: session['visits'] = 1 else: session['visits'] += 1 return f"Merhaba, Flask! Bu sayfayı {session['visits']} kez ziyaret ettiniz." if __name__ == '__main__': app.run(debug=True, ssl_context='adhoc') # Geliştirme için HTTPS, production için ters proxy ``` `.env` dosyanız: ``` SECRET_KEY=super_guclu_gizli_anahtar_buraya_gelmeli_2026 ``` > **Pro Tip:** `SECRET_KEY` asla versiyon kontrol sistemine (Git gibi) yüklenmemeli ve production ortamında `os.environ` üzerinden güvenli bir şekilde sağlanmalıdır. `ssl_context='adhoc'` sadece geliştirme içindir; production'da Nginx veya Apache gibi bir ters proxy ile HTTPS sonlandırması yapılmalıdır. ## Flask Güvenliğinde Yaygın Senaryolar ve Örnekler Flask uygulamalarınızı geliştirirken karşılaşacağınız en yaygın güvenlik senaryolarına karşı nasıl önlem alacağınızı pratik örneklerle ele alalım. 2026'da hala geçerli olan bu zafiyetlere karşı dikkatli olmak, uygulamalarınızın dayanıklılığını artıracaktır. ### 1. Cross-Site Request Forgery (CSRF) Koruması **Problem:** Saldırgan, kullanıcının oturum açtığı bir web sitesinde, kullanıcının bilgisi dışında istek göndermesini sağlayabilir. Bu, kullanıcı adına istenmeyen eylemler gerçekleştirmesine yol açar. **Çözüm:** Flask-WTF kütüphanesinin sağladığı CSRF korumasını kullanmak en yaygın ve etkili yöntemdir. Flask-WTF, formlara otomatik olarak bir CSRF token'ı ekler ve her istekte bu token'ı doğrular. ```python # app.py (devamı) from flask_wtf import CSRFProtect from flask_wtf.csrf import CSRFError from flask import render_template, request, flash, redirect, url_for from flask_login import current_user, login_required from wtforms import StringField, SubmitField from wtforms.validators import DataRequired from flask_wtf import FlaskForm # ... (app tanımı ve config kısmı) csrf = CSRFProtect(app) # Örnek bir form class MyForm(FlaskForm): name = StringField('Adınız', validators=[DataRequired()]) submit = SubmitField('Gönder') @app.route('/submit_data', methods=['GET', 'POST']) @login_required # Kullanıcının giriş yapmış olması gerek def submit_data(): form = MyForm() if form.validate_on_submit(): flash(f'Veri başarıyla alındı: {form.name.data}', 'success') return redirect(url_for('index')) return render_template('submit_form.html', form=form) # CSRF Hata İşleyicisi @app.errorhandler(CSRFError) def handle_csrf_error(e): flash(f'CSRF hatası: {e.description}', 'danger') return render_template('csrf_error.html', reason=e.description), 400 # templates/submit_form.html #

# {{ form.csrf_token }} # {{ form.name.label }} {{ form.name() }} # {{ form.submit() }} #

``` ### 2. Cross-Site Scripting (XSS) Önleme **Problem:** Saldırgan, web uygulamasına kötü niyetli script'ler enjekte ederek kullanıcıların tarayıcılarında çalıştırabilir. Bu, oturum çalma, veri manipülasyonu gibi sonuçlar doğurabilir. **Çözüm:** Jinja2 şablon motoru, varsayılan olarak HTML çıktısını otomatik olarak escape eder (kaçış karakterlerine dönüştürür). Bu, çoğu XSS saldırısını engeller. Ancak, `Markup` veya `|safe` filtresini dikkatli kullanmalısınız. ```python # app.py (XSS örneği) from markupsafe import Markup @app.route('/greet') def greet(): user_input = request.args.get('name', 'Dünya') # Kötü örnek: user_input'ı güvenli hale getirmeden kullanmak # return f"

Merhaba, {user_input}!

" # Güvenli örnek: Jinja2 otomatik olarak escape eder # templates/greet.html içinde {{ name }} kullanmak yeterli return render_template('greet.html', name=user_input) @app.route('/unsafe_html') def unsafe_html(): # Bu şekilde kullanıcıdan gelen HTML'i doğrudan render etmek tehlikelidir # Saldırgan: unsafe_content = request.args.get('content', 'Güvenli İçerik') # Eğer bu content'i doğrudan {{ content|safe }} olarak render ederseniz XSS'e açıksınız. # Sadece güvenilir kaynaklardan gelen HTML için |safe kullanın. return render_template('unsafe.html', content=Markup(unsafe_content)) # Markup ile bilinçli olarak işaretleme ``` ```html

Merhaba, {{ name }}!

``` ```html

Bu içerik bilinçli olarak güvenli olmadan render edildi (SADECE GÖSTERİM AMAÇLI):

Asla kullanıcıdan gelen veriyi doğrudan 'safe' olarak işaretlemeyin.

``` ### 3. SQL Injection Önleme **Problem:** Saldırgan, SQL sorgularına kötü niyetli SQL kodları enjekte ederek veritabanına yetkisiz erişim sağlayabilir, verileri manipüle edebilir veya silebilir. **Çözüm:** Flask-SQLAlchemy gibi bir ORM (Object-Relational Mapper) kullanmak, parametreleştirilmiş sorgular sayesinde SQL Injection'ı büyük ölçüde engeller. Ham SQL sorguları kullanmaktan kaçının veya kullanmak zorundaysanız, parametre bağlama yöntemlerini kullanın. ```python # app.py (SQL Injection örneği) from flask_sqlalchemy import SQLAlchemy from sqlalchemy.exc import SQLAlchemyError # ... (app tanımı ve config kısmı) app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db' app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False db = SQLAlchemy(app) class User(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), unique=True, nullable=False) email = db.Column(db.String(120), unique=True, nullable=False) def __repr__(self): return f'' # Veritabanını oluştur (sadece bir kez çalıştırın) with app.app_context(): db.create_all() if not User.query.filter_by(username='admin').first(): admin_user = User(username='admin', email='admin@example.com') db.session.add(admin_user) db.session.commit() @app.route('/search_user') def search_user(): search_term = request.args.get('q', '') try: # Güvenli yaklaşım: ORM ve parametreleştirilmiş sorgu users = User.query.filter(User.username.like(f'%{search_term}%')).all() user_list = [u.username for u in users] return f"Kullanıcılar: {', '.join(user_list)}" except SQLAlchemyError as e: app.logger.error(f"Veritabanı hatası: {e}") flash('Bir hata oluştu, lütfen daha sonra tekrar deneyin.', 'danger') return "Bir hata oluştu.", 500 # Kötü örnek (SQL Injection'a açık): # @app.route('/unsafe_search') # def unsafe_search(): # search_term = request.args.get('q', '') # # ASLA bu şekilde ham SQL sorgusu kullanmayın! # # query = f"SELECT * FROM user WHERE username LIKE '%{search_term}%'" # # result = db.session.execute(query).fetchall() # # ... # return "Bu yol kasıtlı olarak devre dışı bırakıldı." ``` ### 4. Güvenli Cookie Yönetimi **Problem:** Oturum çerezleri (session cookies) veya diğer hassas çerezler, uygun güvenlik ayarları olmadan çalınabilir veya manipüle edilebilir. **Çözüm:** Çerezleri `Secure`, `HttpOnly` ve `SameSite` bayraklarıyla yapılandırarak güvenliklerini artırın. Flask'ın session mekanizması bu ayarları `app.config` üzerinden destekler. ```python # app.py (devamı, config'de zaten tanımlanmıştı) # app.config['SESSION_COOKIE_SECURE'] = True # Yalnızca HTTPS üzerinden çerez gönder # app.config['SESSION_COOKIE_HTTPONLY'] = True # JavaScript erişimini engelle # app.config['SESSION_COOKIE_SAMESITE'] = 'Lax' # CSRF koruması için SameSite ayarı # Ek olarak, çerezlerin süresini de belirleyebilirsiniz. app.config['PERMANENT_SESSION_LIFETIME'] = 3600 # 1 saat (saniye cinsinden) @app.route('/login', methods=['POST']) def login(): username = request.form['username'] password = request.form['password'] # Kullanıcı doğrulama mantığı buraya gelir if username == 'test' and password == 'password': # SADECE ÖRNEK! session['logged_in'] = True session.permanent = True # Oturumun PERMANENT_SESSION_LIFETIME boyunca kalmasını sağlar flash('Başarıyla giriş yapıldı!', 'success') return redirect(url_for('index')) flash('Kullanıcı adı veya şifre hatalı.', 'danger') return redirect(url_for('index')) ``` ## İleri Seviye Flask Güvenlik Teknikleri Uygulamanız büyüdükçe veya daha hassas verilerle çalıştıkça, temel güvenlik önlemleri yeterli olmayabilir. Bu bölümde, 2026'nın ileri seviye Flask güvenlik tekniklerini ele alacağız. ### 1. JSON Web Token (JWT) ile API Güvenliği API'ler için oturum çerezleri yerine JWT kullanmak yaygın bir pratik haline gelmiştir. `Flask-JWT-Extended` kütüphanesi, Flask'ta JWT entegrasyonunu kolaylaştırır. ```bash pip install Flask-JWT-Extended ``` ```python # app_jwt.py import os from datetime import timedelta from flask import Flask, request, jsonify from flask_jwt_extended import create_access_token, jwt_required, JWTManager, get_jwt_identity from dotenv import load_dotenv load_dotenv() app = Flask(__name__) app.config['JWT_SECRET_KEY'] = os.environ.get('JWT_SECRET_KEY', 'super_secret_jwt_key_2026') # Güçlü bir anahtar kullanın app.config['JWT_ACCESS_TOKEN_EXPIRES'] = timedelta(hours=1) # Token ömrü jwt = JWTManager(app) # Kullanıcı doğrulama (basit örnek) def authenticate_user(username, password): if username == 'burak' and password == 'sifre123': return {'id': 1, 'username': 'burak'} return None @app.route('/login_api', methods=['POST']) def login_api(): username = request.json.get('username', None) password = request.json.get('password', None) user = authenticate_user(username, password) if not user: return jsonify({'msg': 'Kullanıcı adı veya şifre hatalı'}), 401 access_token = create_access_token(identity=user['username']) return jsonify(access_token=access_token) @app.route('/protected', methods=['GET']) @jwt_required() def protected(): current_user_identity = get_jwt_identity() return jsonify(logged_in_as=current_user_identity), 200 if __name__ == '__main__': app.run(debug=True, port=5001) ``` ### 2. OAuth 2.0 ve OpenID Connect Entegrasyonu Harici kimlik sağlayıcıları (Google, Facebook, GitHub vb.) ile kimlik doğrulama için OAuth 2.0 ve OpenID Connect standartlarını kullanmak, kendi kullanıcı yönetim sisteminizi geliştirmekten daha güvenli olabilir. `Authlib` kütüphanesi bu entegrasyonu kolaylaştırır. ```bash pip install Authlib ``` ```python # app_oauth.py (basitleştirilmiş örnek) import os from flask import Flask, url_for, redirect, session, jsonify from authlib.integrations.flask_client import OAuth from dotenv import load_dotenv load_dotenv() app = Flask(__name__) app.secret_key = os.environ.get('SECRET_KEY', 'oauth_secret_key_2026') oauth = OAuth(app) oauth.register( name='google', client_id=os.environ.get('GOOGLE_CLIENT_ID'), client_secret=os.environ.get('GOOGLE_CLIENT_SECRET'), access_token_url='https://oauth2.googleapis.com/token', access_token_params=None, authorize_url='https://accounts.google.com/o/oauth2/auth', authorize_params=None, api_base_url='https://www.googleapis.com/oauth2/v1/', client_kwargs={'scope': 'openid email profile'} ) @app.route('/login/google') def login_google(): redirect_uri = url_for('authorize_google', _external=True) return oauth.google.authorize_redirect(redirect_uri) @app.route('/authorize/google') def authorize_google(): token = oauth.google.authorize_access_token() userinfo = oauth.google.get('userinfo').json() session['user'] = userinfo return redirect('/') @app.route('/logout') def logout(): session.pop('user', None) return redirect('/') @app.route('/') def index_oauth(): user = session.get('user') if user: return f"

Merhaba, {user['name']}!

Çıkış Yap

" return '

Lütfen Google ile giriş yapın

Google ile Giriş Yap

' if __name__ == '__main__': app.run(debug=True, port=5002) ``` ### 3. Rate Limiting (Hız Sınırlama) **Problem:** Brute-force saldırıları, hizmet reddi (DoS) saldırıları veya aşırı kaynak tüketimi, uygulamanızın performansını ve güvenliğini tehdit edebilir. **Çözüm:** `Flask-Limiter` kütüphanesi ile belirli uç noktalara veya genel olarak uygulamaya hız sınırlamaları getirebilirsiniz. ```bash pip install Flask-Limiter ``` ```python # app_rate_limit.py from flask import Flask, jsonify from flask_limiter import Limiter from flask_limiter.util import get_remote_address app = Flask(__name__) # IP adresine göre hız sınırlama limiter = Limiter( get_remote_address, app=app, default_limits=["200 per day", "50 per hour"], storage_uri="memory://", # Production için Redis/Memcached kullanın ) @app.route('/slow') @limiter.limit("1 per minute") # Bu endpoint'e dakikada 1 istek sınırı def slow_endpoint(): return jsonify(message="Bu yavaş bir endpoint.") @app.route('/fast') def fast_endpoint(): return jsonify(message="Bu hızlı bir endpoint.") if __name__ == '__main__': app.run(debug=True, port=5003) ``` ## Flask Güvenliği Best Practices & Anti-Patterns 10+ yıllık deneyimimle, Flask uygulamalarının güvenliğini sağlarken dikkat edilmesi gereken en kritik noktaları ve kaçınılması gereken anti-pattern'ları aşağıda listeledim. 2026'da hala geçerli olan bu kurallara uymak, uygulamanızın siber saldırılara karşı direncini artıracaktır. - **✅ Ortam Değişkenleri Kullanın:** Hassas bilgileri (veritabanı şifreleri, API anahtarları, `SECRET_KEY`) doğrudan kod içine yazmak yerine, `python-dotenv` veya sistem ortam değişkenleri aracılığıyla yükleyin. Bu, production ortamında kritik verilerin açıkta kalmasını engeller. - **❌ Debug Modunu Production'da Açmayın:** `app.run(debug=True)` asla production ortamında kullanılmamalıdır. Debug modu, hata mesajlarında hassas bilgileri ifşa edebilir ve uzaktan kod yürütme zafiyetlerine yol açabilir. - **✅ Bağımlılıkları Düzenli Güncelleyin:** `pip install -r requirements.txt` komutunu sık sık çalıştırın ve `pip-audit` gibi araçlarla bağımlılıklarınızdaki bilinen güvenlik açıklarını kontrol edin. Eski kütüphaneler, 2026'da hala en yaygın güvenlik vektörlerinden biridir. - **❌ Güvenilmeyen Veriyi Doğrudan Render Etmeyin:** Kullanıcıdan gelen veriyi (form girişleri, URL parametreleri) doğrudan HTML'e veya SQL sorgularına eklemeyin. Jinja2'nin otomatik kaçış özelliğine güvenin ve `|safe` filtresini sadece güvenli olduğunu bildiğiniz içerik için kullanın. - **✅ HTTPS Kullanımını Zorunlu Kılın:** Tüm iletişim kanallarını (özellikle kimlik doğrulama ve hassas veri transferi) HTTPS üzerinden şifreleyin. `SESSION_COOKIE_SECURE=True` ayarını mutlaka etkinleştirin ve bir ters proxy (Nginx, Apache) ile SSL/TLS sonlandırması yapın. - **❌ Varsayılan Hata Sayfalarını Kullanmayın:** Flask'ın varsayılan hata sayfaları, saldırganlara sisteminiz hakkında ipuçları verebilir. Özel 404, 500 gibi hata sayfaları oluşturarak hem kullanıcı deneyimini iyileştirin hem de bilgi sızıntısını engelleyin. - **✅ Güçlü Kimlik Doğrulama ve Yetkilendirme Uygulayın:** `Flask-Login` veya `Flask-JWT-Extended` gibi kütüphaneleri kullanarak güçlü şifre politikaları, çok faktörlü kimlik doğrulama (MFA) ve rol tabanlı erişim kontrolü (RBAC) uygulayın. Şifreleri asla düz metin olarak saklamayın, bcrypt gibi güçlü hash algoritmaları kullanın. - **❌ Güvenlik Başlıklarını İhmal Etmeyin:** HTTP güvenlik başlıkları (Content-Security-Policy, X-XSS-Protection, X-Content-Type-Options, Strict-Transport-Security), tarayıcı tabanlı saldırıları önlemek için kritik öneme sahiptir. `Flask-Talisman` gibi bir kütüphane bu başlıkları kolayca eklemenizi sağlar. - **✅ Oturum Yönetimini Güvenli Yapın:** Oturum çerezlerini `HttpOnly`, `Secure` ve `SameSite=Lax/Strict` bayraklarıyla koruyun. Oturum sürelerini makul seviyelerde tutun ve kullanıcı çıkış yaptığında oturumu sunucu tarafında geçersiz kılın. - **❌ Uygulama Loglarını Göz Ardı Etmeyin:** Güvenlik olaylarını, başarısız giriş denemelerini ve anormal davranışları düzenli olarak loglayın. Bu logları merkezi bir sisteme göndererek izleyin ve olası saldırıları erken tespit edin. Loglarda hassas bilgi tutmaktan kaçının. ## Flask Güvenliğinde Yaygın Hatalar ve Çözümleri Flask geliştiricilerinin güvenlik konusunda en sık yaptığı hatalar ve bu hatalardan kaçınma yolları. 2026'da bile bu hatalarla karşılaşmak mümkün. ### 1. Hata: `SECRET_KEY`'in Koda Hard-Code Edilmesi **Problem:** Geliştiriciler, `app.config['SECRET_KEY'] = 'my_secret_key'` gibi hassas bir anahtarı doğrudan `app.py` dosyasına yazar ve bu kodu versiyon kontrolüne yükler. **Sebep:** Kolaylık, ortam değişkenleri hakkında bilgi eksikliği veya `SECRET_KEY`'in öneminin göz ardı edilmesi. **Çözüm:** `SECRET_KEY`'i ortam değişkenlerinden okuyun. `python-dotenv` geliştirme ortamında yardımcı olabilir, ancak production'da sistem ortam değişkenlerini kullanın. ```python # Doğru Çözüm import os from dotenv import load_dotenv load_dotenv() app.config['SECRET_KEY'] = os.environ.get('SECRET_KEY', 'fallback_for_dev_only') ``` ### 2. Hata: Jinja2 `|safe` Filtresinin Yanlış Kullanımı **Problem:** Kullanıcıdan gelen verileri (örneğin bir yorum alanı) `{{ user_input|safe }}` şeklinde şablona doğrudan enjekte etmek. **Sebep:** İçeriğin HTML olarak render edilmek istenmesi veya XSS riskinin farkında olunmaması. **Çözüm:** Jinja2 varsayılan olarak tüm içeriği escape eder, bu nedenle `|safe` filtresini sadece güvenilir ve temizlenmiş HTML içeriği için kullanın. Kullanıcıdan gelen içeriği göstermeden önce bir HTML temizleme kütüphanesi (örneğin `Bleach`) ile temizleyin. ```python # app.py import bleach @app.route('/display_comment') def display_comment(): raw_comment = request.args.get('comment', ' Harika!') # Güvenli temizleme clean_comment = bleach.clean(raw_comment, tags=['b', 'i', 'em', 'strong'], attributes={}, strip=True) return render_template('comment.html', comment=clean_comment) # templates/comment.html #

{{ comment|safe }}

``` ### 3. Hata: Varsayılan Güvenlik Başlıklarının Eksikliği **Problem:** Uygulama, Content-Security-Policy (CSP), X-XSS-Protection gibi HTTP güvenlik başlıklarını göndermiyor. **Sebep:** Bu başlıkların önemi veya nasıl ekleneceği hakkında bilgi eksikliği. **Çözüm:** `Flask-Talisman` gibi bir kütüphane kullanarak veya manuel olarak `after_request` ile bu başlıkları ekleyin. ```bash pip install Flask-Talisman ``` ```python # app.py from flask_talisman import Talisman # ... (app tanımı) # Talisman'ı etkinleştir Talisman(app, content_security_policy={ # 2026 için güncel ve sıkı bir CSP 'default-src': "'self'", 'script-src': ["'self'", "'unsafe-inline'", 'https://cdnjs.cloudflare.com'], # Örnek 'style-src': ["'self'", "'unsafe-inline'", 'https://fonts.googleapis.com'], 'img-src': ["'self'", 'data:'], 'object-src': "'none'", 'frame-ancestors': "'none'", }) # veya manuel olarak (daha zahmetli) # @app.after_request # def add_security_headers(response): # response.headers['X-Frame-Options'] = 'DENY' # response.headers['X-Content-Type-Options'] = 'nosniff' # response.headers['X-XSS-Protection'] = '1; mode=block' # return response ``` ## Flask Uygulama Güvenliği Test ve İzleme Uygulamanızı güvenli bir şekilde geliştirmek kadar, mevcut güvenlik açıklarını tespit etmek ve izlemek de önemlidir. 2026'da güvenlik testleri ve izleme araçları, DevOps süreçlerinin ayrılmaz bir parçası haline gelmiştir. ### 1. Güvenlik Denetimi (Auditing) ve Tarama Araçları * **Bağımlılık Tarayıcıları:** `pip-audit`, `safety` gibi araçlarla `requirements.txt` dosyanızdaki bilinen güvenlik açıklarını düzenli olarak tarayın. ```bash pip install pip-audit pip-audit ``` * **Statik Kod Analizi (SAST):** `Bandit` gibi Python SAST araçları, kodunuzdaki potansiyel güvenlik açıklarını (örneğin, zayıf şifreleme, SQL injection riskleri) otomatik olarak tespit edebilir. ```bash pip install bandit bandit -r . # Proje dizinini tara ``` * **Dinamik Uygulama Güvenliği Testi (DAST):** `OWASP ZAP` veya `Burp Suite` gibi proxy tabanlı araçlar, çalışan uygulamanızı tarayarak bilinen zafiyetleri (XSS, SQLi, CSRF) bulmaya çalışır. ### 2. Penetrasyon Testleri (PenTest) Uygulamanızın production'a çıkmadan önce veya kritik güncellemelerden sonra, profesyonel penetrasyon testleri yaptırmak, gerçek dünya saldırılarına karşı ne kadar dirençli olduğunuzu gösterir. Bu testler, otomatik araçların bulamadığı mantık hatalarını ve karmaşık zafiyetleri ortaya çıkarır. ### 3. Güvenlik İzleme ve Olay Yönetimi (SIEM) Uygulamanızın loglarını (erişim logları, hata logları, güvenlik logları) merkezi bir SIEM (Security Information and Event Management) sistemine (örneğin ELK Stack, Splunk) göndererek anormal aktiviteleri, başarısız giriş denemelerini veya yetkisiz erişim girişimlerini gerçek zamanlı olarak izleyin. Anında uyarı sistemleri kurarak olası saldırılara hızlıca müdahale edin. ## Güvenli Bir Flask API Geliştirme Projesi Bu bölümde, Flask 2.x kullanarak basit ama güvenli bir RESTful API oluşturacağız. Proje, kullanıcı kaydı, giriş ve korumalı bir kaynağa erişim işlevlerini içerecek ve JWT ile güvenliği sağlayacaktır. Bu mini proje, yukarıda bahsedilen güvenlik pratiklerini bir araya getirecektir. ### Proje Yapısı ``` flask_secure_api/ ├── venv/ ├── .env ├── app.py ├── models.py ├── requirements.txt ``` ### `requirements.txt` ``` Flask==2.3.3 # 2026 itibarıyla güncel bir sürüm varsayımı Flask-SQLAlchemy Flask-JWT-Extended python-dotenv Werkzeug==2.3.7 # Flask'ın bağımlılığı passlib # Şifre hash'leme için ``` ```bash pip install -r requirements.txt ``` ### `.env` ``` SECRET_KEY=super_guclu_gizli_anahtar_buraya_gelmeli_2026_api JWT_SECRET_KEY=cok_daha_guclu_jwt_anahtari_2026 ``` ### `models.py` ```python from app import db from passlib.hash import pbkdf2_sha256 class User(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), unique=True, nullable=False) password_hash = db.Column(db.String(128), nullable=False) def __init__(self, username, password): self.username = username self.password_hash = self.hash_password(password) def hash_password(self, password): return pbkdf2_sha256.hash(password) def verify_password(self, password): return pbkdf2_sha256.verify(password, self.password_hash) def to_dict(self): return {'id': self.id, 'username': self.username} def __repr__(self): return f'' ``` ### `app.py` ```python import os from datetime import timedelta from flask import Flask, request, jsonify from