Nokta Toplama (Point Addition)

Eliptik eğri kriptografisinin tüm gücü, son kertede tek bir işlemin üzerine inşa edilmiştir: nokta toplama. Bitcoin'in bir işlem imzalaması, TLS el sıkışmasının paylaşılan gizli anahtarı üretmesi, Ethereum'un bir adres türetmesi hepsi bu basit görünen ama derin matematiksel özelliklere sahip geometrik işlemin milyonlarca kez tekrarlanmasından doğar. Nokta toplamayı anlamak; eliptik eğrilerin neden güvenli olduğunu, neden kırılmasının imkânsız kabul edildiğini ve bu yapıların kriptografide neden bu denli hâkim olduğunu anlamaktır.

Önceki konularda (Weierstrass Formülü) gördüğümüz üzere, eliptik bir eğri \(y^2 = x^3 + ax + b\) şeklinde bir denklemdir ve bu denklemi sağlayan tüm \((x, y)\) koordinat çiftleri eğrinin noktalarını oluşturur. Kriptografide bu eğri her zaman büyük bir asal sayı \(p\) ile tanımlanan bir sonlu alan (\(\mathbb{F}_p\)) üzerinde çalışır; dolayısıyla "denklem üzerindeki noktalar" ifadesi, modüler aritmetik kurallarına uyan ayrık tam sayı çiftleri anlamına gelir.

Eliptik eğri üzerindeki noktaların kümesi, belirli bir işlem (nokta toplama) ile birlikte soyut bir matematiksel grup oluşturur. Bu grup yapısının var olabilmesi için nokta toplama işleminin dört temel kuralı sağlaması gerekir: işlemin her zaman eğri üzerinde kalması (kapalılık), sıranın sonucu değiştirmemesi (değişmelik), grubun bir "hiçlik" elemanının bulunması (birim eleman) ve her noktanın bir tersinin olması (ters eleman). Bu dört kural birlikte, nokta toplamayı kriptografik açıdan kullanılabilir kılan yapının temelidir.

Nokta toplamayı anlamanın en sezgisel yolu, gerçek sayılar (\(\mathbb{R}\)) üzerindeki sürekli grafik üzerinden başlamaktır. Buradaki görsel mantık daha sonra modüler aritmetiğe birebir çevrilecektir.

