Weierstrass Formülü

Modern kriptografinin, özellikle Bitcoin/Ethereum gibi blokzincir mimarilerinin ve güvenli internet protokollerinin (TLS/SSL) temel koruma kalkanını oluşturan eliptik eğriler, isimlerinin aksine geometrik bir elips çizmezler. Bu isimlendirme, tamamen tarihsel bir süreçten kaynaklanır; geçmişte gezegenlerin eliptik yörüngelerinin yay uzunluklarını hesaplamak için kullanılan "eliptik integrallerin" ters fonksiyonu olarak ortaya çıkmışlardır.

Kriptografik açıdan eliptik eğriler, üzerinde yer alan noktaların belirli kurallar çerçevesinde etkileşime girebildiği (nokta toplama ve katlama işlemleri) ve bu işlemlerin sonucunda soyut bir matematiksel grup yapısı oluşturan özel cebirsel geometrik yapılardır. Bu gruptaki işlemler tek yönlü bir fonksiyon (trapdoor function) görevi görür: Bir noktayı kendisiyle milyarlarca kez toplamak (skaler çarpım) son derece hızlıyken, elde edilen sonuç noktası ile başlangıç noktasından yola çıkarak toplama sayısını (yani gizli anahtarı) bulmak günümüz süper bilgisayarları için bile imkansız kabul edilir.

Bu eğrileri matematiksel olarak tanımlamanın ve standartlaştırmanın en sade ve cebirsel olarak en verimli yolu Kısa Weierstrass Formu (Short Weierstrass Form) denklemidir:

Burada \(a\) ve \(b\) katsayıları, eğrinin genel şeklini (grafiğin iki bağımsız daldan mı yoksa tek bir birleşik parçadan mı oluşacağını) doğrudan belirleyen sabit parametrelerdir. Bu parametreler reel sayılar kümesinde (\(\mathbb{R}\)) birer katsayı olabileceği gibi, şifreleme pratiklerinde belirli bir sonlu alanın (\(\mathbb{F}_p\)) elemanlarıdır. Denklemdeki \((x, y)\) değişkenleri ise bu cebirsel denklemi doğrulayan ve eğri üzerindeki noktaları temsil eden koordinat çiftleridir.

