Asal Alanlar (Fp)

Eliptik eğri kriptografisinin (ECC) arkasındaki tüm cebirsel işlemler, alışılagelmiş gerçek sayılar (R) kümesi üzerinde değil, Sonlu Alanlar (Finite Fields) üzerinde gerçekleştirilir. Gerçek sayılar kümesi sonsuzdur ve bilgisayar ortamında her zaman bir "yuvarlama hatası" (rounding error) riski taşır. Kriptografi gibi mutlak hassasiyet gerektiren bir alanda, virgüllü sayıların yarattığı bu belirsizlik kabul edilemez. Bu yüzden sistemler, sayıları bir döngü içine hapseden ve her işlemin kesin bir sonucu olmasını sağlayan kapalı, sonlu matematiksel yapılara ihtiyaç duyar.

ECC standartlarında en sık tercih edilen yapı ise Asal Alanlar (Prime Fields), yani literatürdeki adıyla \mathbb{F}_p veya GF(p) yapısıdır. Bu yapı, bir saati andıran modüler aritmetik prensibiyle çalışır; belirli bir p değerine ulaşıldığında sayılar başa döner. Burada p, kriptografik gücün kaynağı olan devasa bir asal sayıdır. Örneğin, Bitcoin'in kullandığı secp256k1 eğrisindeki 256 bitlik bu asal sayı, sistemin matematiksel sınırlarını belirleyerek, verilerin sonsuz bir boşlukta değil, sınırları kesin olarak çizilmiş güvenli bir "sayı evreninde" hapsolmasını sağlar.

Asal cisim \mathbb{F}_p, elemanları \{0, 1, 2, ..., p-1\} tam sayılarından oluşan sonlu bir kümedir. Bu küme üzerinde tanımlanan toplama, çıkarma ve çarpma işlemleri, p asal sayısına göre modüler aritmetik kurallarıyla gerçekleştirilir:

Bir kümenin matematiksel olarak bir Cisim (Field) yapısı tanımlayabilmesi için aşağıdaki temel aksiyomları sağlaması şarttır:

• Toplama ve Çarpmaya Göre Kapalılık: Kümeden seçilen herhangi iki elemanla yapılan toplama veya çarpma işleminin sonucu, istisnasız olarak yine aynı kümenin bir elemanı olmalıdır.
• Birim (Etkisiz) Elemanların Varlığı: İşlemlerin sonucu değiştirmeyen birer referans noktası bulunmalıdır. Toplama işlemine göre etkisiz eleman 0, çarpma işlemine göre etkisiz eleman ise 1 olarak tanımlanır. Bu değerler, aynı zamanda tüm kriptografik algoritmaların temel yapı taşlarını oluşturur.
• Ters Elemanların Varlığı (Inverses): Sistemdeki işlemlerin tam anlamıyla geri döndürülebilir olması gerekir. Kümedeki her a elemanının, toplandığında bizi birim elemana (sıfıra) götüren bir toplamsal tersi (-a \equiv p - a \pmod p) bulunmalıdır. Benzer şekilde, sıfır hariç her a elemanı için, özellikle şifreleme ve deşifreleme mekanizmalarının merkezinde yer alan bir çarpımsal ters (a^{-1}) değeri küme içinde mevcut olmalıdır.

Bilgi Notu: Aşağıdaki karmaşıklık analizlerinde n, modül p'nin bit uzunluğunu temsil eder. Örn: 256-bit ECC için n = 256.

Kriptografik protokollerde, özellikle eliptik eğri şifrelemesi (ECC) gibi alanlarda nokta toplama ve skaler çarpım işlemlerinde eğimi hesaplayabilmek için bölme işlemine ihtiyaç duyulur. Ancak, sonlu alanlar (finite fields) aritmetiğinde doğrudan bir bölme operatörü tanımlı değildir. Bu kısıtlamayı aşmak ve matematiksel sürekliliği sağlamak adına, bölme işlemi yerine bölen sayının çarpımsal tersi (modular multiplicative inverse) ile çarpma işlemi gerçekleştirilir. Bu yöntem, modüler aritmetik içinde bölme işlemini mümkün kılan temel mekanizmadır:

Burada b^{-1} değeri, b \cdot b^{-1} \equiv 1 \pmod p koşulunu sağlayan yegâne tam sayıyı ifade eder. Sonlu bir alanda b^{-1} değerinin var olabilmesi için b ile modül p'nin aralarında asal olması gerekmektedir. Bu çarpımsal tersi (b^{-1}) hesaplamak için yaygın olarak iki temel algoritma kullanılır:

Bunu bir çeşit matematiksel pusula gibi düşünebilirsiniz. İki sayının en büyük ortak bölenini (\gcd) bulmak için adım adım ilerlerken, aynı zamanda geriye dönük yolu bulmamızı sağlayan gizli Bézout katsayılarını da hesaplar. Saatimizin sınırı olan p asal olduğundan, sıfırdan farklı her b sayısının bu sistemde mutlaka bir eşi vardır ve \gcd(b, p) = 1'dir. Algoritma bu kilidi kırmak için şu eşitliği çözer:

