Python’da Kullanıcı Girişi Doğrulama: Güvenli Bir Kapı İnşa Etmek

Python’da Kullanıcı Girişi Doğrulama: Güvenli Bir Kapı İnşa Etmek

Web uygulamalarından mobil uygulamalara, masaüstü yazılımlarından API’lere kadar, neredeyse her yazılım sisteminin kullanıcıdan girdi alması kaçınılmazdır. Ancak bu girdilere körü körüne güvenmek, uygulamanız için felaketle sonuçlanabilecek güvenlik açıkları, veri bozulmaları ve kötü kullanıcı deneyimleri yaratabilir. Peki, Python ile sağlam ve güvenilir bir “doğrulama kapısı” inşa ederek bu riskleri nasıl bertaraf edebiliriz?

Neden Kullanıcı Girişini Asla Doğrudan Kabul Etmemelisiniz?

Kullanıcı girdisi, bir yazılım sistemine dışarıdan gelen her türlü veridir. Bu, bir web formundaki metin kutusu, bir API çağrısındaki JSON yükü, hatta bir dosya yüklemesi bile olabilir. Bu girdilerin her biri, potansiyel bir tehdit veya sorun kaynağıdır. Uygulamanızın güvenlik duvarı, kullanıcıdan gelen verilere karşı her zaman tetikte olmalıdır. Bu, sadece kötü niyetli saldırganları engellemekle kalmaz, aynı zamanda yanlışlıkla girilen hatalı verilerin sisteminize zarar vermesini de önler.

Güvenilmeyen kullanıcı girdisi, bir dizi ciddi probleme yol açabilir. En bilinen risklerden biri, SQL Enjeksiyonu (SQL Injection)‘dur. Saldırganlar, veritabanı sorgularınıza kötü amaçlı kod parçacıkları ekleyerek hassas verilere erişebilir, değiştirebilir veya silebilirler. Örneğin, bir giriş formuna kullanıcı adı yerine ' OR '1'='1 gibi bir ifade girerek, şifre kontrolünü atlayıp sisteme izinsiz giriş yapabilirler. Benzer şekilde, Siteler Arası Komut Dosyası Çalıştırma (Cross-Site Scripting – XSS) saldırıları, saldırganların kullanıcıların tarayıcılarında kötü amaçlı JavaScript kodları çalıştırmasına olanak tanır. Bu, çerez hırsızlığına, oturum kaçırmaya veya kullanıcıları kötü amaçlı sitelere yönlendirmeye neden olabilir. Bu tür saldırılar, genellikle kullanıcıdan alınan ve yeterince temizlenmeden (sanitize edilmeden) veya doğrulanmadan (validate edilmeden) doğrudan HTML içeriğine yerleştirilen girdiler aracılığıyla gerçekleşir.

Güvenlik risklerinin yanı sıra, veri bütünlüğü (data integrity) de büyük bir endişe kaynağıdır. Eğer bir yaş alanı için sayısal bir değer beklerken metinsel bir girdi alırsanız, bu durum uygulamanızda çalışma zamanı hatalarına (runtime errors) yol açabilir. Veritabanınıza yanlış formatta veya geçersiz aralıkta veriler kaydedilmesi, ileride raporlama, analiz veya diğer iş süreçlerinde ciddi tutarsızlıklara neden olabilir. Örneğin, bir e-ticaret uygulamasında ürün fiyatına negatif bir değer girilmesi, envanter yönetimini veya finansal raporları tamamen bozabilir. Bu tür durumlar, sadece teknik sorunlar yaratmakla kalmaz, aynı zamanda iş süreçlerinizi aksatarak maddi kayıplara ve müşteri memnuniyetsizliğine yol açabilir. Bu nedenle, kullanıcı girdisini sadece güvenlik açısından değil, aynı zamanda sistemin genel sağlığı ve veri kalitesi açısından da titizlikle doğrulamak hayati öneme sahiptir.

Veri Doğrulama (Data Validation) Nedir ve Neden Hayati Önem Taşır?

