Weierstrass Formülü

Modern kriptografinin—özellikle devasa blokzincir mimarilerinin, dijital imza altyapılarının ve internetin güvenliğini sağlayan kırılması pratik olarak imkansız TLS bağlantılarının—kalbini oluşturan eliptik eğriler, salt sayılardan ibaret olmayan, çok boyutlu uzaylarda tanımlanan olağanüstü zarif cebirsel geometrilerdir. Bu pürüzsüz eğriler, sadece analitik düzlemde görsel olarak büyüleyici bir simetri sunmakla kalmaz; asıl güçlerini, üzerlerindeki koordinat noktalarında gerçekleştirilen ve geleneksel aritmetikten tamamen farklı işleyen geometrik toplama ve skaler çarpım işlemleriyle gösterirler. Bu benzersiz işlemler silsilesi, dışarıdan gelebilecek her türlü analitik saldırıya karşı koyabilen, tersine mühendisliğe (geriye dönük hesaplamaya) kapalı ve şifreleme algoritmaları için kusursuz bir soyut grup yapısı (abstract group structure) inşa etmemize olanak tanır.

Kriptografi dünyasında bu karmaşık geometrik yapıları dijital sistemlere, mikroişlemcilere ve matematiksel protokollere güvenle entegre edebilmek için, karmaşadan arındırılmış evrensel bir denkleme ihtiyaç duyulur. Dünya çapındaki tüm şifreleme standartlarında (NIST, SECG, Brainpool) eliptik eğrileri ifade etmek, analiz etmek ve donanım seviyesinde işlem yapmak için kullanılan en temel ve algoritmik olarak en sadeleştirilmiş cebirsel dil, literatürde Kısa Weierstrass Formu (Short Weierstrass Form) olarak adlandırılan o meşhur ve kusursuz denkleme dayanır. Bu form, eğrinin doğasındaki tüm topolojik karmaşıklığı sadece iki sabit parametreye indirgeyerek, modern sistemler üzerinde muazzam bir hesaplama kolaylığı ve küresel bir standardizasyon sağlar:

Bu denklemdeki \(a\) ve \(b\) katsayıları, eğrinin genel yapısını, "düğüm" (node) noktalarını ve karakteristik şeklini doğrudan belirleyen çok kritik sabitlerdir. Geleneksel matematikte bu değerler reel sayılar (\(\mathbb{R}\)) düzleminde çizilse de, şifreleme bilimi gereği bu sabitler ve denklemdeki tüm \((x, y)\) koordinat çiftleri her zaman sınırları belirlenmiş sonlu bir asal alan (\(\mathbb{F}_p\)) içerisinden seçilir.

Matematiksel bir eliptik eğri yapısını, klasik analizdeki reel sayılar kümesi (\mathbb{R}) üzerinde görselleştirdiğimizde, karşımıza x-eksenine göre mutlak bir simetri arz eden, sonsuz noktadan oluşan ve herhangi bir kırılma içermeyen pürüzsüz, sürekli bir eğri grafiği çıkar. Bu sezgisel ve görsel grafik düzlemi üzerinde gerçekleştirilen nokta toplama işlemi, geometrik mantıkla "teğet-kesen yöntemi" (chord-and-tangent method) olarak adlandırılan zarif bir prensibe dayanır: İki noktayı birleştiren kesen doğrunun veya tek bir noktadan çizilen teğetin eğriyi kestiği üçüncü noktanın x-eksenine göre yansımaları, grubun cebirsel yapısını tanımlar.

Ancak modern bilişim sistemleri ve kriptografik protokoller, reel sayıların sunduğu o sonsuz hassasiyeti ve sürekliliği doğrudan işleyebilecek mimaride değildir. Bilgisayarlar, doğaları gereği sonlu bit derinliğine sahip donanımlardır ve reel sayıların virgüllü/ondalıklı yapısını işlerken ortaya çıkan yuvarlama (rounding) hataları ile kayan nokta aritmetiği (floating-point arithmetic), kriptografik sistemin deterministik yapısını tamamen bozarak güvenlik açıklarına kapı aralar. İşte tam bu noktada; kriptografik güvenliği sağlamak için eliptik eğriler, reel sayılar dünyasından koparılarak belirli bir asal sayı modülünde tanımlanan Sonlu Alan (\mathbb{F}_p) üzerine taşınır. Bu geçiş, eğriyi sürekli ve "kaygan" bir geometrik çizgiden çıkarıp, asal sayı modülündeki ayrık koordinat noktalarından oluşan, tahmin edilemez bir "nokta bulutuna" dönüştürür. Eğri denklemi bu sonlu alana aktarıldığında, bildiğimiz pürüzsüz form yerini kriptografik olarak güvenli, modüler bir forma bırakır:

Burada koordinatlar sürekli çizgiler oluşturmak yerine, \(\{0, 1, ..., p-1\}\) kümesi içerisinden seçilen ve denklemi sağlayan ayrık (diskret) tam sayı noktalarından oluşan bir bulut grafiği oluşturur. Fiziksel bir çizgi olmamasına rağmen, reel sayılardaki tüm cebirsel grup kuralları, teğet eğimleri ve aritmetik bağıntılar mod p dünyasında da kusursuz bir şekilde geçerliliğini korur.

Bir eliptik eğri üzerinde tutarlı, öngörülebilir ve güvenli bir "Grup Yasası" (Group Law) işleminin tanımlanabilmesi, ayrıca eğri üzerindeki her bir noktada her zaman benzersiz ve tek bir teğet doğrusunun çizilebilmesi için, eğrinin matematiksel olarak tekil olmaması (non-singular) şarttır. Geometrik bir perspektiften baktığımızda "tekil olmama" durumu, eğrinin kendi üzerine katlanıp kendini kesmemesi, bir düğüm (node) oluşturmaması ve en önemlisi hiçbir noktasında matematiksel türevin tanımlanamayacağı "sivri bir köşe" veya "cusp" barındırmaması anlamına gelir. Eğer bir eğri tekil bir noktaya sahip olsaydı, o noktada grup yasası aksiyomları çöker ve kriptografik olarak güvenli bir matematiksel yapı inşa etmek imkansız hale gelirdi; çünkü tekil noktalar, ayrık logaritma problemini doğrusal veya çok daha basit fonksiyonlara indirgeyerek sistemin tamamen kırılmasına sebep olur.

Kriptografik uygulamalarda kullanılan asal sayı karakteristiği 3'ten büyük olan tüm alanlarda (ki günümüzdeki standart kriptografik sistemlerin neredeyse tamamını kapsar), bir eğrinin bu kusursuz pürüzsüzlüğe sahip olup olmadığı, eğri denklemindeki katsayılar üzerinden hesaplanan Diskriminant (\Delta) değeri ile belirlenir. Diskriminantın matematiksel olarak sıfırdan farklı (\Delta \neq 0) olması, eğrinin herhangi bir "çökme" yaşamadan, kriptografik işlemler için ihtiyaç duyulan o mükemmel ve pürüzsüz yapısını koruduğunun kesin bir kanıtıdır:

Eğer \(\Delta = 0\) olursa, eğri üzerinde türevin her iki bileşeninin de sıfır olduğu ve dolayısıyla teğetin tanımlanamadığı tekil bir nokta oluşur. Kriptografide bu durum iki farklı geometrik felakete yol açar:

Kriptografik protokollerin temelini oluşturan eliptik eğriler, doğası gereği "tekil olmayan" (non-singular) yapılar üzerine inşa edilmelidir. Diskriminantı sıfır olan tekil eğriler, kriptografik güvenlik standartları tarafından kesinlikle yasaklanmıştır. Bu yasaklamanın temelinde, tekil bir eğrinin tekil olmayan noktalarının oluşturduğu grubun (\(E_{ns}\)), güncel hesaplama yöntemleriyle kolaylıkla çözülebilen, kriptografik açıdan "zayıf" veya "basit" gruplara izomorfik (matematiksel olarak eşyapılı) olması yatmaktadır. Bu durum, eliptik eğri ayrık logaritma probleminin (ECDLP) zorluğunu ortadan kaldırarak sistemi savunmasız hale getirir:

1. Cusp (Sivri Uç) İzomorfizması: Geometrik olarak bir "cusp" veya sivri uç barındıran tekil bir eğri üzerinde işlem yapıldığında, bu eğrinin tekil olmayan noktalar kümesi, tanımlı olduğu sonlu alanın (finite field) toplamsal grubuna izomorf hale gelir. Bu izomorfizma, eliptik eğri üzerindeki karmaşık bir işlemi, çok daha basit olan sonlu alanlardaki toplama işlemine indirgeyerek, ayrık logaritma problemini trivial (önemsiz) bir seviyeye düşürür:

Toplamsal grupta grup işlemi bildiğimiz modüler toplamadır: \(P + Q \equiv (x_1 + x_2) \pmod p\). Bu durumda Ayrık Logaritma Problemi (DLP) olan \(Q = k \cdot P\) eşitliği, basit bir modüler bölme/ters alma işlemine indirgenir:

Genişletilmiş Öklid Algoritması kullanılarak bu işlem mikrosaniyeler içinde çözülebilir ve tüm gizli anahtarlar anında ifşa olur.