Eliptik eğri teorisini ilk kez öğrenirken denklemi genellikle reel sayılar kümesi (\(\mathbb{R}\)) üzerinde ele alırız. Grafiksel olarak bu, x-eksenine göre kusursuz bir ayna simetrisine sahip olan, pürüzsüz ve sürekli bir çizgi oluşturur. Sürekli uzayda nokta toplama işlemi tamamen geometriye dayanır: İki noktadan (\(P\) ve \(Q\)) geçen bir doğru çizilir; bu doğru eğriyi üçüncü bir noktada (\(R'\)) keser; bu noktanın x-eksenine göre dikey yansıması alınarak toplam noktası (\(P + Q = R\)) bulunur. Eğer bir noktayı kendisiyle topluyorsak (nokta katlama), o noktadan eğriye çizilen teğet doğrusu kullanılır.

Ancak bu görsel ve sürekli yaklaşım kriptografik olarak iki temel çıkmaza girer:

• Hassasiyet ve Yuvarlama Hataları: Bilgisayarlar reel sayıları ifade ederken kayan noktalı sayı (floating-point) aritmetiği kullanır. Bu aritmetik, \(\pi\) veya karekök gibi irrasyonel değerlerde kaçınılmaz yuvarlama hatalarına yol açar. Kriptografide ise tek bir bitin dahi değişmesi şifrenin çözülememesine neden olacağından, %100 kesinlik (precision) şarttır.
• Sonsuz Grup Boyutu: Reel sayılar sonsuzdur, dolayısıyla eğri üzerindeki nokta sayısı da sonsuzdur. Kriptografik anahtar uzaylarını sınırlandırmak ve yönetmek için sonlu sayıda elemandan oluşan bir gruba ihtiyaç duyarız.

Bu engelleri aşmak için eliptik eğriler, kriptografide her zaman çok büyük bir \(p\) asal sayısı tarafından sınırlandırılan bir Sonlu Alan (\(\mathbb{F}_p\)) üzerinde tanımlanır. Bu durumda denklem modüler aritmetik formatını alır:

Artık karşımızda sürekli bir eğri grafiği yoktur. Eğrinin grafiği, koordinatları \(\{0, 1, ..., p-1\}\) kümesinin birer elemanı olan ve yukarıdaki modüler denklemi sağlayan ayrık tam sayı çiftlerinin koordinat sistemine serpiştirilmesiyle oluşan bir nokta bulutu (scatter plot) haline gelir.

En büyüleyici kısım ise şudur: Fiziksel pürüzsüz bir çizgi olmamasına ve geometrik teğetler çizilememesine rağmen, reel sayılar dünyasındaki tüm cebirsel grup kuralları bu modüler dünyada da aynen çalışır. Geometrik doğrular yerini modüler denklemlere bırakır. Örneğin, sürekli grafiklerdeki teğet veya kesen doğrunun eğimi (\(m = \frac{y_2 - y_1}{x_2 - x_1}\)), sonlu alanda reel bir bölme işlemi olarak değil, paydanın mod p üzerindeki çarpımsal tersi alınarak hesaplanır:

Böylece yuvarlama hataları tamamen ortadan kalkar, işlemler deterministik hale gelir ve her adım sonlu bir sınır içinde güvenceye alınır.

Kriptografik eliptik eğriler dünyasında en kritik tasarım kriteri eğrinin tekil olmaması (non-singular), yani geometrik olarak tamamen düzgün ve pürüzsüz olmasıdır. Cebirsel olarak bu durum, eğrinin her bir noktasında tanımlı ve benzersiz tek bir teğet doğrusunun çizilebilir olmasını şart koşar. Eğer eğri üzerinde sivri bir köşe (cusp) veya kendi kendisini kestiği bir kesişim noktası (node) bulunursa, bu noktalarda eğrinin türevi belirsiz olacağı için teğet çizilemez. Bu da nokta toplama ve katlama aritmetiğini tamamen tutarsız ve tanımsız hale getirir; çünkü eliptik grup kuralları doğrudan eğriye çizilen teğetlere ve kesen doğrulara bağlıdır.

Karakteristik değeri 3'ten büyük olan tüm matematiksel cisimlerde (şifreleme standartlarında kullanılan tüm sonlu alanlarda), bu pürüzsüzlük şartı eğrinin Diskriminant (\(\Delta\)) adı verilen cebirsel kontrol değeri hesaplanarak denetlenir:

Eğer \(\Delta = 0\) olursa, denklemin x ve y eksenlerine göre kısmi türevlerinin her ikisi de aynı anda sıfıra eşitlenir. Bu durum, eğrinin pürüzsüzlüğünü yitirerek grup yapısının tanımlanamayacağı iki farklı geometrik felakete yol açar:

Diskriminantı sıfır olan tekil eğriler, kriptografi standartlarında ve güvenli yazılım protokollerinde kesinlikle yasaklanmıştır. Bunun nedeni, tekil bir eğrinin tekil olmayan noktalarının oluşturduğu grubun (\(E_{ns}\)), matematiksel bir dönüşüm (izomorfizma) köprüsü kurularak çözümü son derece basit olan klasik gruplara dönüştürülebilmesidir.

Matematikte izomorfizma, iki farklı grup arasında işlem yapısını birebir koruyan yapısal bir eşleşmedir. Eğer kriptografik zorluk sunan zor bir grubu (örn: eliptik eğri grubunu), DLP çözümü çok daha kolay olan basit bir gruba (örn: modüler toplama veya çarpma grubuna) birebir eşleyebiliyorsak, zor gruptaki tüm güvenlik garantileri anında çöker:

1. Cusp (Sivri Uç) İzomorfizması ve Toplamsal Saldırı:
Sivri uca sahip (yani denklemi mod p altında \(y^2 = x^3\) olan) bir eliptik eğride, tekil olmayan noktaların kümesi \(E_{ns}(\mathbb{F}_p)\) ile asal alanın toplamsal grubu \((\mathbb{F}_p, +)\) arasında rasyonel fonksiyonlarla tanımlı birebir bir izomorfizma köprüsü (\(\phi\)) kurulabilir:

Bu eşleşme altında, eğri üzerindeki zor nokta toplama işlemi (\(P + Q\)), hedef grupta basit bir modüler toplamaya (\(\phi(P) + \phi(Q) \pmod p\)) dönüşür. Sonuç olarak, çözülmesi gereken eliptik eğri ayrık logaritma problemi (\(Q = k \cdot P\)), toplamsal grupta şu basit modüler çarpım denklemi haline gelir:

Buradaki \(k\) gizli anahtarını bulmak, karmaşık eliptik eğri operasyonları yerine tek bir modüler bölme (ters eleman çarpımı) işlemine indirgenir:

Genişletilmiş Öklid Algoritması (Extended Euclidean Algorithm) kullanılarak bu çarpımsal ters mikrosaniyeler mertebesinde (logaritmik karmaşıklıkla, \(O(\log p)\)) hesaplanabilir. Bu durum, gizli anahtarın güvenlik derecesini tamamen sıfıra indirir.

2. Node (Düğüm) İzomorfizması ve Çarpımsal Saldırı:
Düğüme sahip (kendi kendisini kesen) bir eğride ise, tekil olmayan noktalar grubu \(E_{ns}(\mathbb{F}_p)\) ile sonlu alanın sıfırdan farklı elemanlarının oluşturduğu çarpımsal grup \((\mathbb{F}_p^*, \cdot)\) (veya kesişim noktalarındaki teğet eğimleri sonlu alanda tanımlı değilse kuadratik genişletme alanı \(\mathbb{F}_{p^2}^*\)) arasında bir izomorfizma köprüsü (\(\psi\)) mevcuttur:

Bu izomorfizma altında, eğri üzerindeki nokta toplama operasyonu, hedef gruptaki modüler çarpma işlemine (\(\psi(P + Q) = \psi(P) \cdot \psi(Q) \pmod p\)) karşılık gelir. Dolayısıyla eliptik ayrık logaritma problemi (\(Q = k \cdot P\)), çarpımsal grupta bilinen klasik ayrık logaritma (DLP) yani modüler üs alma problemine dönüşür:

Genel eliptik eğrilerde (tekil olmayan güvenli eğrilerde) ayrık logaritma problemini çözebilmek için bilinen en iyi algoritmalar Pollard's Rho ve Baby-step Giant-step gibi üstel (exponential) zaman alan (\(O(\sqrt{p})\)) algoritmalardır. Ancak çarpımsal sonlu alanlarda (\(\mathbb{F}_p^*\)) ayrık logaritmayı çözmek için Dizin Hesabı (Index Calculus) ve Sayı Alanı Kalburu (Number Field Sieve - NFS) gibi son derece güçlü alt-üstel (sub-exponential) zaman karmaşıklığına sahip algoritmalar mevcuttur. Bu algoritmalar, aynı anahtar boyutu için eliptik eğrilerin sunduğu üstün güvenliği tamamen kırarak sistemi saniyeler içinde çözülebilir hale getirir.

Kriptografi dünyasında, güvenlik sertifikaları ve donanım üreticileri tarafından önceden doğrulanmış, diskriminantı sıfırdan farklı ve bilinen tüm saldırılara (MOV, FR, anomali vb.) karşı dayanıklı standart eğriler kullanılır. Aşağıdaki tablo, Weierstrass formundaki en popüler eğrileri karşılaştırmaktadır:

Aşağıdaki Rust kod örneğinde, eliptik eğri parametrelerini doğrulamak, diskriminant tabanlı tekillik kontrolü yapmak ve verilen noktaların Weierstrass denklemini sağlayıp sağlamadığını doğrulamak için tasarlanmış modüler bir yapı yer almaktadır:

#[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));
}