Veri doğrulama, bir yazılım sistemine giren verilerin belirli kurallara, standartlara veya kısıtlamalara uygun olup olmadığını kontrol etme sürecidir. Basitçe ifade etmek gerekirse, sisteminize giren her bir veri parçasının “geçerli” olup olmadığını anlamaktır. Bu “geçerlilik”, verinin türünden (sayı, metin, tarih vb.) değer aralığına, formatından (e-posta adresi, telefon numarası) iş mantığına (bir ürünün fiyatı negatif olamaz) kadar geniş bir yelpazeyi kapsayabilir. Doğrulama, uygulamanızın kalitesi, güvenliği ve kararlılığı için birincil savunma hattıdır.

Doğrulama, sadece kötü niyetli saldırıları engellemekle kalmaz, aynı zamanda istem dışı hataları da yakalar. Bir kullanıcı yanlışlıkla bir metin alanına sayısal bir değer girmeye çalıştığında veya bir tarih alanına geçersiz bir tarih formatı girdiğinde, doğrulama mekanizması devreye girerek bu hatayı tespit eder ve kullanıcıya anlamlı bir geri bildirim sunar. Bu, hem uygulamanın çökmesini engeller hem de kullanıcı deneyimini iyileştirir. Kullanıcılar, hatalarını anında görüp düzeltebildiklerinde, uygulamayı daha verimli ve sorunsuz bir şekilde kullanabilirler.

Veri doğrulamanın temel faydalarını şu şekilde özetleyebiliriz:

• Güvenlik: SQL Enjeksiyonu, XSS gibi saldırıları önleyerek uygulamanızı ve verilerinizi korur.
• Veri Bütünlüğü: Veritabanınıza yalnızca doğru ve tutarlı verilerin kaydedilmesini sağlar, bu da raporlama ve analiz süreçlerinin güvenilirliğini artırır.
• Uygulama Kararlılığı: Geçersiz girdilerden kaynaklanan çalışma zamanı hatalarını ve çökmeleri minimize eder.
• Kullanıcı Deneyimi: Kullanıcılara hataları hakkında anında geri bildirim sağlayarak, veri girişini kolaylaştırır ve hayal kırıklığını azaltır.
• İş Mantığı Uyumluluğu: İş kurallarınızın (örneğin, “yaş 18’den küçük olamaz” veya “sipariş miktarı 0’dan büyük olmalı”) sistem tarafından doğru bir şekilde uygulanmasını sağlar.

Bir “doğrulama kapısı” inşa etmek, uygulamanızın her giriş noktasında bu kontrolleri sistematik bir şekilde uygulamanız anlamına gelir. Bu kapı, gelen tüm verileri titizlikle inceler, geçerli olanları içeri alır ve geçersiz olanları reddederek uygun hata mesajları ile geri çevirir. Bu yaklaşım, uygulamanızın temelinden itibaren sağlam ve güvenilir olmasını sağlar.

Python’da Temel Doğrulama Teknikleri: Basit Girişleri Nasıl Güvenli Hale Getiririz?

Python, kullanıcı girdilerini doğrulamak için çeşitli yerleşik (built-in) fonksiyonlar ve yöntemler sunar. Bu temel teknikler, karmaşık doğrulama kütüphanelerine geçmeden önce uygulayabileceğiniz ilk savunma hattını oluşturur. Basit kontrollerle başlayarak, uygulamanızın güvenlik seviyesini önemli ölçüde artırabilirsiniz.

1. Tür Kontrolü (Type Checking): Python’da bir değişkenin beklenen türde olup olmadığını kontrol etmek için isinstance() fonksiyonunu kullanabilirsiniz. Bu, özellikle bir API’den veya bir formdan gelen verilerin doğru veri tipinde olduğundan emin olmak için önemlidir.

def dogrula_yas(yas_girisi):
    if not isinstance(yas_girisi, int):
        raise TypeError("Yaş değeri bir tam sayı olmalıdır.")
    if yas_girisi < 0 or yas_girisi > 120:
        raise ValueError("Yaş 0 ile 120 arasında olmalıdır.")
    return yas_girisi

try:
    gecerli_yas = dogrula_yas(30)
    print(f"Geçerli yaş: {gecerli_yas}")
    # gecersiz_yas = dogrula_yas("otuz") # TypeError fırlatır
    # gecersiz_yas_aralik = dogrula_yas(150) # ValueError fırlatır