Eliptik eğri üzerinde iki farklı nokta seçelim: \(P = (x_1, y_1)\) ve \(Q = (x_2, y_2)\). Bu iki noktadan geçen düz bir doğru çizdiğimizde, bu doğru genel olarak eğriyi üçüncü bir noktada daha keser; bu noktaya \(R'\) diyelim. �?imdi kritik adım: \(R'\) noktasının x-eksenine göre dikey yansımasını alırız, yani \(y\) koordinatının işaretini tersine çeviririz. Bu yansıma noktası, yani \(R = (x_3, -y_3')\), \(P + Q\) toplamının tanımıdır.

Bu geometrik tanımın matematiksel olarak neden mantıklı olduğu şu şekilde açıklanabilir: Weierstrass denklemi \(y^2 = x^3 + ax + b\), sağ tarafı sabit tutulduğunda \(y\)'nin hem pozitif hem de negatif karekökünü çözüm olarak kabul eder. Dolayısıyla eğri, x-eksenine göre tam bir ayna simetrisi taşır: bir \((x, y)\) noktası eğri üzerindeyse \((x, -y)\) de her zaman eğri üzerindedir. Bu simetriyi kullanarak elde ettiğimiz yansıma noktası, grubun "ters eleman" özelliğini de doğal olarak gömülü hale getirir. Eğer \(R' = (x, y)\) ise, \(R' + (-R') = \mathcal{O}\) (sonsuz nokta) olacak şekilde \(-R' = (x, -y)\) eğri üzerindedir.

Genel toplama formülleri yalnızca \(x_1 \neq x_2\) olduğunda geçerlidir. Eliptik eğri grubu matematiksel olarak tam ve kapalı olabilmek için üç özel durumun da ayrıca ele alınması gerekir. Bu durumları atlamak, kriptografik uygulamalarda ciddi hatalara veya güvenlik açıklarına yol açar.

Sonsuz nokta (\(\mathcal{O}\)), eliptik eğri grubunun matematiksel hiyerarşisinde en soyut, ancak sistemin ayakta kalmasını sağlayan en kritik yapı taşıdır. Standart Kartezyen koordinat sisteminde doğrudan sayısal bir karşılığı olmayan bu eleman, geometride "sonsuzda kesişme" konseptine dayanır. İki paralel doğrunun Öklid (gerçel sayılar) dünyasında asla birleşemeyeceği gerçeği, projektif geometri (projective geometry) uzayına geçildiğinde bu doğruların "sonsuzda tek bir ideal noktada buluştuğu" varsayımıyla aşılır. Eliptik eğrilerde bu yaklaşım, eğrinin cebirsel bütünlüğünü tamamlayarak her yönden kesintisiz ve kapalı bir matematiksel uzay inşa edilmesini sağlar.

Eliptik eğri grubunun tam teşekküllü bir değişmeli grup (Abelian group) yapısı sergileyebilmesi için sonsuz nokta üç temel ve vazgeçilmez rolü üstlenir:

• Birim Eleman (Identity): Cebirsel yapının sıfır noktasıdır. Eğri üzerindeki herhangi bir \(P\) noktası ile toplandığında, sistemin dengesini bozmayarak sonucu aynı bırakır: \(P + \mathcal{O} = P\). Bu durum, tam sayılar aritmetiğindeki sıfırın (0) toplama işlemindeki etkisiz eleman rolünün eliptik eğri uzayındaki kusursuz karşılığıdır.
• Ters Eleman Garantisi (Inverses): Geometrik düzlemde, eğri üzerinde x-eksenine dik çizilen dikey bir doğru eğriyi iki noktada keser. Her \(P = (x, y)\) noktasının simetrik zıttı olan \(-P = (x, -y \bmod p)\) elemanı ile toplanması, bu dikey doğrunun sonsuzluğa uzanarak sonsuz noktada eğriyi kestiği anlamına gelir. Matematiksel olarak bu iki ters nokta birleştirildiğinde sonuç her zaman birim elemana döner (\(P + (-P) = \mathcal{O}\)) ve grubun kapalılık aksiyomu güvence altına alınır.
• Skaler Çarpım Döngüsü (Cyclic Subgroups): Kriptografik sistemlerin güvenliği, belirli bir \(G\) (Üretici - Generator) noktasının kendisiyle ardışık olarak toplanmasıyla oluşan döngüsel alt gruplara dayanır. Bu skaler ekleme işlemi devam ettiğinde, grubun sınır mertebesine (order, \(n\)) ulaşıldığı an \(n \cdot G = \mathcal{O}\) eşitliği elde edilir ve döngü başa sarar. Bu sınır, eliptik eğri ayrık logaritma probleminin (ECDLP) zorluğunu belirleyen kriptografik anahtar uzayının (key space) kesin boyutunu çizer.

Sistemin yazılım ve donanım mimarisindeki (implementasyon) karşılığına bakıldığında, sonsuz noktanın standart afin \((x, y)\) koordinat çiftleriyle doğrudan ifade edilememesi özel mühendislik yaklaşımları gerektirir. Yazılım geliştirme aşamasında bu soyut kavram, veri yapılarında sıklıkla izole edilmiş bir enum varyantı veya özel bir işaretçi (sentinel value) olarak kodlanır. Rust gibi bellek ve tür güvenliğini (type-safety) merkeze alan modern dillerdeki gelişmiş ECC kütüphanelerinde bu ayrım, derleyici (compiler) seviyesinde zorunlu tutulur; sonsuz noktayı sıradan bir geçerli koordinatmış gibi işlemeye çalışmak anında derleme hatası verir. Ek olarak, gelişmiş sistemlerde projektif koordinatlara (X, Y, Z) geçiş yapılarak \(Z=0\) durumunun matematiksel olarak sonsuz noktayı temsil etmesi sağlanır; bu da kod dallanmalarını (if-else branching) tamamen ortadan kaldırarak sabit zamanlı (constant-time) güvenli bir yürütme ortamı sunar.

Nokta toplamayı kriptografik açıdan güçlü yapan özellik, bu işlemin tek yönlülüğüdür (one-way function). Bir başlangıç noktası \(G\) (üretici nokta) ile bir tam sayı \(k\) (gizli anahtar) verildiğinde, \(k\) defa nokta toplama yaparak \(Q = k \cdot G\) sonuç noktasını hesaplamak son derece hızlıdır. Bu işlem, Double-and-Add algoritması kullanılarak \(O(\log k)\) adımda tamamlanır 256 bitlik bir \(k\) için yalnızca 256 adım yeterlidir.

Ancak tersini yapmak, yani sadece \(G\) ve \(Q\) bilindiğinde \(k\)'yı bulmak bu Eliptik Eğri Ayrık Logaritma Problemi (ECDLP)'dir ve günümüzdeki en güçlü bilgisayarlar için bile hesaplamalı olarak imkânsız kabul edilmektedir. Sonlu alandaki nokta bulutu o kadar düzensiz ve öngörülemez dağılmıştır ki, brute-force deneme dışında bilinen hiçbir verimli algoritma bu problemi çözemez. secp256k1 eğrisinde \(p \approx 2^{256}\) olduğundan, olası anahtar uzayı evrendeki atom sayısından kat kat büyüktür.

Aşağıdaki Rust kod paneli, Weierstrass eğrisi üzerindeki nokta toplama operasyonunu özel durumlar dahil eksiksiz biçimde uygular. Sonsuz nokta ayrı bir enum varyantı olarak modellenerek tip güvenliği sağlanmış; çarpımsal ters, Fermat'ın Küçük Teoremi tabanlı sabit zamanlı üs alma ile hesaplanmaktadır.

/// Eliptik eğri üzerindeki noktaları temsil eden tip.
/// Infinity varyantı, grubun birim elemanını (sonsuz nokta) temsil eder.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Point {
    Coordinate(u128, u128), // (x, y) koordinatı
    Infinity,               // Grubun birim elemanı O
}