2. Node (Düğüm) İzomorfizması: Düğüme sahip bir eğrinin noktaları ise tanımlı olduğu sonlu alanın (veya kuadratik genişletmesinin) çarpımsal grubuna izomorftur:

Çarpımsal grupta Ayrık Logaritma Problemi, Dizin Hesabı (Index Calculus) adı verilen gelişmiş algoritmalarla alt-üstel (sub-exponential) zaman karmaşıklığında çözülebilir. Oysa eliptik eğrilerin güvenli olmasının temel nedeni, genel durumlarda DLP'nin sadece üstel (exponential) zaman alan Pollard's Rho gibi zor algoritmalarla çözülebilmesidir.

Modern kriptografik altyapılar, eliptik eğri şifrelemesinin (ECC) güvenliğini sağlamak adına titizlikle seçilmiş ve dünya çapındaki güvenlik otoriteleri tarafından onaylanmış eğri parametrelerine dayanır. Bu standart eğriler; diskriminantın sıfırdan farklı olması, gömme derecesinin yeterince yüksek tutulması ve MOV (Menezes-Okamoto-Vanstone), Frey-Rück (FR) saldırıları veya anomali açıkları gibi kriptanalitik zayıflıklara karşı dirençli olmaları için optimize edilmiştir. Kriptografik uygulamalarda kullanılan bu Weierstrass eğrileri, işlemci verimliliği ile yüksek güvenlik seviyeleri arasında ideal bir denge kurar.

Kriptografik uygulamaların güvenilirliği, kullanılan matematiksel parametrelerin doğruluğuna ve uygulanan algoritmaların hata payı içermemesine bağlıdır. Rust dili, sahip olduğu güçlü tip güvenliği (type safety) ve bellek yönetimi özellikleriyle, eliptik eğri hesaplamaları ve kriptografik protokollere entegrasyon için ideal bir altyapı sunar. Aşağıdaki kod bloğu; Weierstrass formundaki eliptik eğri parametrelerini tanımlamak, eğrinin tekillik durumunu (diskriminant kontrolü aracılığıyla) analiz ederek "güvenli eğri" kriterlerini doğrulamak ve koordinat düzlemindeki noktaların eğri denklemi (\(y^2 = x^3 + ax + b\)) üzerinde kesin olarak yer alıp almadığını teyit etmek amacıyla tasarlanmış, genişletilebilir ve modüler bir yapıyı içermektedir:

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Point {
    Coordinate(u128, u128),
    Infinity,
}

#[derive(Debug)]
pub struct WeierstrassCurve {
    pub a: u128,
    pub b: u128,
    pub p: u128, // Asal alan p parametresi
}

impl WeierstrassCurve {
    /// Yeni bir Weierstrass eğrisi tanımlar ve parametrelerin tekillik durumunu doğrular.
    pub fn new(a: u128, b: u128, p: u128) -> Result<Self, &'static str> {
        // Diskriminant kontrolü: 4a³ + 27b² != 0 (mod p)
        let a_cubed = a.pow(3) % p;
        let b_squared = b.pow(2) % p;
        let term1 = (4 * a_cubed) % p;
        let term2 = (27 * b_squared) % p;
        let discriminant = (term1 + term2) % p;
        if discriminant == 0 {
            return Err("Hata: Eğri tekildir (4a³ + 27b² = 0 mod p). Güvenli değildir!");
        }
        Ok(Self { a, b, p })
    }

    /// Bir noktanın bu eğri üzerinde olup olmadığını kontrol eder.
    pub fn is_on_curve(&self, point: &Point) -> bool {
        match point {
            Point::Infinity => true, // Sonsuzdaki nokta her eğri üzerindedir
            Point::Coordinate(x, y) => {
                let lhs = (y * y) % self.p;
                let x_cubed = x.pow(3) % self.p;
                let ax = (self.a * x) % self.p;
                let rhs = (x_cubed + ax + self.b) % self.p;
                lhs == rhs
            }
        }
    }
}

fn main() {
    // secp256k1 benzeri basitleştirilmiş bir eğri: y² = x³ + 7 (mod 97)
    let p = 97;
    let curve = WeierstrassCurve::new(0, 7, p).unwrap();
    println!("secp256k1-97 eğrisi başarıyla oluşturuldu.");
    
    // Eğri üzerindeki noktaları test etme
    let p1 = Point::Coordinate(32, 11);
    let p2 = Point::Coordinate(10, 10);
    println!("P1(32, 11) eğri üzerinde mi? {}", curve.is_on_curve(&p1));
    println!("P2(10, 10) eğri üzerinde mi? {}", curve.is_on_curve(&p2));
}