except (TypeError, ValueError) as e:
    print(f"Hata: {e}")
  

Yukarıdaki örnekte, dogrula_yas fonksiyonu hem tür kontrolü hem de değer aralığı kontrolü yaparak yaş girdisinin geçerliliğini denetler.

2. Metin İşleme ve Temizleme (String Manipulation and Sanitization): Kullanıcıdan gelen metin girdileri genellikle boşluklar, büyük/küçük harf tutarsızlıkları veya özel karakterler içerebilir. Python’ın string metotları bu tür sorunları gidermek için çok kullanışlıdır.

• strip(): Bir metnin başındaki ve sonundaki boşlukları kaldırır.
• lower() / upper(): Metni tamamen küçük veya büyük harfe dönüştürür, bu da karşılaştırmaları tutarlı hale getirir.
• isdigit() / isalpha() / isalnum(): Bir metnin sadece rakamlardan, harflerden veya hem harf hem de rakamlardan oluşup oluşmadığını kontrol eder.

def dogrula_kullanici_adi(kullanici_adi_girisi):
    kullanici_adi_temiz = kullanici_adi_girisi.strip().lower()
    if not kullanici_adi_temiz.isalnum():
        raise ValueError("Kullanıcı adı sadece harf ve rakam içermelidir.")
    if len(kullanici_adi_temiz) < 3 or len(kullanici_adi_temiz) > 20:
        raise ValueError("Kullanıcı adı 3 ile 20 karakter arasında olmalıdır.")
    return kullanici_adi_temiz

try:
    gecerli_ad = dogrula_kullanici_adi("  Mehmet123  ")
    print(f"Geçerli kullanıcı adı: {gecerli_ad}")
    # gecersiz_ad_karakter = dogrula_kullanici_adi("Ali@") # ValueError fırlatır
    # gecersiz_ad_uzunluk = dogrula_kullanici_adi("a") # ValueError fırlatır
except ValueError as e:
    print(f"Hata: {e}")
  

Bu örnek, kullanıcı adını temizler, sadece alfanümerik karakterlerden oluşup oluşmadığını ve belirli bir uzunluk aralığında olup olmadığını kontrol eder. Bu tür basit kontroller, birçok yaygın hatayı ve güvenlik zafiyetini önlemek için yeterli olabilir. Ancak daha karmaşık desenler ve formatlar için düzenli ifadelere (Regex) ihtiyacımız olacaktır.

Regex (Düzenli İfadeler) ile Güçlü Doğrulama: Karmaşık Desenleri Nasıl Yakalarız?

Basit string metotları belirli durumlar için yeterli olsa da, e-posta adresleri, telefon numaraları, güçlü şifreler veya belirli bir formatta ürün kodları gibi karmaşık desenlere sahip girdileri doğrulamak için Düzenli İfadeler (Regular Expressions – Regex) vazgeçilmez bir araçtır. Python’ın yerleşik re modülü, regex kullanımını kolaylaştırır.

Regex, metin içinde belirli arama desenlerini tanımlamanıza olanak tanıyan güçlü bir dildir. Bir desen tanımladıktan sonra, bir metnin bu desene uyup uymadığını kontrol edebilirsiniz. İşte bazı yaygın kullanım senaryoları:

• E-posta Adresi Doğrulama: E-posta adreslerinin belirli bir formatı vardır (kullanıcı@alanadı.uzantı). Regex ile bu formatı kolayca kontrol edebilirsiniz.
• Telefon Numarası Doğrulama: Ülke kodları, alan kodları ve abone numaralarını içeren çeşitli telefon numarası formatlarını doğrulayabilirsiniz.
• Güçlü Şifre Politikaları: Şifrelerin en az bir büyük harf, bir küçük harf, bir rakam ve bir özel karakter içermesi gibi karmaşık kuralları Regex ile tanımlayabilirsiniz.
• URL Doğrulama: Bir metnin geçerli bir URL formatında olup olmadığını kontrol edebilirsiniz.

Örnek olarak, bir e-posta adresi doğrulama fonksiyonu oluşturalım:

import re

def dogrula_eposta(eposta_girisi):
    # Basit bir e-posta regex deseni
    # Daha kapsamlı desenler için internetten araştırma yapılabilir.
    eposta_deseni = r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
    
    if not re.match(eposta_deseni, eposta_girisi):
        raise ValueError("Geçersiz e-posta adresi formatı.")
    return eposta_girisi