Bu hikayenin başrolü x katsayısıdır. Çünkü o, devasa modüler evrende b sayısını tekrar başlangıç noktasına (1'e) döndüren yegane anahtar, yani onun sihirli çarpımsal tersi olan b^{-1} elemanıdır.

Eliptik eğrileri klasik matematikten hatırladığınız o kusursuz, pürüzsüz ve estetik grafikler olarak düşünebilirsiniz. Ancak bu nazik grafik, katı kuralları olan asal alan \mathbb{F}_p evrenine girdiğinde bir anda o ipeksi yapısını kaybeder. Tıpkı bir aynanın parçalanması gibi dağılır ve uzay boşluğundaki yıldızlar misali sonlu bir ızgara (grid) üzerindeki gizemli bir nokta bulutuna dönüşür.

İşte bu muazzam kaos, dijital dünyanın en büyük savunma hattını oluşturur. Bu dağınık uzayda seyahat etmek, yani eliptik eğri üzerindeki nokta çarpımı (Scalar Multiplication: Q = k \cdot P) sadece tek bir yöne doğru çalışan sihirli bir fonksiyona dönüşür. Elinizde gizli haritanız (k) ve başlangıç noktanız (P) varsa, varış noktasına (Q) ulaşmak saniyeler sürer. Fakat bir gözlemci sadece başlangıç (P) ve bitiş (Q) noktalarına bakarak, o görünmez labirentte atılan milyarlarca adımı (k skalerini, yani gizli anahtarı) asla tahmin edemez. Evrenin bu eşsiz asimetrisine Eliptik Eğri Ayrık Logaritma Problemi (ECDLP) denir ve bugün tüm modern blokzincir kalelerinin yıkılmaz temel taşıdır.

Kağıt üzerinde kusursuz bir uyumla çalışan bu matematiksel teorileri gerçek dünya uygulamalarına —özellikle de kriptografik algoritmaların çekirdeğine— entegre ederken yüksek performans ve mutlak işlem hassasiyeti gerekir. Aşağıda inceleyeceğimiz Rust implementasyonu, bu soyut altyapıyı dijital dünyaya taşıyan pratik bir laboratuvar işlevi görmektedir. Bu kod parçacığı; Fermat'ın Küçük Teoremi'nin algoritmik gücünden yararlanarak devasa asal cisimlerde (Fp) modüler üs alma işleminin nasıl optimize edildiğini ve normal şartlarda yüksek hesaplama maliyeti gerektiren çarpımsal ters (multiplicative inverse) bulma operasyonunun güvenli, deterministik ve verimli bir şekilde nasıl modellendiğini somutlaştırmaktadır:

/// Sonlu Asal Alan işlemlerini yöneten yapı
pub struct PrimeField {
    pub p: u128, // Büyük asal modül değeri
}
impl PrimeField {
    /// Modüler toplama: (a + b) mod p
    pub fn add(&self, a: u128, b: u128) -> u128 {
        ((a % self.p) + (b % self.p)) % self.p
    }
    /// Modüler çarpma: (a * b) mod p
    pub fn mul(&self, a: u128, b: u128) -> u128 {
        ((a % self.p) * (b % self.p)) % self.p
    }
    /// Modüler üs alma: (base^exp) mod p (Square-and-Multiply)
    pub fn pow(&self, mut base: u128, mut exp: u128) -> u128 {
        let mut result = 1;
        base = base % self.p;
        while exp > 0 {
            if exp % 2 == 1 {
                result = (result * base) % self.p;
            }
            base = (base * base) % self.p;
            exp /= 2;
        }
        result
    }
    /// Fermat'ın Küçük Teoremi ile çarpımsal ters bulma: a^(p-2) mod p
    pub fn invert(&self, a: u128) -> Option<u128> {
        if a % self.p == 0 {
            return None; // Sıfırın çarpımsal tersi yoktur
        }
        Some(self.pow(a, self.p - 2))
    }
}
fn main() {
    // 256-bit benzeri küçük bir asal sayı seçelim
    let field = PrimeField { p: 1000000007 }; // Asal sayı
    let val = 123456789;
    // Çarpımsal tersini hesaplayalım
    if let Some(inv) = field.invert(val) {
        println!("Sayi: {}", val);
        println!("Moduler Ters (val^-1): {}", inv);
        // Doğrulayalım: (val * val^-1) mod p == 1 olmalı
        let proof = field.mul(val, inv);
        println!("Dogrulama (val * val^-1) mod p = {}", proof);
        assert_eq!(proof, 1, "Hata: Modüler ters doğrulanamadı!");
    } else {
        println!("Sıfırın tersi yoktur.");
    }
}

# Sonlu Asal Alan işlemlerini yöneten yapı
class PrimeField:
    def __init__(self, p: int) -> None:
        self.p = p

    def add(self, a: int, b: int) -> int:
        # Modüler toplama: (a + b) mod p
        return ((a % self.p) + (b % self.p)) % self.p

    def mul(self, a: int, b: int) -> int:
        # Modüler çarpma: (a * b) mod p
        return ((a % self.p) * (b % self.p)) % self.p

    def pow(self, base: int, exp: int) -> int:
        # Modüler üs alma: (base^exp) mod p
        result = 1
        base %= self.p
        while exp > 0:
            if exp % 2 == 1:
                result = (result * base) % self.p
            base = (base * base) % self.p
            exp //= 2
        return result

    def invert(self, a: int) -> int | None:
        # Fermat'ın Küçük Teoremi: a^(p-2) mod p
        if a % self.p == 0:
            return None
        return self.pow(a, self.p - 2)


field = PrimeField(1000000007)
val = 123456789
inv = field.invert(val)

if inv is not None:
    print(f"Sayi: {val}")
    print(f"Moduler Ters (val^-1): {inv}")
    proof = field.mul(val, inv)
    print(f"Dogrulama (val * val^-1) mod p = {proof}")
    assert proof == 1, "Hata: Modüler ters doğrulanamadı!"
else:
    print("Sıfırın tersi yoktur.")