Nokta Katlama (Point Doubling)

Bir önceki konuda (\(\textbf{Nokta Toplama}\)) iki farklı noktayı nasıl toplayacağımızı öğrendik. Formüllerin kalbi şuydu: iki noktadan geçen doğrunun eğriye kesişimini bul, yansımasını al. Ancak o formüllerin önünde görünmez bir kısıtlama vardı: iki nokta farklı olmalıydı, yani \(x_1 \neq x_2\). Peki ya aynı noktayı kendisiyle toplamak istersek? Yani \(P + P = 2P\) hesabını?

Bu soru, görünüşte basit bir özel durumu tanımlar; ama aslında nokta katlama, eliptik eğri kriptografisinin en kritik yapı taşıdır. Bir gizli anahtar \(k\), büyük olasılıkla 256 bitlik bir tam sayıdır ve \(Q = k \cdot G\) hesabı binlerce nokta katlaması içerir. Bitcoin'in bir anahtar türetmesi, TLS'in oturum anahtarı üretmesi, Ethereum'un bir imzalaması — hepsinin merkezinde nokta katlama vardır. Bu işlemi anlamak, skaler çarpımı ve dolayısıyla tüm ECC protokollerini anlamak demektir.

Nokta katlamayı nokta toplamadan ayrı bir formülle çözmek zorunda olmamız, tamamen geometrik bir zorunluluktan kaynaklanır. İki farklı nokta için "ikisi arasından geçen doğru" diye bir şey vardır. Ama tek bir nokta için bu tanım anlamsızlaşır. Yerine geçen kavram, o noktada eğriye çizilen teğet doğrusudur. Bu teğetin eğriye ikinci kez kesiştiği nokta ve ardından yapılan yansıma, \(2P\) sonucunu verir.

Geometrik sezgiyi kuralım. \(P + Q\) toplamının tanımını hatırlayın: \(P\) ve \(Q\) arasından geçen doğruyu çiz, eğriyle üçüncü kesişim noktasını bul, yansımasını al. �?imdi \(Q\)'yu yavaş yavaş \(P\)'ye yaklaştırdığınızı düşünün. \(Q \to P\) limitinde, iki farklı noktadan geçen doğru ne olur? Bu iki nokta birbirlerine sonsuz yaklaştıkça, aralarından geçen kesen doğru (secant line), P noktasındaki teğet doğrusuna dönüşür.

Matematiksel olarak bu, diferansiyel hesabın temel tanımıyla örtüşür: bir eğrinin bir noktasındaki teğeti, o noktaya yaklaşan iki nokta arasındaki kesen doğrunun limitidir. Dolayısıyla nokta katlama, limit anlamında nokta toplamadan doğar — ayrı bir kural değil, aynı geometrinin özel bir durumudur. Bu bakış açısı, grup yapısının tutarlılığını da garanti eder: grup aksiyomları \(P + P\) için de bozulmadan geçerlidir, çünkü bu işlem içsel olarak aynı geometrik çerçeveden türetilmiştir.

Eliptik eğri üzerindeki nokta toplama ve katlama (doubling) formülleri incelendiğinde, işlemin paydasında yer alan \(2y_1\) terimi kritik bir rol oynar. Eğer bir \(P = (x_1, y_1)\) noktası için \(y_1 = 0\) şartı sağlanırsa, bu payda sıfıra eşitlenir ve standart formül hesaplanamaz hale gelir; yani işlem "çöker". Geometrik perspektiften bakıldığında bu durum, söz konusu noktadaki teğet doğrusunun eğiminin sonsuz (\(\infty\)) olduğu, başka bir deyişle teğet doğrusunun x-eksenine tam olarak dik (vertikal) bir konumda olduğu anlamına gelir.

Bir noktanın y-koordinatının sıfır olması, bu noktanın doğrudan x-ekseni üzerinde konumlandığını işaret eder. Weierstrass formundaki eliptik eğrilerin x-eksenine göre yansıyan bir ayna simetrisine sahip olduğu gerçeği göz önüne alındığında, eğri üzerindeki her \((x, y)\) noktası için onun negatifi olan \((x, -y)\) noktası da eğri üzerinde yer alır. Ancak \(y = 0\) olduğu özel durumda \(-y = 0\) olduğundan, nokta kendi negatifi ile özdeştir; yani \(P = -P\) denklemi sağlanır. Bu geometrik özdeşlik, eliptik grup teorisinde oldukça dikkat çekici bir sonuca yol açar:

Bir noktanın kendisi ile toplanması sonucunda "sonsuzdaki noktayı" (\(\mathcal{O}\)) vermesi, grubun mertebe-2 (order-2) bir eleman barındırdığını kanıtlar. Matematiksel literatürde bu tür noktalar "2-torsion noktaları" olarak adlandırılır. Kriptografik sistemlerin tasarımı aşamasında, bu noktalar potansiyel bir zafiyet kaynağı olabileceği için oldukça titizlikle yönetilir. Özellikle güvenli bir üretici nokta \(G\) seçimi sırasında \(2G \neq \mathcal{O}\) koşulu esas alınır; bu, seçilen üreticinin mertebesinin 2'den kesinlikle büyük olması gerektiğini şart koşar.

Pratik uygulamalarda kullanılan secp256k1 veya NIST P-256 gibi standart kriptografik eğrilerde, tanımlanan üretici noktanın oluşturduğu grubun mertebesi büyük bir asal sayıdır. Bu tercih, grubun "asal mertebeli" (prime order) olmasını sağlayarak, grup içerisinde hiçbir elemanın mertebe-2 olmamasını garantiler. Bu stratejik tasarım kararı, hem katlama formüllerinin hiçbir istisnai durumla karşılaşmadan (sıfıra bölme hatası almadan) güvenle uygulanabilmesine olanak tanır hem de grubun alt gruplara bölünmesini engelleyerek Polig-Hellman gibi kriptografik saldırılara karşı sistemin direncini en üst seviyeye çıkarır.

Nokta katlama (point doubling) operasyonunun kriptografik sistemlerde neden vazgeçilmez ve stratejik bir öneme sahip olduğunu kavramak için, eliptik eğri şifrelemesinin (ECC) çalışma prensibine daha yakından bakmamız gerekir. ECC protokollerindeki temel hesaplama yükü, bir gizli anahtar olan \(k\) skaler değeri ile eğri üzerindeki tanımlı bir üretici nokta \(G\) arasında gerçekleştirilen skaler çarpım işlemidir: \[ Q = k \cdot G \] Matematiksel tanımı itibarıyla bu işlem, üretici nokta \(G\)'nin kendisiyle \(k\) kez ardışık olarak toplanması, yani \(G + G + G + \ldots + G\) dizisinin hesaplanmasıdır. Eğer bu işlemi teorik olarak "naif" bir toplama döngüsüyle uygulamaya çalışsaydık, \(k\) değerinin büyüklüğü ile doğru orantılı olarak işlem karmaşıklığı da doğrusal bir şekilde artardı.

Modern kriptografide kullanılan standart bir 256-bitlik anahtar uzunluğu göz önüne alındığında, naif bir döngü yaklaşımı yaklaşık \(2^{256}\) adet toplama operasyonu gerektirirdi; bu devasa rakam, günümüzün en hızlı işlemcilerinin dahi hesaplamasını tamamlaması için evrenin yaşından çok daha uzun bir süreye ihtiyaç duyacağı anlamına gelir. Bu verimsizliği ortadan kaldırmak için, ikili sayı sisteminin (binary representation) gücünden yararlanan Double-and-Add (İkile ve Topla) algoritması devreye girer. Bu algoritma, gizli anahtarı \(k\) bitlerine ayırarak süreci modüler bir yapıya dönüştürür; her adımda noktayı ya "katlar" (double) ya da toplama işlemi (add) gerçekleştirir. Bu yöntem, işlem karmaşıklığını \(O(k)\) seviyesinden, çok daha verimli olan \(O(\log_2 k)\) seviyesine, yani toplamda yaklaşık 256 adıma kadar indirgeyerek, kriptografik işlemlerin milisaniyeler içerisinde güvenle tamamlanmasını mümkün kılar.

Algoritmanın iki temel operasyonu vardır: Nokta toplama ve nokta katlama. Her bit için:

Örnek olarak \(k = 13\) için:\(13 = 1101_2\) (binary). Algoritma şöyle çalışır:

256 bit için bu, 256 katlama + en fazla 256 toplama işlemi demektir. Toplamda \(\sim\)512 operasyon, birkaç milisaniye. Ve bu hesabın tersini yapmak — yani sadece \(G\) ve \(Q = kG\) bilindiğinde \(k\)'yı bulmak — hâlâ kriptografik açıdan imkânsız kabul edilmektedir.

Aşağıdaki Rust kodu, nokta katlama operasyonunu point-addition.rs'teki altyapı üzerine genişletir. Aynı EllipticCurve struct'ı kullanılır; double() metodu ayrı olarak implemente edilmiş, scalar_mul() ise Double-and-Add algoritmasını uçtan uca çalıştırır. Sabit zamanlı bir conditional_select primitive'i de eklenmiştir.

/// point_doubling.rs — EllipticCurve'e double() ve scalar_mul() ekleniyor.
/// point_addition.rs'teki Point enum ve EllipticCurve struct üzerine inşa edilir.
use crate::{EllipticCurve, Point};

impl EllipticCurve {
    /// Bir noktayı kendisiyle toplar: 2P.
    /// Dejenere durum: y₁ = 0 ise teğet dik, 2P = Infinity döner.
    pub fn double(&self, p: Point) -> Point {
        match p {
            // 2 * O = O (birim eleman sabit kalır)
            Point::Infinity => Point::Infinity,
            Point::Coordinate(x1, y1) => {
                // Dejenere: y₁ = 0 → teğet dik → 2P = O
                if y1 == 0 {
                    return Point::Infinity;
                }
                // m = (3x₁² + a) · (2y₁)⁻¹ mod p
                let numerator = (3 * x1 % self.p
                    * x1 % self.p
                    + self.a) % self.p;
                let denominator = self.mod_inv(2 * y1 % self.p);
                let m = numerator * denominator % self.p;
                // x₃ = m² - 2x₁ mod p
                let x3 = (m * m % self.p
                    + 2 * self.p          // negatif taşmayı önle
                    - 2 * x1 % self.p) % self.p;
                // y₃ = m(x₁ - x₃) - y₁ mod p
                let y3 = (m * ((x1 + self.p - x3) % self.p) % self.p
                    + self.p - y1) % self.p;
                Point::Coordinate(x3, y3)
            }
        }
    }

    /// Double-and-Add ile k·P skaler çarpımını hesaplar.
    /// Karmaşıklık: O(log₂ k) — 256-bit k için ~512 adım.
    pub fn scalar_mul(&self, mut k: u128, point: Point) -> Point {
        let mut result = Point::Infinity; // Birim eleman ile başla
        let mut addend = point;         // Katlanacak baz nokta
        while k > 0 {
            // En düşük bit 1 ise mevcut addend'i ekle
            if k & 1 == 1 {
                result = self.add(result, addend);
            }
            // Her adımda baz noktayı katla: G → 2G → 4G → 8G …
            addend = self.double(addend);
            k >>= 1; // bir sonraki bite geç
        }
        result
    }
}

fn main() {
    // y² = x³ + 7 (mod 97) üzerinde P = (3, 6)
    let curve = EllipticCurve { a: 0, p: 97 };
    let p = Point::Coordinate(3, 6);
    
    // Nokta katlama: 2P
    let doubled = curve.double(p);
    println!("2P = {:?}", doubled); // Beklenen: (90, 65)
    
    // Skaler çarpım: 13 * P
    let k13 = curve.scalar_mul(13, p);
    println!("13P = {:?}", k13);
    
    // Grup mertebesi doğrulaması: eğer n * G = O ise n mertebedir
    // (küçük örnek için n deneme yanılma ile bulunabilir)
    let p_doubled_again = curve.double(
        Point::Coordinate(0, 0)  // y = 0 → dejenere test
    );
    assert_eq!(p_doubled_again, Point::Infinity, "y=0 → 2P = O olmalı");
    println!("Dejenere durum doğrulandı: y=0 → 2P = O");
}