try:
    gecerli_eposta = dogrula_eposta("ornek@domain.com")
    print(f"Geçerli e-posta: {gecerli_eposta}")
    
    # gecersiz_eposta_1 = dogrula_eposta("ornekdomain.com") # ValueError fırlatır
    # gecersiz_eposta_2 = dogrula_eposta("ornek@domain") # ValueError fırlatır
except ValueError as e:
    print(f"Hata: {e}")
  

Yukarıdaki kodda re.match() fonksiyonu, metnin başlangıcından itibaren desenle eşleşip eşleşmediğini kontrol eder. Eğer eşleşme yoksa, bir ValueError fırlatılır. Regex desenleri ilk bakışta karmaşık görünebilir, ancak pratikle ve çevrimiçi araçlarla (örneğin, regex101.com) kolayca öğrenilebilir ve test edilebilirler. Örneğin, bir şifrenin en az 8 karakter uzunluğunda olmasını, bir büyük harf, bir küçük harf, bir rakam ve bir özel karakter içermesini gerektiren daha karmaşık bir senaryo için şöyle bir desen kullanılabilir: "^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$". Bu tür desenler, güvenlik politikalarınızı kullanıcı girdilerine yansıtmanın etkili bir yoludur.

Harici Kütüphanelerle Doğrulama: Daha Güçlü ve Esnek Çözümler Mümkün mü?

Python’ın yerleşik özellikleri ve Regex, birçok doğrulama ihtiyacını karşılayabilirken, daha büyük ve karmaşık uygulamalarda, özellikle yapılandırılmış verilerle (JSON, form verileri) çalışırken, harici doğrulama kütüphaneleri iş akışınızı büyük ölçüde basitleştirebilir ve daha güçlü çözümler sunabilir. Bu kütüphaneler, genellikle veri şemalarını tanımlamanıza, otomatik hata mesajları üretmenize ve karmaşık iç içe geçmiş veri yapılarını kolayca doğrulamanıza olanak tanır.

Piyasada birçok popüler Python doğrulama kütüphanesi bulunmaktadır:

• Pydantic: Veri doğrulama ve ayarlar yönetimi için modern, Python type hints (tür ipuçları) tabanlı bir kütüphanedir. Hızlı, esnek ve kullanımı kolaydır. Özellikle FastAPI gibi modern web framework’lerinde yaygın olarak kullanılır.
• Marshmallow: Nesneleri seri hale getirmek (serialize) ve seri hale getirilmiş verileri geri dönüştürmek (deserialize) için kullanılan bir kütüphanedir. Doğrulama, bu sürecin bir parçası olarak doğal bir şekilde entegre edilmiştir.
• Cerberus: Esnek ve hafif bir doğrulama kütüphanesidir. Doğrulama kurallarını bir Python sözlüğü (dictionary) olarak tanımlamanıza izin verir.

Bu kütüphaneler arasında özellikle Pydantic, Python geliştiricileri arasında popülerliği hızla artan bir seçenektir. Tür ipuçlarını kullanarak veri modellerinizi tanımlamanıza ve bu modellerin otomatik olarak doğrulanmasını sağlamanıza olanak tanır. Hatalı veri geldiğinde, Pydantic detaylı hata mesajları ile birlikte bir ValidationError fırlatır.

Şimdi Pydantic kullanarak bir kullanıcı kayıt formunu (ad, e-posta, yaş, şifre) nasıl doğrulayacağımıza dair bir örnek inceleyelim:

from pydantic import BaseModel, Field, EmailStr, ValidationError
from typing import Optional

# Pydantic'i yüklemek için: pip install pydantic

class KullaniciKayitFormu(BaseModel):
    ad: str = Field(min_length=2, max_length=50, description="Kullanıcının adı")
    soyad: str = Field(min_length=2, max_length=50, description="Kullanıcının soyadı")
    eposta: EmailStr = Field(description="Kullanıcının geçerli e-posta adresi")
    yas: int = Field(ge=18, le=120, description="Kullanıcının yaşı, 18 ile 120 arasında olmalı")
    sifre: str = Field(min_length=8, description="En az 8 karakterli güvenli bir şifre")
    telefon: Optional[str] = Field(default=None, regex=r"^\+?\d{10,15}$", description="Telefon numarası (isteğe bağlı)")

