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.

Geometrik sezgiden cebirsel formüllere geçelim. İki ayrı nokta \(P = (x_1, y_1)\) ve \(Q = (x_2, y_2)\) verildiğinde (bu iki nokta birbirinden farklı, yani \(x_1 \neq x_2\)), \(P + Q = R = (x_3, y_3)\) toplamını bulmak için şu adımları izleriz:

Bu üç formül birlikte, eliptik eğri nokta toplamının tüm cebirsel iskeletini oluşturur. \(\mathbb{R}\) üzerinde geometrik çizimle yapılan işlem, sonlu alanda tamamen bu üç modüler denklemle ikame edilir.

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 en soyut ama en kritik elemanıdır. Geometride "sonsuzda kesişme" kavramına karşılık gelir; iki paralel doğrunun, gerçek sayılar dünyasında asla bir araya gelemeyen ama projektif geometri çerçevesinde "sonsuzda tek bir noktada buluştuğu" düşüncesine dayanır.

Eliptik eğri grubunda sonsuz nokta üç temel rolü yerine getirir:

• Birim Eleman (Identity): Herhangi bir nokta \(P\) ile toplandığında sonucu değiştirmez: \(P + \mathcal{O} = P\). Tıpkı sayısal toplamada sıfırın rolü gibi.
• Ters Eleman Garantisi: Her \(P = (x, y)\) noktasının tersi \(-P = (x, -y \bmod p)\)'dir. Bu iki ters nokta toplandığında \(P + (-P) = \mathcal{O}\) olur ve grubu kapalı tutar.
• Skaler Çarpım Döngüsü: Bir üretici nokta \(G\) tekrar tekrar kendisiyle toplandığında, sonunda grubun mertebesine (order) ulaşıldığında \(n \cdot G = \mathcal{O}\) elde edilir ve döngü kapanır. Bu özellik, güvenli kriptografik anahtar uzayının boyutunu belirler.

Yazılım implementasyonlarında sonsuz nokta, koordinat çiftiyle temsil edilemeyeceği için genellikle ayrı bir enum varyantı veya özel bir sentinel değeriyle kodlanır. Rust ve diğer güvenli dillerdeki modern ECC kütüphanelerinde bu ayrım, tür sistemi seviyesinde (type-level) zorunlu hale getirilir; sonsuz noktayı geçerli bir koordinat çiftiyle karıştırmak derleme hatası verir.

Formülleri soyut kalmaktan çıkaralım. \(y^2 = x^3 + 7\) eğrisini \(p = 97\) sonlu alanı üzerinde ele alıyoruz — aynı yapıyı secp256k1 kullanır, sadece çok daha büyük sayılarla. İki başlangıç noktamız: \(P = (3,\ 6)\) ve \(Q = (10,\ 17)\).

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