/// Weierstrass eğrisi: y² = x³ + ax + b (mod p)
#[derive(Debug)]
pub struct EllipticCurve {
    pub a: u128,
    pub p: u128, // Asal modül
}

impl EllipticCurve {
    /// Fermat'ın Küçük Teoremi: a^(p-2) mod p
    /// Sabit zamanlı (constant-time) modüler ters bulma.
    fn mod_inv(&self, a: u128) -> u128 {
        self.mod_pow(a, self.p - 2)
    }

    /// Square-and-Multiply ile hızlı modüler üs alma.
    fn mod_pow(&self, mut base: u128, mut exp: u128) -> u128 {
        let mut result = 1;
        base %= self.p;
        while exp > 0 {
            if exp % 2 == 1 {
                result = result.wrapping_mul(base) % self.p;
            }
            base = base.wrapping_mul(base) % self.p;
            exp /= 2;
        }
        result
    }

    /// İki noktayı toplar. Tüm özel durumlar (sonsuz nokta,
    /// dikey doğru, nokta katlama) ayrı ayrı ele alınmıştır.
    pub fn add(&self, p1: Point, p2: Point) -> Point {
        match (p1, p2) {
            // Birim eleman kuralları: O + P = P ve P + O = P
            (Point::Infinity, other) | (other, Point::Infinity) => other,
            (Point::Coordinate(x1, y1), Point::Coordinate(x2, y2)) => {
                // Dikey doğru: P + (-P) = O
                if x1 == x2 && (y1 + y2) % self.p == 0 {
                    return Point::Infinity;
                }
                // Nokta katlama: P = Q ise teğet formülü
                let m = if x1 == x2 && y1 == y2 {
                    // m = (3x1² + a) · (2y1)⁻¹ mod p
                    let num = (3 * x1 % self.p * x1 % self.p + self.a) % self.p;
                    let den = self.mod_inv(2 * y1 % self.p);
                    num * den % self.p
                } else {
                    // m = (y2 - y1) · (x2 - x1)⁻¹ mod p
                    let dy = (y2 + self.p - y1) % self.p;
                    let dx_inv = self.mod_inv((x2 + self.p - x1) % self.p);
                    dy * dx_inv % self.p
                };
                // x3 = m² - x1 - x2 (mod p)
                let x3 = (m * m % self.p + 2 * self.p - x1 - x2) % self.p;
                // y3 = m(x1 - x3) - y1 (mod p)
                let y3 = (m * ((x1 + self.p - x3) % self.p) % self.p
                    + self.p - y1) % self.p;
                Point::Coordinate(x3, y3)
            }
        }
    }
}

fn main() {
    // y² = x³ + 7 (mod 97)  secp256k1 benzeri küçük örnek
    let curve = EllipticCurve { a: 0, p: 97 };
    let p = Point::Coordinate(3, 6);
    let q = Point::Coordinate(10, 17);
    let result = curve.add(p, q);
    println!("P + Q = {:?}", result);
    
    // Birim eleman testi: P + O = P
    let identity_test = curve.add(p, Point::Infinity);
    assert_eq!(identity_test, p, "Birim eleman hatası!");
    println!("P + O = P doğrulandı: {:?}", identity_test);
}