# Örnek kullanım
veri = {
    "ad": "Ayşe",
    "soyad": "Yılmaz",
    "eposta": "ayse.yilmaz@ornek.com",
    "yas": 25,
    "sifre": "GucluSifre123!",
    "telefon": "+905321234567"
}

try:
    kullanici = KullaniciKayitFormu(**veri)
    print("Kullanıcı verileri başarıyla doğrulandı:")
    print(kullanici.model_dump_json(indent=2)) # Pydantic v2'de to_json yerine model_dump_json kullanılır
except ValidationError as e:
    print("Doğrulama hatası:")
    print(e.json(indent=2)) # Pydantic v2'de .json() metodu kullanılır
  

Bu örnekte, KullaniciKayitFormu adında bir Pydantic modeli tanımladık. Her alan için veri tipi (str, int, EmailStr), minimum/maksimum uzunluk (min_length, max_length), değer aralığı (ge – greater than or equal, le – less than or equal) ve hatta Regex desenleri (regex) gibi doğrulama kurallarını belirledik. EmailStr gibi özel Pydantic tipleri, e-posta formatını otomatik olarak doğrular. Veri, bu modele uygun değilse, Pydantic detaylı bir ValidationError fırlatır. Bu, özellikle büyük ve karmaşık veri yapılarıyla çalışırken hem kod tekrarını azaltır hem de doğrulama mantığını merkezi bir yerde tutarak yönetimi kolaylaştırır.

Gerçek Dünya Senaryoları ve Vaka Analizi: Bir Web Uygulamasında Doğrulama Kapısı Nasıl Kurulur?

Şimdiye kadar öğrendiğimiz doğrulama tekniklerini gerçek bir web uygulaması senaryosunda nasıl bir araya getireceğimizi inceleyelim. Diyelim ki bir e-ticaret platformunda yeni bir ürün ekleme işlevselliği geliştiriyorsunuz. Ürün bilgileri (ad, açıklama, fiyat, stok adedi, kategori) kullanıcıdan bir form aracılığıyla alınacak. Bu verilerin güvenli ve doğru bir şekilde işlenmesi kritik öneme sahiptir.

Bu senaryoda bir “doğrulama kapısı” inşa etmek için Pydantic gibi bir kütüphane kullanmak, hem kodun okunabilirliğini artıracak hem de doğrulama sürecini standartlaştıracaktır. Ayrıca, olası hataları yönetmek için özel bir hata işleme mekanizması da ekleyeceğiz.

from pydantic import BaseModel, Field, ValidationError
from typing import Optional

# Pydantic modeli ile ürün veri şemasını tanımlayalım
class UrunEklemeFormu(BaseModel):
    urun_adi: str = Field(min_length=3, max_length=100, description="Ürünün adı")
    aciklama: Optional[str] = Field(default=None, max_length=500, description="Ürünün detaylı açıklaması")
    fiyat: float = Field(gt=0, description="Ürünün fiyatı, sıfırdan büyük olmalı")
    stok_adedi: int = Field(ge=0, description="Ürünün stok adedi, sıfır veya daha büyük olmalı")
    kategori: str = Field(min_length=2, max_length=50, description="Ürünün kategorisi")
    barkod: Optional[str] = Field(default=None, regex=r"^\d{12,13}$", description="Ürünün 12 veya 13 haneli barkodu")

# Bir web uygulamasından (örneğin Flask veya Django'dan) geldiğini varsaydığımız giriş verisi
def urun_ekle(urun_verisi: dict):
    try:
        # Pydantic modeli ile veriyi doğrula ve parse et
        gecerli_urun = UrunEklemeFormu(**urun_verisi)
        
        # Doğrulama başarılı ise, veritabanına kaydetme veya başka işlemler yap
        print(f"Ürün '{gecerli_urun.urun_adi}' başarıyla doğrulandı ve işleniyor.")
        # Burada veritabanına kaydetme, stok güncelleme vb. işlemler yapılabilir.
        return {"mesaj": "Ürün başarıyla eklendi", "urun": gecerli_urun.model_dump()}
    except ValidationError as e:
        # Doğrulama hatası durumunda, detaylı hata mesajlarını döndür
        print("Ürün ekleme doğrulama hatası:")
        return {"hata": "Doğrulama başarısız", "detaylar": e.errors()}
    except Exception as e:
        # Diğer beklenmedik hatalar
        print(f"Beklenmedik bir hata oluştu: {e}")
        return {"hata": "Sunucu hatası", "detaylar": str(e)}

# Örnek kullanım senaryoları
print("--- Geçerli Ürün Ekleme ---")
gecerli_veri = {
    "urun_adi": "Akıllı Telefon X",
    "aciklama": "Son teknoloji özelliklere sahip akıllı telefon.",
    "fiyat": 999.99,
    "stok_adedi": 150,
    "kategori": "Elektronik",
    "barkod": "1234567890123"
}
sonuc = urun_ekle(gecerli_veri)
print(sonuc)

print("\n--- Geçersiz Fiyat ile Ürün Ekleme ---")
gecersiz_fiyat_veri = {
    "urun_adi": "Akıllı Telefon Y",
    "aciklama": "Yeni model akıllı telefon.",
    "fiyat": -100.00, # Geçersiz fiyat
    "stok_adedi": 50,
    "kategori": "Elektronik"
}
sonuc_fiyat_hatasi = urun_ekle(gecersiz_fiyat_veri)
print(sonuc_fiyat_hatasi)

print("\n--- Eksik Alan ile Ürün Ekleme ---")
eksik_alan_veri = {
    "urun_adi": "Akıllı Saat Z",
    "fiyat": 299.99,
    # "stok_adedi" eksik
    "kategori": "Giyilebilir Teknoloji"
}
sonuc_eksik_alan_hatasi = urun_ekle(eksik_alan_veri)
print(sonuc_eksik_alan_hatasi)

print("\n--- Geçersiz Barkod ile Ürün Ekleme ---")
gecersiz_barkod_veri = {
    "urun_adi": "Bluetooth Kulaklık",
    "fiyat": 149.99,
    "stok_adedi": 200,
    "kategori": "Aksesuar",
    "barkod": "ABC123456789" # Geçersiz barkod formatı
}
sonuc_barkod_hatasi = urun_ekle(gecersiz_barkod_veri)
print(sonuc_barkod_hatasi)
  

Bu vaka analizinde, UrunEklemeFormu Pydantic modeli, gelen JSON veya form verilerini otomatik olarak doğrular. Fiyatın sıfırdan büyük olması, stok adedinin sıfır veya daha fazla olması, ürün adının belirli bir uzunlukta olması gibi iş kuralları burada tanımlanır. Eğer gelen veri bu kurallara uymazsa, Pydantic bir ValidationError fırlatır ve biz de bu hatayı yakalayarak kullanıcıya anlaşılır bir hata mesajı döndürürüz. Bu yaklaşım, hem uygulamanın güvenliğini artırır hem de veri kalitesini garanti altına alır. Her bir giriş noktasında bu tür bir doğrulama kapısı kurmak, uygulamanızı dış tehditlere ve hatalı verilere karşı çok daha dirençli hale getirecektir.

İleri Düzey Doğrulama Stratejileri ve İpuçları: Güvenlik ve Performans İçin Ne Yapmalıyız?

Temel doğrulama teknikleri ve kütüphanelerle sağlam bir zemin oluşturduktan sonra, uygulamanızın doğrulama kapısını daha da güçlendirmek için ileri düzey stratejilere ve önemli ipuçlarına göz atabiliriz. Bu yaklaşımlar, özellikle büyük ölçekli ve kritik uygulamalarda güvenlik, performans ve sürdürülebilirlik açısından fark yaratır.

1. Özel Doğrulayıcılar (Custom Validators) ve İş Mantığı: Bazen standart kütüphane veya Regex kuralları, uygulamanızın benzersiz iş mantığını karşılamayabilir. Örneğin, bir ürünün indirimli fiyatının her zaman orijinal fiyattan düşük olması gerektiğini veya bir kullanıcının sadece belirli bir yaş aralığındaki ürünleri satın alabileceğini doğrulamak isteyebilirsiniz. Pydantic gibi kütüphaneler, modellere özel doğrulayıcı metotlar eklemenize olanak tanır.

from pydantic import BaseModel, ValidationError, Field, validator

class IndirimliUrun(BaseModel):
    urun_adi: str
    normal_fiyat: float = Field(gt=0)
    indirimli_fiyat: float = Field(gt=0)

    @validator('indirimli_fiyat')
    def indirimli_fiyat_normal_fiyattan_dusuk_olmali(cls, v, values):
        if 'normal_fiyat' in values and v >= values['normal_fiyat']:
            raise ValueError('İndirimli fiyat normal fiyattan düşük olmalıdır.')
        return v

try:
    # Gecerli durum
    urun1 = IndirimliUrun(urun_adi="Laptop", normal_fiyat=1000.0, indirimli_fiyat=800.0)
    print(f"Geçerli ürün: {urun1}")
    
    # Geçersiz durum
    # urun2 = IndirimliUrun(urun_adi="Klavye", normal_fiyat=200.0, indirimli_fiyat=250.0) # ValueError fırlatır
except ValidationError as e:
    print(f"Hata: {e}")
  

Bu örnekte, @validator dekoratörü ile indirimli_fiyat alanına özel bir doğrulama kuralı ekledik. Bu, daha karmaşık iş kurallarını doğrudan veri modelinize entegre etmenizi sağlar.

2. Sunucu Taraflı (Server-Side) ve İstemci Taraflı (Client-Side) Doğrulama Ayrımı: Web uygulamalarında genellikle hem istemci tarafında (tarayıcıda JavaScript ile) hem de sunucu tarafında (Python ile) doğrulama yapılır. İstemci taraflı doğrulama, kullanıcıya anında geri bildirim sağlayarak kullanıcı deneyimini iyileştirir ve sunucu yükünü azaltır. Ancak, güvenlik açısından asla sadece istemci taraflı doğrulamaya güvenmemelisiniz. İstemci taraflı doğrulama kolayca atlatılabilir. Tüm kritik doğrulama mantığı her zaman sunucu tarafında uygulanmalıdır.

3. Doğrulama ve Temizleme (Sanitization) Farkı: Doğrulama, verinin geçerli olup olmadığını kontrol ederken, temizleme (sanitization) veriyi güvenli ve kullanılabilir hale getirmek için değiştirme işlemidir. Örneğin, HTML etiketlerini bir metinden kaldırmak veya özel karakterleri kaçış dizilerine (escape sequences) dönüştürmek temizleme işlemidir. Güvenlik açısından, kullanıcı girdisini veritabanına kaydetmeden veya bir web sayfasında göstermeden önce hem doğrulamalı hem de uygun şekilde temizlemelisiniz. Özellikle XSS saldırılarını önlemek için temizleme çok önemlidir. Python’da bleach veya html.escape gibi kütüphaneler/fonksiyonlar temizleme için kullanılabilir.

4. Uluslararasılaştırma (Internationalization – i18n) ve Yerelleştirme (Localization – l10n) İçin Doğrulama: Uygulamanız farklı coğrafi bölgelerden kullanıcıları hedefliyorsa, doğrulama kurallarınızın bu farklılıkları dikkate alması gerekir. Telefon numarası formatları, tarih formatları, para birimi sembolleri ve hatta isimlerin karakter setleri ülkeden ülkeye değişebilir. Bu durumlar için, doğrulama kurallarınızı esnek tutmalı ve gerektiğinde yerel standartlara uyarlayabilmelisiniz. Örneğin, farklı ülke kodlarına sahip telefon numaralarını doğrulamak için daha esnek Regex desenleri kullanmak veya farklı tarih formatlarını işleyebilen kütüphanelerden faydalanmak gerekebilir.

5. Performans Etkisi: Büyük veri kümeleri üzerinde yoğun doğrulama işlemleri yapmak, uygulamanızın performansını etkileyebilir. Özellikle API’ler aracılığıyla büyük JSON yüklerini işlerken, doğrulama mantığınızın verimli olduğundan emin olmalısınız. Pydantic gibi kütüphaneler C tabanlı Rust kütüphaneleri (örneğin pydantic-core) kullanarak yüksek performans sunar. Ancak, özel doğrulayıcılar yazarken veya çok sayıda Regex deseni uygularken performansı göz önünde bulundurmak önemlidir. Gereksiz veya aşırı karmaşık doğrulama adımlarından kaçınmak, performansı optimize etmenize yardımcı olacaktır.

Bu ileri düzey stratejiler, doğrulama kapınızı sadece güvenli değil, aynı zamanda esnek, performanslı ve genişletilebilir hale getirerek, uygulamanızın uzun vadeli başarısına katkıda bulunur.

Sonuç ve Sıkça Sorulan Sorular

Kullanıcı girdisine güvenmek, yazılım geliştirme dünyasında yapılan en büyük hatalardan biridir ve uygulamanız için ciddi güvenlik, veri bütünlüğü ve kararlılık sorunlarına yol açabilir. Python ile bir “doğrulama kapısı” inşa etmek, bu risklere karşı en etkili savunma mekanizmalarından biridir. Basit tür kontrollerinden Regex’in gücüne, Pydantic gibi gelişmiş kütüphanelerin sunduğu şema tabanlı doğrulama çözümlerine kadar birçok araç ve teknikle, kullanıcıdan gelen verileri titizlikle inceleyebilir ve yalnızca geçerli olanların sisteminize girmesine izin verebilirsiniz.

Bu makalede, veri doğrulamanın neden hayati önem taşıdığını, Python’da temel doğrulama tekniklerini, Regex ile karmaşık desenleri nasıl yakalayacağımızı, Pydantic gibi harici kütüphanelerle daha güçlü çözümler geliştirmeyi ve gerçek dünya senaryolarında bu teknikleri nasıl uygulayacağımızı öğrendik. Ayrıca, özel doğrulayıcılar, istemci/sunucu tarafı doğrulama ayrımı, temizleme kavramı ve performans ipuçları gibi ileri düzey stratejilere de değindik. Unutmayın, güvenli bir uygulama, her zaman güvenli veri girişinden başlar. Doğrulama kapınızı sağlam inşa ederek, uygulamanızın geleceğini güvence altına alırsınız.

Sıkça Sorulan Sorular (SSS)

• S: Sadece istemci tarafında (tarayıcıda) doğrulama yapmak yeterli midir?

  C: Hayır, kesinlikle yeterli değildir. İstemci tarafı doğrulama, kullanıcı deneyimini iyileştirmek ve sunucu yükünü azaltmak için faydalıdır ancak güvenlik açısından kolayca atlatılabilir. Tüm kritik doğrulama mantığı her zaman sunucu tarafında uygulanmalıdır.

• S: Doğrulama (Validation) ile Temizleme (Sanitization) arasındaki fark nedir?

  C: Doğrulama, bir verinin belirli kurallara uygun olup olmadığını kontrol etme işlemidir (örneğin, bir sayının pozitif olması). Temizleme ise, veriyi güvenli ve kullanılabilir hale getirmek için değiştirme işlemidir (örneğin, bir metinden zararlı HTML etiketlerini kaldırmak). Güvenlik için genellikle her ikisi de gereklidir.

• S: Python’da hangi doğrulama kütüphanesini kullanmalıyım?

  C: Projenizin büyüklüğüne ve karmaşıklığına bağlıdır. Basit projeler için yerleşik Python özellikleri ve Regex yeterli olabilir. Daha büyük ve yapılandırılmış veri modelleriyle çalışan projeler için Pydantic (modern web uygulamaları için popüler), Marshmallow (serileştirme/deserileştirme ile birlikte) veya Cerberus (hafif ve esnek) gibi kütüphaneler önerilir.

• S: Kullanıcı girdisini doğrulamayı unutursam ne olur?

  C: Kullanıcı girdisini doğrulamayı unutmak, uygulamanızda SQL Enjeksiyonu, XSS gibi güvenlik açıkları, veri tabanında tutarsız veya bozuk veriler, uygulamanın çökmesine neden olan çalışma zamanı hataları ve kötü bir kullanıcı deneyimi gibi ciddi sorunlara yol açabilir.

#Python #WebGeliştirme #VeriGüvenliği #Doğrulama #SiberGüvenlik