BÖLÜM 1: Rastgeleliğin Kısa Tarihi – Kemiklerden Silikona
İnsanlık tarihi, bilinmeyeni bilme, geleceği öngörme ve kaosun içinden bir düzen çıkarma arzusunun tarihidir. Medeniyetimizin şafağından bu yana, belirsizlik hem en büyük korkumuz hem de en büyük heyecan kaynağımız olmuştur. Şans, kader, kısmet veya talih olarak adlandırdığımız bu soyut kavramı somutlaştırma çabası, insanı diğer canlılardan ayıran en temel özelliklerden biridir. Bir hayvan avını yakalayıp yakalayamayacağını hesaplamaz, sadece eyleme geçer; ancak insan, eyleme geçmeden önce olasılıkları tartmak, riskleri ölçmek ve mümkünse sonucu manipüle etmek ister. İşte bu dürtü, bizi bugün kullandığımız süper bilgisayarların, kriptografik algoritmaların ve karmaşık simülasyonların temeline, yani rastgeleliğin tarihsel köklerine götürür.
Tarih öncesi çağlarda, henüz matematik veya istatistik bilimi ortada yokken bile insanlar rastgeleliğin araçlarına sahipti. Bu araçlar silikondan, plastikten veya metalden değil, doğrudan doğanın ve canlının kendisinden geliyordu. Antik çağlarda rastgelelik üretmek için kullanılan en temel donanım, “astragalus” adı verilen aşık kemiğiydi. Koyun veya keçi gibi toynaklı hayvanların arka bacaklarında bulunan bu kemik, neredeyse kusursuz bir rastgele sayı üreteci olarak işlev görüyordu. Aşık kemiğinin dört farklı yüzü vardı ve havaya fırlatıldığında hangi yüzünün geleceği, o dönemin insanı için tanrıların iradesinin bir yansımasıydı. Bu kemiklerin yere düşüş şekli, sadece bir oyunun sonucunu belirlemekle kalmıyor, aynı zamanda hasat zamanını, savaş kararlarını ve hatta kabilelerin göç yollarını tayin ediyordu. O dönemde rastgelelik, istatistiksel bir dağılım değil, ilahi bir mesajlaşma yöntemiydi. İnsanlar, kaosun içinde gizli bir düzen olduğuna ve doğru araçlarla bu düzeni okuyabileceklerine inanıyorlardı.
Zamanla medeniyetler geliştikçe, doğanın sunduğu ham kemiklerin yerini insan elinden çıkma daha simetrik araçlar almaya başladı. Kemiklerin doğal girinti ve çıkıntılarının yarattığı adaletsiz dağılım, yerini daha adil bir şans arayışına, yani zara bıraktı. Antik Mısır mezarlarından çıkan, fildişinden veya taştan oyulmuş zarlar, insanoğlunun şansı standardize etme çabasının ilk kanıtlarıdır. Ancak bu geçiş sadece bir malzeme değişimi değildi; bu, insanlığın “tanrısal irade” kavramından yavaş yavaş “matematiksel olasılık” kavramına geçişinin de habercisiydi. Bir kemiğin hangi yüzünün geleceğini kemiğin fiziksel yapısı belirlerken, küp şeklindeki bir zarın her yüzünün gelme olasılığının eşit olması hedefleniyordu. Bu, kaosun evcilleştirilmesi yolunda atılan devasa bir adımdı. Artık şans, sadece tanrıların elinde olan bir gizem değil, aynı zamanda insan aklıyla üretilen bir nesnenin fiziksel özelliğiydi.
Doğu medeniyetlerinde ise rastgelelik, sayısal bir değerden ziyade bir ikilik (dualite) üzerine kuruluydu. Çin kültürünün kadim metni I-Ching veya Değişimler Kitabı, rastgeleliğin aslında modern bilgisayarların kullandığı ikili sisteme (binary) ne kadar benzediğinin şaşırtıcı bir örneğidir. Civanperçemi sapları kullanılarak yapılan bu kehanet yöntemi, temelde “yin” ve “yang” yani 0 ve 1 mantığına dayalıydı. Rastgele seçilen sapların oluşturduğu kombinasyonlar, evrenin o anki durumunu temsil eden altı çizgili şekiller (heksagramlar) oluşturuyordu. Bu sistem, rastgeleliğin sadece bir sayı üretmek olmadığını, aynı zamanda karmaşık durumları basit “var” veya “yok” kararlarıyla modelleyebileceğini gösteriyordu. Binlerce yıl önce Çinli bilgelerin sapları yere atarak oluşturduğu bu desenler, bugün modern işlemcilerin içinde milyarlarca kez tekrarlanan 0 ve 1 akışının atası sayılabilir.
Ancak insanlık tarihinin en büyük kırılması, mekanik ve ardından elektronik hesaplama makinelerinin icadıyla gerçekleşti. Sanayi Devrimi ve sonrasında gelen bilgi çağı, insanlığı daha önce hiç karşılaşmadığı bir paradoksla yüzleştirdi. Bilgisayarlar, doğaları gereği deterministik makinelerdir. Yani bir bilgisayar, kendisine verilen emirleri harfiyen yerine getiren, mantık kurallarına sıkı sıkıya bağlı, “mantık makineleridir”. Bir bilgisayara “2 artı 2 kaç eder?” diye sorduğunuzda, evrenin sonuna kadar her seferinde “4” cevabını verir. Bu kesinlik, mühendisliğin ve bilimin temelidir. Ancak bu mükemmel düzen, “rastgelelik” ihtiyacı doğduğunda devasa bir engele dönüşür. Tamamen mantıksal kurallara göre çalışan, her adımı öngörülebilir olan bir cihazdan, tamamen öngörülemez, kaotik ve mantıksız bir sayı üretmesini nasıl isteyebilirsiniz? Bu, son derece disiplinli bir askere “kafana göre takıl” emri vermeye benzer; asker bu emri bile bir kural çerçevesinde algılamaya çalışacaktır.
Bilgisayar biliminin şafağında bu sorun, basit bir teknik detaydan çok daha fazlasıydı; felsefi ve pratik bir çıkmazdı. İkinci Dünya Savaşı sırasında, balistik hesaplamalar, nükleer reaksiyon simülasyonları ve şifre çözme çalışmaları için devasa miktarda rastgele sayıya ihtiyaç duyuldu. O dönemde bilim insanları, fiziksel dünyadaki gürültüyü veya kaosu ölçerek rastgele sayı üreten hantal makineler kullanıyorlardı. Ancak elektronik bilgisayarların, özellikle de ENIAC gibi devlerin sahneye çıkmasıyla birlikte, bu yavaş ve fiziksel yöntemler yetersiz kalmaya başladı. Bilgisayarlar saniyede binlerce işlem yapabiliyordu, ancak onlara “rastgele sayı ver” dediğinizde duraksıyorlardı. Çünkü onların dünyasında tesadüfe yer yoktu.
İşte tam bu noktada, modern bilgisayar mimarisinin babası sayılan John von Neumann sahneye çıktı. Von Neumann, Manhattan Projesi kapsamında nükleer fizyon süreçlerini modellerken, nötronların kaotik hareketlerini simüle etmek zorundaydı. Bu yöntem bugün “Monte Carlo Simülasyonu” olarak bilinir ve çalışması için çok hızlı bir şekilde, çok miktarda rastgele sayıya ihtiyaç duyar. Fiziksel bir cihazdan sayı beklemek, elektronik bir beyin olan ENIAC için kabul edilemez bir zaman kaybıydı. Von Neumann, dahice ama bir o kadar da kusurlu bir fikir ortaya attı: Eğer bilgisayar gerçek anlamda rastgele davranamıyorsa, biz de ona rastgeleymiş gibi görünen sayılar ürettiririz. Yani, kaosu taklit eden bir matematiksel formül kullanırız.
Von Neumann’ın geliştirdiği bu yöntem “Middle-Square” yani “Ortayı Kareleme” yöntemi olarak tarihe geçti. Fikir, kağıt üzerinde son derece basit ve zarifti. Bir tohum sayı (seed) alırsınız, örneğin 4 basamaklı bir sayı. Sonra bu sayının karesini alırsınız. Ortaya çıkan sonucun ortasındaki rakamları kesip alırsınız ve bu yeni sayıyı bir sonraki rastgele sayı olarak kullanırsınız. Sonra bu yeni sayının da karesini alırsınız, yine ortasını kesersiniz ve süreç böyle devam eder. İlk bakışta bu işlem, sayıları karıştırıp tanınmaz hale getiriyor gibi görünür. Sayıların karesini almak onları hızla büyütür, basamakları değiştirir ve insan gözü için takip edilmesi zor bir karmaşa yaratır. Bu yöntem, bilgisayarın hafızasında çok az yer kaplıyordu ve işlemci gücünü minimum düzeyde kullanıyordu, ki 1940’ların teknolojisi için bu hayati bir önem taşıyordu.
Ancak Ortayı Kareleme yönteminin ölümcül bir kusuru vardı. Matematiksel kaos, gerçek kaos gibi davranmıyordu. Belirli sayı dizileriyle başlandığında, algoritma bir süre sonra kendini tekrar eden kısa döngülere giriyor veya daha kötüsü, hızla sıfıra çöküyordu. Düşünün ki bir sayının karesini aldınız ve ortadaki rakamlar tesadüfen “0000” geldi. Sıfırın karesi sıfırdır. Ortası yine sıfırdır. Algoritma bir kez bu kara deliğe düştüğünde, sonsuza kadar sadece “0” üretmeye başlar. Rastgelelik aniden donar ve yerini sonsuz bir hiçliğe bırakır. Von Neumann elbette bu tehlikenin farkındaydı. Ancak o dönemde yapılan simülasyonlar sınırlıydı ve “yeterince uzun süre” rastgele giden bir dizi, işlerini görmeye yetiyordu. Von Neumann bu durumu kendi tarzıyla şöyle özetlemişti: “Aritmetik yöntemlerle rastgele sayılar üretmeye çalışan herkes, günah işlemektedir.” O, bunun gerçek bir rastgelelik olmadığını, sadece geçici bir yalan, bir illüzyon olduğunu biliyordu. Ama o an için eldeki en iyi illüzyon buydu.
Bu ilk denemeler, bilgisayar bilimcilerine çok önemli bir ders verdi: Deterministik bir evrende (bilgisayarın içinde) gerçek kaosu yaratmak imkansızdır. Yarattığınız her şey, ne kadar karmaşık görünürse görünsün, aslında bir formülün ürünüdür ve o formülü bilen biri için tamamen öngörülebilirdir. Bu ders, sonraki on yıllarda geliştirilecek olan tüm Sözde Rastgele Sayı Üreteçlerinin (PRNG – Pseudo Random Number Generators) temel felsefesini oluşturdu. Amaç artık kusursuz rastgeleliği bulmak değil, insan algısının ve analiz yeteneğinin sınırlarını zorlayacak kadar uzun ve karmaşık desenler yaratmaktı.
Günümüze geldiğimizde ise rastgele sayı ihtiyacı, Von Neumann’ın hayal bile edemeyeceği boyutlara ulaştı. Artık sadece nükleer simülasyonlar için değil, hayatımızın her alanında milyarlarca rastgele sayıya muhtacız. İnternet bankacılığına girerken kullandığınız şifreleme anahtarları, oynadığınız video oyunundaki düşmanların yapay zeka kararları, hava durumu tahmin modelleri, hatta Spotify listenizdeki şarkıların sıralaması bile bu görünmez sayılara dayanıyor. Her bir akıllı telefon, her bir sunucu, saniyede milyonlarca kez o dijital zarı atmak zorunda. Eğer bu zarlar hileli olursa, eğer desenler tahmin edilebilir olursa, dijital dünyamızın güvenliği bir iskambil kulesi gibi çöker.
Modern dünya, silikon çiplerin içindeki o mikroskobik dünyada, antik çağların aşık kemiklerinin dijital bir versiyonunu döndürüp durmaktadır. Ancak artık mesele tanrıların ne dediğini anlamak değil, kötü niyetli bir hacker’ın veya meraklı bir gözün bu desenleri çözmesini engellemektir. Von Neumann’ın “günahı”, bugün modern kriptografinin temel taşı haline gelmiştir. Bizler, mükemmel düzenin makinelerine, kusurlu ve kaotik davranmayı öğretmek zorundayız. Çünkü hayatın kendisi kaotiktir ve hayatı simüle etmek isteyen her makine, bu kaostan bir parça taşımak zorundadır.
Tarihsel süreç, kemiklerin çıkardığı tok sesten, işlemcilerin sessiz ve soğuk matematiksel döngülerine evrildi. Ancak özündeki arayış hiç değişmedi: Belirsizliği kontrol altına almak. İlk insanlar bunu hayatta kalmak için yapıyordu, biz ise dijital kimliğimizi, paralarımızı ve sırlarımızı korumak için yapıyoruz. Rastgeleliğin tarihi, aslında insanın kontrol edemediği evrenle, kendi yarattığı ve tamamen kontrol edebildiği makineler arasında bir köprü kurma çabasıdır. Bu köprü bazen sallanır, bazen çöker (Middle-Square yönteminde olduğu gibi), ama insanlık her seferinde daha sağlam, daha karmaşık ve daha “tahmin edilemez” bir köprü inşa etmenin yolunu bulmuştur. İşte bu bölümde incelediğimiz tarihsel miras, videoda daha sonra detaylandırılacak olan karmaşık algoritmaların, lineer benzeşimlerin ve modern hackleme tekniklerinin neden var olduğunun ve neden bu kadar kritik olduğunun temel gerekçesidir. Bilgisayarların “şanslı” olmayı öğrenme süreci, aslında onların insanlaşma sürecinin de bir parçasıdır.
BÖLÜM 2: Büyük İllüzyon – Sözde Rastgelelik (Pseudo-Randomness)
Bilgisayar ekranınızda dönen bir yükleme ikonu, dijital bir kumarhanede çevrilen slot makinesinin çarkları veya en sevdiğiniz müzik uygulamasının size sunduğu sürpriz bir şarkı… Tüm bu deneyimler, modern çağın en başarılı illüzyonlarından birinin üzerine inşa edilmiştir. Bu illüzyonun adı rastgeleliktir; ancak dijital dünyada deneyimlediğimiz şey, gerçekliğin kaotik doğasından tamamen farklı, soğuk ve hesaplı bir taklitten ibarettir. Bir önceki bölümde insanlığın kemiklerden silikona uzanan yolculuğunda nasıl bir arayış içinde olduğunu görmüştük; şimdi ise bu silikon beyinlerin, aslında hiçbir zaman zar atmadığını, sadece zar atıyormuş gibi yapmakta ustalaştığını derinlemesine inceleme vaktidir. Bu, deterministik bir evrende yaşayan bir makinenin, kaotik bir evreni taklit etme çabasının hikayesidir.
Bilgisayarların en temel çalışma prensibi, mutlak itaat ve kesinlik üzerine kuruludur. Bir işlemcinin içindeki milyarlarca transistör, elektrik akımının varlığına veya yokluğuna göre sadece iki durumda bulunabilir: Açık veya kapalı, bir veya sıfır. Bu ikili sistemde “belki”, “bazen” veya “canım öyle istedi” gibi kavramlara yer yoktur. Bir bilgisayara aynı girdiyi verdiğinizde, evrenin sonuna kadar aynı çıktıyı üretmek zorundadır. Bu deterministik yapı, mühendislik harikası binalar inşa etmemizi, uzaya roket göndermemizi ve küresel iletişimi sağlamamızı mümkün kılan güvenilirliğin kaynağıdır. Ancak aynı özellik, bilgisayarın özgür iradeye veya şansa sahip olmasını imkansız kılar. Bir makineye “bana rastgele bir sayı söyle” dediğinizde, o makine insani bir kararsızlık yaşamaz; bunun yerine hafızasındaki önceden yazılmış devasa bir kural kitabına başvurur. İşte bu yüzden bilgisayar bilimlerinde üretilen sayılara “rastgele” değil, “sözde rastgele” (pseudo-random) denir. Bu terimdeki “sözde” ifadesi, üretilen sayıların kalitesiz olduğunu değil, kökeninin bir tesadüfe dayanmadığını, tamamen matematiksel bir kurgunun ürünü olduğunu belirtir.
Bu durumu anlamak için devasa, sonu gelmeyen bir sayılar kitabı hayal edin. Bu kitap, bilgisayarınızın işletim sisteminin derinliklerinde kodlanmış matematiksel bir fonksiyondur. Bilgisayara bir sayı istediğinizi söylediğinizde, o aslında zihinsel bir zar atmaz; sadece bu sanal kitabın kapağını açar, parmağını bir satıra koyar ve orada yazan sayıyı size okur. Siz ikinci bir sayı istediğinizde, parmağını bir alt satıra kaydırır ve sıradaki sayıyı okur. Eğer bilgisayar bu kitabı her seferinde aynı sayfadan, aynı satırdan okumaya başlarsa, size vereceği sayılar daima aynı sırayla gelecektir: 5, 12, 89, 4… Bilgisayarı kapatıp açsanız, format atsanız, hatta on yıl sonra tekrar deneseniz bile, eğer okumaya başladığı nokta aynıysa, sonuçlar da tıpatıp aynı olacaktır. İşte bu “okumaya başlanan nokta”, bizim “tohum” veya teknik adıyla “seed” dediğimiz kavramdır.
Tohum, rastgelelik ağacının kökü, kaosun başlangıç noktasıdır. Deterministik bir makinenin ürettiği sayı dizisi, aslında önceden belirlenmiş bir kaderin, adım adım tezahür etmesinden başka bir şey değildir. Bu kaderin nasıl şekilleneceği ise tamamen başlangıçtaki o tek bir sayıya, tohuma bağlıdır. Eğer tohumu biliyorsanız, ağacın hangi dalının nereye uzanacağını, hangi yaprağın ne zaman düşeceğini en ince ayrıntısına kadar bilirsiniz. Bu noktada yazılımcıların karşısına çıkan en büyük zorluk, bu deterministik döngüyü kırmak ve kullanıcıya gerçek bir kaos hissi yaşatmaktır. Eğer bir oyun programcısı, oyun her açıldığında tohum olarak sabit bir sayı, örneğin “1” sayısını kullanırsa, oyundaki düşmanlar her seferinde aynı yerden çıkar, sandıklardan hep aynı hazineler düşer ve kartlar hep aynı sırayla dağıtılır. Bu, oyunun öngörülemezlik büyüsünü tamamen bozar.
Bu sorunu çözmek için bilgisayar mühendisleri, makinenin içinde sürekli değişen bir değişken arayışına girmişlerdir. Sabit bir donanımın içinde ne sürekli değişebilir? Cevap, zamanın kendisidir. Neredeyse tüm modern sistemler, rastgele sayı üretimine başlamadan önce tohum değeri olarak o anki zamanı kullanır. Ancak bu zaman, bizim duvarda gördüğümüz saat ve dakika gibi kaba bir ölçü değildir. Genellikle 1 Ocak 1970 tarihinden itibaren geçen milisaniye (hatta bazen mikrosaniye) sayısı olarak ifade edilen devasa bir tam sayıdır. Siz bir web sitesine girdiğinizde veya bir oyun başlattığınızda, bilgisayar o anki milisaniyeyi yakalar ve bunu o devasa sayılar kitabının sayfa numarası olarak kullanır. Zaman asla geriye akmadığı ve sürekli ilerlediği için, her denemenizde kitabın farklı bir sayfasını açmış olursunuz. Bu da size her seferinde farklı, taze ve öngörülemez bir sayı dizisiyle karşılaştığınız hissini verir. Oysa değişen tek şey, kitabın okumaya başlandığı satırdır; kitabın içeriği, yani kullanılan formül ve sayıların birbirini takip etme mantığı daima aynıdır.
Bu durumun felsefi ve pratik sonuçları büyüleyicidir. Eğer bilgisayarınızın saatini tam olarak, mikrosaniyesi mikrosaniyesine geçmişteki bir anla eşleştirebilseydiniz, o an üretilen şansı tekrar yaşayabilirdiniz. Dijital dünyada kader, zamanın bir fonksiyonudur. Saatinizi değiştirmek, kelimenin tam anlamıyla şansınızı değiştirmek demektir. Bu, bir önceki bölümde bahsettiğimiz ilahi irade arayışının yerini, zamanlama ustalığına bırakmasıdır. Bir hacker veya bir oyuncu için bu bilgi, sisteme karşı kazanılan en büyük kozdur. Eğer sistemin hangi tohumu kullandığını (yani saatin tam olarak kaç olduğunu) biliyorsanız, gelecekte hangi sayıların geleceğini %100 kesinlikle bilebilirsiniz. Artık ortada bir şans oyunu kalmamış, her şey bir hafıza oyununa dönüşmüştür.
Bu illüzyonu daha somutlaştırmak için günlük hayatta sıkça kullandığımız müzik platformlarının “karışık çal” (shuffle) özelliğini ele alalım. Çoğu kullanıcı, karışık çal butonuna bastığında, uygulamanın her şarkı bitiminde sanal bir zar attığını ve kütüphanedeki binlerce şarkı arasından rastgele birini seçtiğini düşünür. Oysa perde arkasında işleyen mekanizma bu değildir. Siz o butona bastığınız anda, algoritma elindeki tohum değerini (yine muhtemelen zamanı veya kullanıcı verilerinizi) kullanarak, çalınacak şarkıların tam listesini o saniyede oluşturur. Yani 50. sırada hangi şarkının çalacağı, siz daha ilk şarkıyı dinlerken bellidir. Müzik çalarınız her şarkı bittiğinde “Acaba şimdi ne çalsam?” diye düşünmez; sadece önceden oluşturulmuş listenin bir sonraki satırını okur. Bu liste o kadar uzundur ve insan hafızası sıralamaları tutmakta o kadar zayıftır ki, biz bu önceden belirlenmiş sırayı “rastgele” zannederiz. Hatta ilginç bir detay olarak, insan beyni gerçek rastgeleliği algılamakta zorlandığı için (örneğin aynı sanatçıdan üç şarkının peş peşe gelmesi gerçek rastgelelikte mümkündür ama insanlara hatalı gelir), Spotify gibi firmalar bu algoritmaları “daha az rastgele” ama “daha rastgele hissettiren” şekilde manipüle etmişlerdir. Ancak özünde, dinlediğiniz sıra bir anlık tesadüf değil, matematiksel bir permütasyondur.
Bu deterministik yapı, video oyun dünyasında “prosedürel üretim” (procedural generation) olarak bilinen tekniğin de kalbidir. Minecraft veya No Man’s Sky gibi devasa evrenlere sahip oyunları düşünün. Bu oyunlarda milyarlarca gezegen, trilyonlarca arazi parçası bulunur. Oyunun bu kadar veriyi diskte saklaması imkansızdır. Peki, siz ve arkadaşınız aynı koordinata gittiğinizde nasıl aynı dağı, aynı ağacı görüyorsunuz? Çünkü oyun, o dünyayı yaratırken rastgele davranmıyor; belirli bir tohum (seed) değerini formüle sokuyor. Siz bir “dünya tohumu” (world seed) girdiğinizde, oyun motoru bu sayıyı alıyor ve tüm evreni bu sayıdan türetiyor. Dağların yüksekliği, nehirlerin kıvrımı, madenlerin yerleşimi; hepsi o ilk tohum sayısının matematiksel birer yansımasıdır. Aynı tohumu girerseniz, aynı evreni yaratırsınız. Bu, sözde rastgeleliğin en muazzam kanıtıdır: Kaos gibi görünen o karmaşık araziler, aslında tek bir sayının farklı frekanslardaki yankılarından ibarettir.
Buradaki illüzyonun gücü, dizinin uzunluğunda ve karmaşıklığında yatar. Bilgisayarların kullandığı sayı üretme algoritmaları (PRNG’ler), o kadar uzun periyotlara sahiptir ki -bazıları evrendeki atom sayısından bile fazla sayı ürettikten sonra başa döner- bir insan ömrü bu döngüyü fark etmeye yetmez. Bizler, kısıtlı algımızla sadece “şimdi” üretilen sayıya odaklanırız ve bunun bir geçmişi veya geleceği olmadığını sanırız. Oysa her sayı, kendinden önceki sayının doğrudan bir sonucudur ve kendinden sonraki sayının tek nedenidir. Bu zincirleme reaksiyon, ilk tohum atıldığı andan itibaren bellidir. Tıpkı bir domino taşları dizisi gibi; taşlar ne kadar karmaşık şekillerde dizilmiş olursa olsun, ilk taşa dokunulduğu an, son taşın ne zaman ve nereye düşeceği fizik kuralları çerçevesinde kesinleşmiştir. Bilgisayarın yaptığı tek şey, bu domino taşlarının yıkılışını bize izletmektir.
Ancak bu sistemin kusursuz görünen zırhında bir çatlak vardır. Deterministik evren, dışarıdan müdahaleye kapalıdır ama gözleme açıktır. Eğer birisi, yani bir hacker, sistemin kullandığı formülü (kitabı) ele geçirir ve o anki tohum değerini (hangi sayfada olunduğunu) tahmin edebilirse, illüzyon anında çöker. Artık o kişi için “şans” diye bir şey kalmaz; o kişi sistemin tanrısı haline gelir. Geleceği görmek, sadece bir sonraki sayıyı hesaplamaktan ibaret olur. İşte bu yüzden, videoda da göreceğimiz üzere, hacker’ların amacı sistemi kırmak değil, sistemin hangi tohumu kullandığını anlamaktır. Çünkü tohumu bilen, sonucu bilir. Bu bilgi, kaybedilen bir hesabın kurtarılmasından, bir şans oyununda büyük ikramiyeyi kazanmaya kadar uzanan sınırsız bir gücün anahtarıdır.
Sözde rastgelelik, modern teknolojinin hem en büyük gücü hem de en yumuşak karnıdır. Bize sonsuz bir çeşitlilik ve kaos sunarken, aslında her şeyin bir düzen içinde olduğunu, tesadüf sandığımız şeylerin sadece henüz formülünü çözemediğimiz matematiksel ilişkiler olduğunu fısıldar. Bilgisayarlar zar atmaz, bilgisayarlar hesap yapar. Ve bu hesapta, eğer dikkatli bakarsanız, şansın yerini matematiğin soğuk kesinliğinin aldığını görürsünüz. Bu illüzyonu kabul etmek, dijital dünyayla kurduğumuz ilişkinin temelini anlamak demektir. Ekranınızdaki o sayı gerçekten rastgele seçilmedi; o sayı, milyarlarca işlem, zamanın akışı ve karmaşık algoritmaların birleşimiyle, sizin için orada olması “gerektiği” için orada belirdi. Bu, dijital kaderin ta kendisidir.
BÖLÜM 3: Basit Matematik – Lineer Benzeşim Üreteçleri (LCG)
Önceki bölümlerde, insanlığın kemiklerden silikona uzanan rastgelelik arayışını ve bilgisayarların deterministik dünyasında “rastgelelik” kavramının aslında nasıl büyük bir illüzyon olduğunu detaylıca incelemiştik. Bilgisayarların zar atmadığını, sadece devasa bir kitaptan sayı okuduğunu ve bu kitabın hangi sayfasının açılacağının “tohum” (seed) değeriyle belirlendiğini artık biliyoruz. Şimdi ise o kitabın nasıl yazıldığını, yani sayfaların içini dolduran o sihirli mürekkebi inceleme vakti geldi. Bu mürekkep, bilgisayar biliminin en zarif, en eski ve en çok kullanılan formüllerinden biri olan Lineer Benzeşim Üreteçleri, yani İngilizce kısaltmasıyla LCG’dir (Linear Congruential Generator). Modern tarayıcılarda, eski video oyunlarında ve sayısız simülasyonda karşımıza çıkan o meşhur “Math.random()” fonksiyonunun atası ve çoğu zaman ta kendisi olan bu yapı, karmaşıklığın aslında ne kadar basit bir temelden doğabileceğini gösteren muazzam bir matematiksel mimaridir.
Lineer Benzeşim Üreteci’nin kalbinde yatan fikir, lise matematiğinden tanıdığımız doğrusal bir denklem ile saatlerde gördüğümüz döngüsel mantığın birleşimidir. İlk bakışta son derece sıradan görünen bu formül, doğru sayılarla beslendiğinde kaotik bir nehir gibi akabilirken, yanlış ellerde sadece kendini tekrar eden sıkıcı bir döngüye dönüşebilir. Bu algoritmanın güzelliği, sadeliğindedir. Karmaşık kriptografik sistemler binlerce satır kod ve ağır işlem gücü gerektirirken, LCG tek bir satıra sığar ve işlemciyi neredeyse hiç yormaz. İşte bu verimlilik, onun on yıllar boyunca bilgisayar dünyasının standart “zar atma” mekanizması olmasını sağlamıştır. Formülü anlamak için, onu oluşturan üç temel dişliyi (çarpan, artış ve modül) ve bu dişlilerin zaman (önceki sayı) ile nasıl etkileşime girdiğini bir saat ustası titizliğiyle parçalarına ayırmamız gerekir.
Formülün anatomisi (Girdi * Çarpan + Artış) % Modül şeklinde ifade edilir. Bu denklemde “Girdi”, bir önceki adımda ürettiğimiz rastgele sayıyı (veya ilk adımda tohum değerini) temsil eder. Buradaki amaç, elimizdeki sayıyı alıp onu tanınmayacak hale gelene kadar yoğurmak, esnetmek ve kesip biçmektir. İlk işlem olan çarpma, bu sürecin “esnetme” aşamasıdır. Girdi sayısını büyük bir “Çarpan” değeriyle çarptığımızda, sayı sayı doğrusu üzerinde devasa bir sıçrama yapar. Bu sıçrama, sayılar arasındaki ilişkiyi insan gözünden saklamanın ilk adımıdır. Eğer çarpan küçük olursa, sayılar birbirine yakın kalır ve desenler kolayca fark edilir. Ancak devasa bir çarpan, sayıyı hafızanın sınırlarına kadar iter. Bu işlem, bir hamur parçasını alıp onu metrelerce uzatmak gibidir; hamurun içindeki her bir molekül (bilgi) birbirinden uzaklaşır ve yapı kaotikleşmeye başlar.
Çarpma işleminin ardından gelen “Artış” (toplama) kısmı, formülün hayati bir sigortasıdır. Önceki bölümde Von Neumann’ın “Ortayı Kareleme” yönteminin nasıl sıfıra çökebileceğinden bahsetmiştik; eğer elinizdeki sayı sıfırsa ve sadece çarpma işlemi yapıyorsanız, sonucunuz sonsuza kadar sıfır kalacaktır (0 * 5 = 0). İşte “Artış” değeri burada devreye girer. Sonuç ne olursa olsun, üzerine sabit bir sayı eklemek, dizinin sıfır tuzağına düşmesini engeller. Bu, sayı doğrusu üzerinde yapılan bir “öteleme” hareketidir. Bu öteleme, üretilen sayıların birbirine olan mesafesini asimetrik hale getirir ve tahmin edilebilirliği zorlaştırır. Çarpma işlemi kaosu yaratırken, toplama işlemi sürekliliği ve çeşitliliği garanti altına alır.
Ancak LCG’nin asıl büyüsü, denklemin sonundaki o garip sembolde, yani “%” (modül) işleminde gizlidir. Matematikte modüler aritmetik olarak bilinen bu işlem, doğrusal olarak sonsuza giden sayıları alıp sınırlı bir alana hapseder. Modül, bir bölme işleminden kalan sayıyı bulmak demektir. Örneğin, “7 mod 3” işleminin sonucu 1’dir; çünkü 7’yi 3’e bölerseniz kalan 1 olur. Bu basit “kalanı bulma” işlemi, bilgisayar biliminde sayıların belirli bir sınırı asla aşmamasını sağlar. Videoda kullanılan ve bizim de zihnimizde canlandırmamız gereken en güçlü analoji “Asteroids” oyunudur. Bu klasik oyunda, uzay geminiz ekranın sağ kenarından dışarı çıktığında kaybolmaz; anında sol kenardan tekrar belirir. Ekranın üstünden çıkarsa, alttan geri girer. Uzay gemisi için evren sonsuz değildir, kendi üzerine katlanan bir silindir gibidir.
LCG formülündeki modül işlemi de sayılara tam olarak bunu yapar. Çarpma ve toplama işlemleriyle devasa boyutlara ulaşan, milyarlara varan o sayı, modül değerine (ekranın sınırına) ulaştığı anda “wrap around” yapar, yani başa sarar. Sayı doğrusunu düz bir çizgi yerine, bir çember olarak düşünün. Sayılar büyüdükçe bu çemberin etrafında dönerler. Modül işlemi, sayının çember üzerindeki o anki konumudur. Bu mekanizma sayesinde, bilgisayar sonsuz büyüklükte sayılarla uğraşmak zorunda kalmaz. Her zaman 0 ile Modül değeri arasında bir sonuç elde ederiz. Bu, rastgele sayıların “normalize” edilmesini sağlar. Örneğin, bir zar atmak istiyorsanız ve modülünüz 6 ise, sonuçlarınız her zaman 0 ile 5 arasında (bilgisayar saymaya 0’dan başlar) olacaktır.
Modül işleminin yarattığı bu döngüsellik, rastgelelik algısının temel taşıdır. Doğrusal bir artış (örneğin her seferinde 1 eklemek: 1, 2, 3, 4…) insan beyni için son derece tahmin edilebilirdir. Ancak LCG’de sayı, çarpan etkisiyle modül çemberinin etrafında birden fazla tur atar ve her seferinde farklı bir noktaya “iniş” yapar. Bir turunda 3. dereceye, diğer turunda 250. dereceye, bir sonrakinde 15. dereceye düşebilir. Dışarıdan bakan bir gözlemci için bu iniş noktaları tamamen rastgele görünür. Oysa içerideki mekanik, her seferinde geminin kaç tur atacağını ve tam olarak hangi koordinata ineceğini kesin bir matematiksel hassasiyetle hesaplamaktadır. İşte “sözde” rastgeleliğin özü budur: Çok hızlı dönen bir çarkın nerede duracağını, çarkı çeviren güç (çarpan ve artış) ile çarkın boyutu (modül) arasındaki ilişki belirler.
Ancak bu mekanizmanın kusursuz işlemesi için seçilen sayıların (parametrelerin) birbirleriyle olan uyumu hayati önem taşır. Rastgele sayı üretecinin “kalitesi”, bu parametrelerin seçimine bağlıdır. Eğer yanlış sayılar seçerseniz, üreteciniz çok kısa bir sürede kendini tekrar etmeye başlar. Örneğin, modül olarak 10 seçerseniz, üretebileceğiniz en fazla 10 farklı sayı vardır. 11. adımda mutlaka daha önce ürettiğiniz bir sayıyı üretirsiniz ve döngü (periyot) başa sarar. İyi bir LCG’de modül değeri genellikle bilgisayarın işlemci mimarisine uygun olarak çok büyük seçilir (örneğin
231−12^{31}-1231−1
veya
2322^{32}232
). Bu, milyarlarca sayı üretildikten sonra ancak tekrarın başlayacağı anlamına gelir ki bu da çoğu uygulama için yeterlidir. Ayrıca “Artış” değeri ile “Modül” değeri aralarında asal olmalıdır (ortak bölenleri olmamalıdır); aksi takdirde çemberin üzerindeki bazı noktalara asla uğranmaz ve potansiyel rastgele sayı havuzunuz daralır.
Bu matematiksel teoriyi görselleştirmek, LCG’nin neden “kalitesiz” veya “eski teknoloji” olarak adlandırıldığını anlamak için en iyi yoldur. İnsan beyni desenleri yakalamakta ustadır, ancak sayılar bir liste halindeyken bu desenleri görmek zordur. Sayıları görselleştirdiğimizde ise gerçekler tüm çıplaklığıyla ortaya çıkar. Videoda bahsedilen deneyde olduğu gibi, LCG ile üretilen sayıları ardışık çiftler halinde alıp bir koordinat sistemine (X, Y) yerleştirdiğinizi hayal edin. İlk üretilen sayı X, ikinci üretilen sayı Y olsun. Sonra üçüncü sayı X, dördüncü sayı Y… Bu şekilde binlerce noktayı bir kareye serpiştirdiğimizde ne görmeyi beklersiniz?
Gerçekten rastgele bir dağılımda, karenin her yerinin homojen bir şekilde, tıpkı karıncalı bir televizyon ekranı veya uzay boşluğundaki yıldızlar gibi dolması gerekir. Hiçbir belirgin şekil, çizgi veya kümelenme olmamalıdır. Kaosun resmi budur: Düzensiz, öngörülemez ve her yere eşit dağılmış gürültü. Ancak LCG ile üretilen noktaları bu şekilde çizdirdiğinizde, şok edici bir manzarayla karşılaşırsınız. Noktalar rastgele dağılmak yerine, belirli çizgiler üzerinde hizalanmaya başlar. Sanki görünmez bir manyetik alan onları sıraya dizmiş gibidir. Bu duruma “Marsaglia Etkisi” veya daha teknik adıyla “Spektral Test” denir. George Marsaglia’nın meşhur makalesinde dediği gibi: “Rastgele sayılar genellikle düzlemlere düşer.”
Bu çizgiler, LCG formülünün doğrusal doğasının kaçınılmaz bir sonucudur. Formül
Y=aX+cY = aX + cY=aX+c
yapısında olduğu için, üretilen her sayı bir öncekiyle doğrusal bir ilişki içindedir. Modül işlemi bu ilişkiyi kırıp bükse de, ilişkiyi tamamen yok edemez; sadece parçalar ve paralel doğrulara böler. Görselleştirmede gördüğünüz o paralel çizgiler, aslında modül işlemiyle “ekranın diğer tarafından çıkan” o doğrusal fonksiyonun parçalarıdır. Tıpkı bir mısır tarlasına yukarıdan baktığınızda bitkilerin rastgele dağılmış gibi görünmesi, ama tarlaya belirli bir açıyla ve yere yakın baktığınızda o mükemmel ekim sıralarını (düz çizgileri) görmeniz gibi, LCG sayıları da doğru açıdan bakıldığında (veya doğru boyutta incelendiğinde) düzenlerini ele verirler.
Kötü parametrelerle kurulmuş bir LCG’de bu çizgiler çok belirgindir ve sayıları azdır. Bu, o rastgele sayı üretecinin aslında “kısıtlı” bir özgürlüğe sahip olduğu anlamına gelir. Örneğin, bir LCG kullanarak üç boyutlu bir küpün içine noktalar koymaya çalışırsanız, bu noktaların küpün hacmini doldurmak yerine, küpün içinde asılı duran birkaç ince cam levha üzerinde toplandığını görürsünüz. Bu levhaların arasındaki boşluklara hiçbir sayı düşmez. İşte bu “boşluklar”, rastgeleliğin kalitesizliğinin kanıtıdır. Eğer bir şifreleme anahtarı veya bir piyango çekilişi bu boşluklara denk gelen bir sayıya ihtiyaç duyuyorsa, o sayı asla seçilemeyecektir. Bu durum, sistemin tahmin edilebilirliğini artırır. Bir hacker, sayıların sadece bu düzlemler üzerinde oluştuğunu bildiğinde, arama yapması gereken alanı milyarlarca kat küçültmüş olur.
LCG’nin ürettiği bu desenler, sadece görsel bir kusur değil, aynı zamanda pratik bir güvenlik açığıdır. Videoda gösterilen, görüntünün belirli boyutlarda net çizgilere dönüşmesi, piksellerin (sayıların) birbirleriyle olan matematiksel korelasyonunu (bağıntısını) gösterir. Gerçek rastgelelikte bir sonraki pikselin rengi, bir öncekine bağlı olmamalıdır. Ancak LCG’de bir piksel siyahsa, bir sonrakinin beyaz olma olasılığı, formülün yapısı gereği değişebilir. Bu ince bağımlılıklar, hassas simülasyonlarda (örneğin hava durumu modellerinde veya moleküler dinamik hesaplamalarında) hatalı sonuçlara yol açabilir. Oyunlarda ise oyuncuların “şanslı” anları veya “hileli” durumları hissetmesine neden olan o ince yapaylık hissini yaratır.
Buna rağmen LCG’nin tarihsel ve pratik önemi yadsınamaz. Bilgisayar kaynaklarının kısıtlı olduğu dönemlerde, tek bir çarpma ve toplama işlemiyle “yeterince iyi” rastgelelik sağlaması devrim niteliğindeydi. C programlama dilindeki rand(), Java’daki java.util.Random, eski Unix sistemlerindeki üreteçler hep bu prensiple çalıştı. “Basit Matematik” başlığı altında incelediğimiz bu yapı, aslında karmaşıklık ile verimlilik arasındaki hassas dengenin bir anıtıdır. Formülün her bir parçası; çarpanın kaosu, artışın sürekliliği ve modülün döngüselliği, dijital dünyanın rastgelelik ihtiyacını karşılamak için mükemmel bir uyum içinde çalışır. Ancak gördüğümüz gibi, bu uyumun bir bedeli vardır: Desenler.
Bu bölümü tamamlarken, LCG’nin aslında bir “matematiksel kristal” olduğunu söyleyebiliriz. Uzaktan bakıldığında amorf ve şekilsiz (rastgele) görünür, ancak mikroskop altında (görselleştirme ve analizle) incelendiğinde son derece düzenli, katı ve kırılabilir bir yapıya sahip olduğu anlaşılır. Bilgisayar korsanları için bu düzen, bir zayıflık; matematikçiler için ise bir estetik meseledir. LCG, modern kriptografi için artık “güvensiz” kabul edilse de, onun çalışma prensibi, sayıların nasıl manipüle edilebileceğine dair bize eşsiz bir ders verir. Bir sonraki bölümde, bu kristal yapının nasıl kırılacağını, yani formülün nasıl tersine çevrilerek “geleceğin” önceden görülebileceğini incelediğimizde, LCG’nin bu basitliğinin nasıl bir silaha dönüştüğüne tanık olacağız. Doğrusal olan her şey, tersine çevrilebilir; ve LCG, adından da anlaşılacağı gibi, doğrusaldır.
BÖLÜM 4: Şifreyi Çözmek – LCG Nasıl Hacklenir?
Şu ana kadar yaptığımız yolculukta, rastgeleliğin tarihsel kökenlerinden başlayıp, bilgisayarların bu kavramı nasıl taklit ettiğini ve Lineer Benzeşim Üreteçleri (LCG) adını verdiğimiz o basit ama etkili matematiksel makinenin nasıl çalıştığını tüm detaylarıyla inceledik. Önceki bölümlerde, bu makinenin ileriye doğru nasıl işlediğini, yani bir tohum sayısını alıp onu nasıl çarpıp, toplayıp ve bölerek yeni bir sayı ürettiğini gördük. Bu süreç, dışarıdan bakıldığında kaotik ve geri döndürülemez bir nehir gibi görünüyordu. Ancak şimdi, akıntının tersine yüzme vaktidir. Bir hacker’ın zihni, mühendisin zihninden farklı çalışır; mühendis bir şeyi nasıl inşa edeceğini düşünürken, hacker o yapının nasıl söküleceğini, vidalarının nasıl gevşetileceğini ve en önemlisi, sürecin nasıl tersine çevrileceğini düşünür. Bu bölümde, matematiksel dedektifliğin zirvesine çıkacak ve imkansız gibi görünen bir soruyu cevaplayacağız: Eğer elimizde sadece şu anki rastgele sayı varsa, geçmişte üretilen sayıyı, hatta tüm sistemi başlatan o gizli tohumu bulabilir miyiz? Bu, dijital bir zaman makinesi inşa etmek gibidir ve bu makinenin yakıtı, modüler aritmetiğin derinliklerinde saklı olan “Modüler Ters” kavramıdır.
Bir Lineer Benzeşim Üreteci’ni hacklemek, aslında bir cinayet mahallindeki kanıtları toplayıp katilin kim olduğunu bulmaya benzer, ancak buradaki katil bir matematiksel formüldür. Normal şartlarda, lise yıllarımızdan hatırladığımız temel cebir kuralları bize denklemlerin tersine çevrilebilir olduğunu öğretmiştir. Eğer birisi size “Aklımda bir sayı tuttum, bunu 2 ile çarptım ve 5 ekledim, sonuç 15 oldu” derse, bu gizemli sayıyı bulmak için dahi olmanıza gerek yoktur. İşlemleri sondan başa doğru ve ters işaretleriyle yaparsınız: 15’ten 5 çıkarırsınız (10 kalır), sonra 10’u 2’ye bölersiniz ve aklındaki sayının 5 olduğunu şıp diye bulursunuz. Bu, doğrusal ve deterministik bir dünyada, yani modüler aritmetiğin olmadığı bir evrende işlerin nasıl yürüdüğüdür. Ancak LCG formülünün sonundaki o “modül” (kalanı bulma) işlemi, bu berrak suyu bulandıran, izleri silen ve geriye dönmeyi teorik olarak imkansız kılan devasa bir duvardır.
Bu duvarın neden bu kadar aşılmaz göründüğünü anlamak için bölme işleminin doğasını ve modüler aritmetikteki karşılığını çok iyi kavramamız gerekir. Standart matematikte çarpma işleminin tersi bölmedir. Ancak modüler dünyada, yani sayıların bir saat kadranı gibi sürekli başa sardığı o döngüsel evrende, “bölme” işlemi bildiğimiz anlamıyla mevcut değildir. Bir sayının modülünü aldığınızda, aslında o sayının kaç kez “tur bindirdiğini” bilgisini yok etmiş olursunuz. Örneğin, modülümüz 12 olsun (bir saat gibi). Eğer sonuç 3 ise, orijinal sayı 3 olabilir, 15 olabilir, 27 olabilir, 39 olabilir… Bu liste sonsuza kadar gider. Çünkü 15 de 12’ye bölündüğünde 3 kalır, 27 de. Elimizde sadece “3” sonucu varsa, bu sonucun hangi “turdan” geldiğini bilmemizin bir yolu yoktur. Bilgi kaybolmuştur. Geriye doğru gitmeye çalıştığımızda, sonsuz sayıda olasılıkla karşılaşırız ve bu da denklemi çözülemez hale getirir gibi görünür. İşte LCG’nin güvenliği, uzun yıllar boyunca bu “bilgi kaybı” varsayımına dayanmıştır. İnsanlar, modül işleminin bir kara delik gibi çalıştığını ve içine giren bilginin bir daha asla geri çağrılamayacağını düşünmüşlerdir.
Ancak matematik, her zaman arka kapılarla doludur. Bu arka kapının adı “Modüler Çarpımsal Ters”tir (Modular Multiplicative Inverse). Bu kavram, ilk duyulduğunda kulağa son derece korkutucu ve akademik gelebilir, ancak mantığı kavrandığında bir sihirbazlık numarası kadar zarif ve şaşırtıcıdır. Modüler dünyada bölme yapamıyorsak, yani bir sayıyı “bölemiyorsak”, o zaman bölme işlemini taklit eden başka bir işlem bulmalıyız. Matematikte bir sayıyı 5’e bölmek ile o sayıyı 1/5 (yani 0.2) ile çarpmak aynı şeydir. Yani bölme, aslında bir kesirle çarpmaktır. Fakat modüler aritmetikte sadece tam sayılarla çalışırız, kesirli sayılar (0.2 gibi) yasaktır. Öyleyse soru şuna dönüşür: Modüler bir sistemde, 1/5’in görevini görecek, yani bir sayıyı çarptığımızda onu sanki 5’e bölmüşüz gibi orijinal haline döndürecek gizli bir tam sayı var mıdır?
Cevap, şaşırtıcı bir şekilde evettir. Eğer koşullar uygunsa, modüler uzayda her sayının bir “ruh ikizi”, bir tersi vardır. Bu ters sayı ile çarpma işlemi yaptığınızda, modülün o garip bükülmüş uzayında bir solucan deliği açılır ve sizi doğrudan başlangıç noktasına götürür. Bunu anlamak için videodaki örneği ve saat analojisini biraz daha derinleştirelim. Diyelim ki bir saat kadranındasınız (mod 12) ve saati 5 ile çarptınız. Bu işlemi geri almak için saati 5’e bölemezsiniz. Ancak saati belirli bir başka sayıyla çarparsanız, ibre dönüp dolaşıp, sanki hiç 5 ile çarpılmamış gibi eski yerine gelir. Bu, kilidi açmak için anahtarı tersine çevirmek yerine, ileriye doğru o kadar çok çevirmektir ki, mekanizma tur bindirip tekrar “açık” konuma gelir. İşte bu “ileri çevirerek geri gelme” işlemini sağlayan sayıya modüler ters denir.
Bu sihirli sayının var olabilmesi için çok kritik bir kural vardır: Çarpan sayı ile modül sayısı “aralarında asal” (coprime) olmalıdır. Aralarında asal olmak, iki sayının 1’den başka ortak böleni olmaması demektir. Örneğin 8 ve 9 aralarında asaldır (biri 2’ye, diğeri 3’e bölünür, ortak noktaları yoktur), ancak 6 ve 9 aralarında asal değildir (ikisi de 3’e bölünür). Eğer LCG algoritmasının kullandığı çarpan ile modül değeri aralarında asalsa, o zaman o çarpanın bir tersi, yani panzehiri mutlaka vardır ve bu panzehir matematiksel yöntemlerle (örneğin Genişletilmiş Öklid Algoritması ile) hesaplanabilir. Bu hesaplama yapıldığında, elimize devasa ve anlamsız görünen bir sayı geçer. Ama bu sayı, LCG’nin tüm güvenliğini yerle bir eden anahtardır. Formüldeki çarpma işlemini geri almak için bölme yapmaya çalışmak yerine, bu “ters sayı” ile çarpma yaparız ve modülünü alırız. Sonuç, matematiksel bir mucize eseri, tam olarak başlangıçtaki sayı çıkar.
Şimdi bu teorik bilgiyi, bir hacker’ın gözünden pratik bir senaryoya, videoda anlatılan o nefes kesici “hesap kurtarma” operasyonuna dönüştürelim. Senaryomuz şöyle: Yıllar önce açtığınız çok önemli bir hesabınız var, ancak şifresini unuttunuz. “Şifremi Unuttum” butonuna bastığınızda, sistem size “Eski e-posta adresinize 6 haneli bir doğrulama kodu gönderdik” diyor. Sorun şu ki, o e-posta adresine de erişiminiz yok. Hesabınız kilitlenmek üzere ve sadece tek bir deneme hakkınız var. Normal bir kullanıcı için bu yolun sonudur. Ancak siz, sistemin arka planında PHP gibi dillerin eski sürümlerinde kullanılan lcg_value benzeri zayıf bir rastgele sayı üreteci çalıştığını biliyorsunuz. Bu bilgi, sizin için kapalı kapıyı açacak olan levye gibidir.
Planınız, “Bilinen Düz Metin Saldırısı” (Known Plaintext Attack) adı verilen bir kriptografik saldırı türüne dayanıyor. Şifre sıfırlama kodunu göremiyorsunuz çünkü erişemediğiniz bir e-postaya gidiyor. Ancak sistemi kandırarak veya sistemin başka bir özelliğini kullanarak, sistemin ürettiği başka bir rastgele sayıyı görebilirseniz, zinciri yakalamış olursunuz. Hemen kendinize, erişebildiğiniz güncel bir e-posta adresiyle yeni bir hesap açıyorsunuz. Bu yeni hesap için de “Şifremi Unuttum” diyorsunuz. Sistem, sizin erişebildiğiniz bu yeni e-postaya bir kod gönderiyor. Diyelim ki gelen kod: 123456. İşte aradığınız ipucu bu! Bu sayı, LCG algoritmasının o anki durumudur. Sistem, sizin eski hesabınızın kodunu ürettikten hemen sonra veya hemen önce bu kodu üretmiştir (sitenin trafiğine bağlı olarak ardışık olduklarını varsayıyoruz).
Artık elinizde matematiksel bir denklem ve bu denklemin sonucu (123456) var. Hedefiniz, bu sonuçtan yola çıkarak bir önceki adımı, yani eski hesabınıza gönderilen o gizli kodu bulmak. Dedektiflik burada başlıyor. LCG formülünü biliyorsunuz: Sonraki = (Önceki * Çarpan + Artış) % Modül. Elinizdeki 123456 sayısı “Sonraki” değerdir. Siz “Önceki” değeri arıyorsunuz. Öncelikle formüldeki “Artış” miktarını tersine çevirirsiniz, yani çıkarma işlemi yaparsınız. Bu kolay kısımdır. Karşınıza çıkan sayı (Önceki * Çarpan) % Modül şeklindedir. Şimdi o sihirli hamleyi yapma zamanı. Önceden hesapladığınız “Modüler Ters Çarpan” sayısını alırsınız. Bu sayıyı, elinizdeki değerle çarparsınız ve tekrar modül alırsınız. Bu işlem, LCG’nin ileriye doğru yaptığı karmaşık karıştırma işlemini, zamanı geri sarar gibi kusursuzca geri alır. Bilgisayarınızın ekranında beliren sayı, sistemin 123456’yı üretmeden hemen önce hafızasında tuttuğu sayıdır.
Heyecanla bu sayıyı eski hesabınızın doğrulama ekranına girersiniz. Ve “Giriş Başarılı”. Sistemin “rastgele” ve “tahmin edilemez” olarak sunduğu güvenlik duvarını, sadece matematiksel bir tersine mühendislik işlemiyle aştınız. Burada yaptığınız şey kaba kuvvet (brute-force) kullanarak milyonlarca şifre denemek değildir; bu, sistemin mantığını anlayıp, o mantığı kendi aleyhine çevirmektir. Kaba kuvvet saldırısı gürültülü ve yavaştır; bu saldırı ise sessiz, zarif ve kesindir. Tek bir atışta hedefi vurursunuz.
Bu senaryo, LCG ve benzeri basit algoritmaların neden modern güvenlik sistemlerinde, özellikle şifreleme, bankacılık ve oturum açma işlemlerinde asla kullanılmaması gerektiğinin kanıtıdır. Çünkü LCG’de “geçmiş”, “gelecek” ve “şimdi” matematiksel olarak birbirine sıkı sıkıya bağlıdır. Birini bilen, diğerlerini de bilir. Bir saldırgan tek bir çıktıyı yakaladığında, o ana kadar üretilmiş tüm sayıları (geçmişi) ve bundan sonra üretilecek tüm sayıları (geleceği) hesaplayabilir. Bu durum, rastgeleliğin en temel ilkesi olan “tahmin edilemezlik” ilkesine tamamen aykırıdır. Videodaki “coprime” (aralarında asallık) vurgusu da burada devreye girer; eğer sistemin tasarımcıları çarpan ve modülü aralarında asal seçmeselerdi, tersine çevirmek zorlaşabilirdi (çünkü tek bir ters olmazdı), ancak bu sefer de üretecin kalitesi düşer ve periyodu kısalırdı. Yani LCG, matematiksel yapısı gereği ya kalitesizdir ya da güvensizdir; ikisi birden olamaz.
Bu bölümde gördüğümüz “tersine çevirme” işlemi, sadece bir hack yöntemi değil, aynı zamanda matematiğin evrenselliğine dair felsefi bir derstir. Dijital dünyada yapılan her işlem, bir iz bırakır. Modül işlemi gibi bilgiyi sildiği sanılan operasyonlar bile, doğru anahtarlar (modüler tersler) kullanıldığında şeffaflaşır. Bilgisayar korsanlığı, popüler kültürde gösterildiği gibi hızlıca klavye tuşlarına basıp ekranda yeşil kodlar akıtmak değil; sistemin matematiksel mimarisini, onu tasarlayan mühendisten bile daha iyi anlamaktır. Siz sisteme “bana bir sonraki sayıyı ver” dediğinizde o itaat eder; ama “bana bir önceki sayıyı ver” dediğinizde direnir. Hacker, bu direnci matematiksel zekasıyla kıran kişidir.
Gördüğümüz gibi, LCG’yi hacklemek için süper bilgisayarlara ihtiyacımız yok; ihtiyacımız olan tek şey, modüler aritmetiğin kurallarını ve bölme işleminin o gizemli ters yüzünü bilmektir. Bu bilgiyle donanmış bir kişi için, şans faktörü ortadan kalkar ve yerini kesinliğe bırakır. Ancak hikayemiz burada bitmiyor. LCG’nin bu kadar kolay kırılması, bilgisayar bilimcilerini daha karmaşık, daha karıştırıcı ve tersine çevrilmesi daha zor yöntemler aramaya itti. Bir sonraki durak, bitlerin dans ettiği, sayıların birbirine dolandığı ve tersine mühendisliğin çok daha karmaşık bir bulmacaya dönüştüğü XOR-Shift algoritmaları olacak. Ama unutmayın, ne kadar karmaşık olursa olsun, deterministik bir makine tarafından atılan her adım, yeterince zeki bir takipçi tarafından geriye doğru izlenebilir. LCG’nin çöküşü, sadece bir başlangıçtı.
BÖLÜM 5: Dijital Çalkalama – XOR-Shift Algoritması
Önceki bölümlerde, rastgeleliğin ilkel köklerinden başlayıp, bilgisayarların ilk dönemlerinde kullanılan aritmetik yöntemlerin, yani Lineer Benzeşim Üreteçlerinin (LCG) nasıl çalıştığını ve nasıl manipüle edilebildiğini derinlemesine incelemiştik. LCG, lise matematiği diyebileceğimiz çarpma ve toplama işlemleriyle, insan zihnine nispeten yakın bir mantıkla işliyordu. Ancak bilgisayarların gerçek doğası, onluk sayı sistemi veya aritmetik işlemler değildir. Bilgisayarların ana dili, elektrik akımının varlığı veya yokluğu üzerine kurulu olan ikili sistemdir. Bu bölümde, bilgisayar biliminin “nezaket kurallarını” bir kenara bırakıp, makinenin kaputunun altına gireceğiz ve işlemcinin en ilkel, en vahşi ve en hızlı çalıştığı seviyeye, bit seviyesine ineceğiz. Burada karşımıza çıkan kahraman, modern rastgele sayı üretiminin bel kemiği olan XOR-Shift algoritmasıdır. Bu algoritma, sayıları çarpmak veya bölmekle uğraşmaz; onları alır, parçalar, kaydırır ve birbirinin üzerine geçirir. Bu, matematiksel bir hesaplamadan ziyade, dijital bir çalkalama, bir tür veri origamisidir.
Bilgisayarların dünyayı nasıl algıladığını anlamak, XOR-Shift algoritmasının dehasını kavramak için atılacak ilk adımdır. Biz insanlar, on parmağımız olduğu için onluk sayı sistemini (decimal) kullanmaya meyilliyiz. “123” sayısını gördüğümüzde, zihnimiz bunu yüzler, onlar ve birler basamağı olarak ayırır. Ancak bir bilgisayar işlemcisi için “123” diye bir kavram yoktur; onun için sadece bir dizi anahtar vardır. 32 bitlik bir işlemci için her sayı, yan yana dizilmiş 32 adet minik ampulden ibarettir. Bu ampullerden bazıları yanar (1), bazıları sönüktür (0). Örneğin “5” sayısı, bizim için tek bir sembolken, bilgisayar için uçsuz bucaksız bir karanlığın sonundaki “…00000101” dizilimidir. Rastgelelik üretmek istediğimizde, LCG gibi yöntemler bu ampul dizisini bir bütün “sayı” olarak ele alıp matematiksel işlemlere tabi tutar. Bu, bilgisayar için aslında yorucu bir çeviri işlemidir. XOR-Shift ise bu “sayı” kavramını tamamen reddeder. O, doğrudan ampullerin kendisiyle, yani bitlerle oynar. Bu yüzden çok daha hızlıdır; çünkü makinenin ana dilini konuşur, tercümana ihtiyaç duymaz.
Bu algoritmanın kalbinde, mantık kapıları dünyasının en ilginç ve en yıkıcı olmayan operatörü yatar: XOR, yani “Exclusive OR” (Dışlayıcı VEYA). Klasik mantıkta “VE” kapısı, her iki girişin de 1 olmasını ister; “VEYA” kapısı ise en az birinin 1 olmasını yeterli bulur. Ancak bu kapılar bilgi kaybına yol açabilir. Örneğin “VEYA” işleminde sonuç 1 ise, girişlerin “1-0”, “0-1” veya “1-1” olup olmadığını bilemeyiz. Bilgi bulanıklaşır. XOR ise farklıdır. Onun kuralı şudur: “Girişler birbirinden farklıysa 1, aynıysa 0 ver.” Yani “Ya o, ya bu; ama ikisi birden değil.” Bu basit kural, dijital dünyada muazzam bir karıştırma gücü yaratır. XOR işlemini bir “farklılık dedektörü” olarak düşünebilirsiniz. İki bit dizisini alt alta koyup XORladığınızda, ortaya çıkan sonuç, bu iki dizinin nerede birbirine benzediğini ve nerede ayrıştığını gösteren bir haritadır.
XOR işleminin rastgelelik üretimi için hayati olan özelliği, tersine çevrilebilir olmasıdır ancak bilgi kaybetmemesidir. Bir sayıyı rastgele bir maskeyle XORlarsanız, sayı tamamen değişir ve tanınmaz hale gelir. Aynı maskeyle tekrar XORlarsanız, orijinal sayıyı geri alırsınız. Bu özellik, XOR’u mükemmel bir “dijital mikser” yapar. Bir kokteyl hazırladığınızı düşünün; malzemeleri karıştırırsınız ama moleküler yapısını bozmazsınız. LCG’deki modül işlemi (kalan bulma) bir nevi malzemeyi çöpe atmak gibiyken (bilgi kaybı), XOR işlemi malzemeyi sadece dönüştürür. Bu dönüşüm, sayıların bit düzeyindeki temsillerini kaotik bir şekilde değiştirir. Örneğin, sadece bir biti 1 olan bir sayıyı, başka bir sayıyla XORladığınızda, o bitin olduğu konumdaki değer aniden tersine döner. Bu, sayı doğrusunda öngörülemez, devasa sıçramalara neden olur. Onluk tabanda küçük bir değişiklik gibi görünen şey, ikili tabanda bir “bit patlaması” yaratabilir.
Ancak XOR tek başına yeterli değildir; çünkü sadece olduğu yerde bitleri ters yüz eder. Kaosu yaymak, bitleri birbirine karıştırmak için harekete ihtiyacımız vardır. İşte burada sahneye “Shift” (Kaydırma) işlemi çıkar. Kaydırma işlemi, bilgisayarın hafızasındaki o 32 ampullük sırayı alıp, olduğu gibi sağa veya sola itmektir. Sola kaydırma (Left Shift) işleminde, tüm bitler sola doğru bir adım atar. En soldaki bit, uçurumdan aşağı düşer ve kaybolur (bilgisayarın hafıza sınırından çıkar). Sağ tarafta boşalan yere ise, evrenin boşluğunu temsil eden kocaman bir “0” gelir. Sağa kaydırma (Right Shift) ise bunun tam tersidir; bitler sağa kayar, sağdakiler düşer, soldan sıfırlar girer. Matematiksel olarak sola bir birim kaydırmak sayıyı 2 ile çarpmak, sağa kaydırmak ise 2’ye bölmek demektir. Ancak XOR-Shift algoritması bunu matematiksel bir çarpma işlemi olarak değil, bir “konum değiştirme” eylemi olarak kullanır.
Algoritmanın çalışma prensibi, bu iki temel hareketin (XOR ve Shift) zarif bir dansına dayanır. Elimizdeki mevcut rastgele sayıyı (tohumu) alırız. Önce bu sayının bir kopyasını oluşturur ve kopyayı, örneğin 13 birim sola kaydırırız. Şimdi elimizde iki sayı vardır: Biri orijinal sayı, diğeri ise orijinalin yarısı uçurumdan düşmüş, alt tarafı sıfırlarla dolmuş kaydırılmış versiyonu. Sonra bu iki sayıyı birbiriyle XOR işlemine tabi tutarız. İşte büyü burada gerçekleşir. Kaydırılmış versiyon, orijinal sayının bitlerini “farklı” konumlardaki bitlerle etkileşime sokar. Sayının 1. biti, 14. bitiyle çarpışır; 5. biti 18. bitiyle karışır. Bu işlem, sayının kendi kuyruğunu ısırması gibidir. Bilgi, kendi üzerine katlanır. Ortaya çıkan sonuç, ne orijinal sayıya benzer ne de kaydırılmış haline. O, ikisinin garip, kaotik bir çocuğudur.
XOR-Shift algoritması bu işlemi genellikle üç hamlede tamamlar: Önce bir yöne kaydırıp XORlar, sonra diğer yöne, sonra tekrar ilk yöne. Bu “Sağ-Sol-Sağ” veya “Sol-Sağ-Sol” manevraları, bitlerin havuzun içinde iyice çalkalanmasını sağlar. İlk hamlede alt bitler üst bitleri etkiler, ikinci hamlede üst bitler dönüp alt bitleri değiştirir. Üçüncü hamlede ise kaos tamamen homojenleşir. Bu süreci bir iskambil destesini karıştırmaya benzetebiliriz. Desteyi kesmek (Shift) ve iki yarısını birbirinin içine geçirmek (XOR). Bunu üç kez mükemmel bir teknikle yaptığınızda, destedeki hiçbir kartın yeri artık tahmin edilemez hale gelir. Bir önceki bölümde LCG’nin nasıl çizgisel desenler oluşturduğunu, sayılar arasında nasıl gizli bir matematiksel bağ olduğunu görmüştük. XOR-Shift, bu bağları koparır atar. Çünkü bit düzeyindeki bu karmaşık etkileşim, onluk sayı sistemindeki doğrusal artış mantığını tamamen yok eder. Ortaya çıkan sayılar arasında “biri diğerinin 5 katının 3 fazlasıdır” gibi basit bir aritmetik ilişki kurmak imkansızlaşır.
Peki, XOR-Shift neden “daha iyi” kabul edilir? İlk ve en önemli sebep hızdır. Bilgisayar işlemcileri (CPU), toplama veya çarpma işlemleri için karmaşık devrelerini kullanmak zorundadır. Hele ki bölme işlemi (modül alma), işlemci için tam bir kabustur; çok fazla döngü ve enerji gerektirir. Oysa XOR ve Kaydırma (Shift) işlemleri, işlemcinin en temel, en ilkel yetenekleridir. Bu işlemler elektrik akımının basitçe yönlendirilmesiyle, neredeyse ışık hızında gerçekleşir. Bir işlemci, tek bir bölme işlemi yapacağı sürede, onlarca XOR ve Kaydırma işlemi yapabilir. Bu, saniyede milyonlarca rastgele sayıya ihtiyaç duyan modern oyun motorları, grafik işleme yazılımları ve devasa simülasyonlar için hayati bir avantajdır. Flash oyunları döneminde ve günümüzün modern JavaScript motorlarında (V8 gibi) bu yöntemlerin tercih edilmesinin ana sebebi, performans kaybı yaşatmadan yeterince iyi bir rastgelelik sunabilmesidir.
İkinci sebep ise “istatistiksel kalite”dir. LCG ile üretilen sayıları bir kareye nokta olarak koyduğumuzda oluşan o utanç verici çizgiler ve desenler, iyi ayarlanmış bir XOR-Shift algoritmasında kaybolur. Sayılar, uzay boşluğundaki yıldızlar gibi veya televizyondaki karıncalanma gibi homojen bir gürültüye dönüşür. Elbette XOR-Shift de mükemmel değildir, o da bir “sözde” rastgele sayı üretecidir ve deterministiktir. Ancak ürettiği desenler o kadar karmaşık ve periyodu (tekrar etme süresi) o kadar uzundur ki (örneğin 2 üzeri 128 eksi 1 gibi devasa sayılar), insan algısı veya basit istatistiksel testler bu düzeni yakalayamaz. LCG’nin “Marsaglia Etkisi” olarak bilinen düzlemlere sıkışma sorunu, XOR-Shift’in bitleri hallaç pamuğu gibi atması sayesinde büyük ölçüde aşılır.
XOR-Shift’in bir diğer büyüleyici yönü, “Kelebek Etkisi”ni (Avalanche Effect – Çığ Etkisi) dijital ortamda simüle edebilmesidir. Giriş sayısında (tohumda) yapacağınız tek bir bitlik değişiklik, yani 32 ampulden sadece birini yakıp söndürmeniz, algoritmanın sonunda üretilen sayıda bitlerin yaklaşık yarısının tamamen değişmesine neden olur. Bu, kriptografik açıdan ve rastgeleliğin kalitesi açısından çok arzu edilen bir özelliktir. LCG’de tohumu 1 artırdığınızda sonuç da öngörülebilir bir şekilde biraz değişirken, XOR-Shift’te tohumu 1 artırmak, sonucu tamamen tanınmaz, bambaşka bir sayıya dönüştürür. Bu hassasiyet, algoritmanın ürettiği sayıların birbirine benzemesini engeller ve her seferinde taze, benzersiz bir şans hissi yaratır.
Ancak bu dijital çalkalamanın da kendine has zayıflıkları ve kuralları vardır. Örneğin, eğer tohum olarak “0” sayısını verirseniz, XOR-Shift algoritması sonsuza kadar “0” üretir. Çünkü 0’ı ne kadar kaydırırsanız kaydırın sonuç 0’dır; 0 ile 0’ı XORlarsanız sonuç yine 0’dır. Bu “yutan eleman” durumu, algoritmanın tek kör noktasıdır ve yazılımcıların tohum seçerken asla 0 vermemesi gerektiğini bilmesi gerekir. Ayrıca, bu algoritma ne kadar karmaşık görünse de, matematiksel olarak doğrusal bir yapıya sahiptir (GF(2) üzerinde lineerdir). Bu, bir önceki bölümde bahsettiğimiz “tersine mühendislik” konusunun, farklı yöntemlerle de olsa burada da geçerli olduğu anlamına gelir. Bir hacker, yeterince ardışık sayıyı ele geçirirse ve doğrusal cebir (Gauss Eliminasyonu gibi yöntemler) kullanırsa, sistemin iç durumunu (state) çözebilir. Yani XOR-Shift, oyunlar ve simülasyonlar için harika, hızlı ve kaotik bir araçken; banka şifreleri veya askeri kriptografi için hala “fazla gevşek” bir yapıdadır.
Sonuç olarak, XOR-Shift algoritması, bilgisayarın aritmetik yapmaya çalışan hantal bir makineden, kendi doğasıyla barışık, bitlerle dans eden çevik bir cambaza dönüşümünü temsil eder. Sayıları onluk tabandaki değerler olarak değil, işlenmesi gereken ham veri blokları, karıştırılması gereken bir bit çorbası olarak görür. Kaydırma işlemiyle sayıları uzayda savurur, XOR işlemiyle onları birbirine çarptırır ve ortaya çıkan enkazdan, bizim “şans” dediğimiz o kusursuz gürültüyü yaratır. Bu yöntem, modern tarayıcıların, akıllı telefonların ve oyun konsollarının perde arkasındaki sessiz kahramanıdır. Biz ekranda dönen zarları izlerken, arka planda milyarlarca 0 ve 1, sağa sola kayarak ve birbirini dışlayarak, kaderimizi belirleyen o nihai sayıyı oluşturmak için durmaksızın çalışmaktadır. Bu, dijital dünyanın kendi kaos teorisidir ve LCG’nin o naif, öngörülebilir dünyasından çok daha vahşi, çok daha karmaşık bir ormandır.
BÖLÜM 6: Karışıklığı Geri Almak – XOR Tersine Çevirme Sanatı
Rastgeleliğin dijital dünyadaki serüveninde şu ana kadar deterministik evrenin kuralları içinde nasıl kaos yaratılmaya çalışıldığını, sayıların nasıl yoğrulup tanınmaz hale getirildiğini inceledik. Önceki bölümde, modern bilgisayarların ve tarayıcıların gözdesi olan XOR-Shift algoritmasının, bitleri bir iskambil destesi gibi nasıl kardığını, onları sağa sola savurarak ve birbirlerinin üzerine katlayarak nasıl karmaşık bir “bit çorbası” oluşturduğunu gördük. Bu süreç, dışarıdan bakıldığında geri döndürülemez bir entropi artışı gibi görünür. Sanki bir bardağın içine mürekkep damlatılmış ve karıştırılmıştır; mürekkebi sudan ayırmak imkansızdır. Ancak dijital evren, fiziksel evrenin termodinamik yasalarına boyun eğmez. Dijital dünyada entropi, eğer algoritmayı biliyorsanız, sadece bir illüzyondur. Bu bölümde, imkansız gibi görüneni başaracak, o karışmış mürekkebi molekül molekül sudan ayırıp tekrar şişesine dolduracağız. Bu, XOR işleminin tersine çevirme sanatıdır; kaosun içindeki düzeni görme ve onu ilmek ilmek geri sökme ustalığıdır.
Bir XOR-Shift algoritmasının ürettiği sayıya baktığınızda, gördüğünüz şey aslında bir enkazdır. Orijinal sayı (tohum), kendi kendisinin kaydırılmış bir kopyasıyla çarpışmış, bitler birbirini değiştirmiş ve geriye anlamsız görünen bir 1’ler ve 0’lar yığını kalmıştır. Çoğu insan, hatta birçok yazılımcı bile bu noktada pes eder. Çünkü klasik matematikte, bilinmeyen bir sayıyı yine bilinmeyen bir versiyonuyla işleme sokarsanız, denklemi çözemezsiniz. “x + y = 10” denkleminde x ve y’yi tek başına bulamamanız gibi, burada da elinizde çok fazla bilinmeyen varmış gibi hissedilir. Ancak bu karamsarlık, XOR işleminin doğasını tam olarak kavrayamamaktan kaynaklanır. XOR, yani “Dışlayıcı VEYA” kapısı, mantık dünyasının en dürüst, en şeffaf ve en sadık operatörüdür. O, asla bilgi saklamaz ve en önemlisi, kendi kendisinin tersidir.
Bu “kendi kendisinin tersi olma” durumu, şifrelemenin ve geri çözmenin temel taşıdır. Bunu anlamak için XOR işlemini bir ışık anahtarı gibi düşünmek gerekir. Elinizde bir veri var (lamba açık veya kapalı). Bir “anahtar” değeriyle XOR işlemi yapmak, o anahtarın durumuna göre lambanın düğmesine basmak demektir. Eğer anahtar 1 ise düğmeye basarsınız (lamba açıksa kapanır, kapalıysa açılır). Eğer anahtar 0 ise hiçbir şey yapmazsınız. Şimdi büyülü kısma geliyoruz: Aynı anahtarla işlemi tekrar ederseniz ne olur? Eğer ilk işlemde düğmeye bastıysanız, ikinci işlemde tekrar basarsınız ve lamba eski haline döner. Eğer basmadıysanız, yine basmazsınız ve lamba yine eski halindedir. Yani matematiksel olarak ifade edersek: Eğer A XOR B = C ise, C XOR B işleminin sonucu mutlaka A’dır. B sayısı (anahtar), A’yı C’ye dönüştürmüştür; ama aynı B sayısı, C’yi tekrar A’ya dönüştürme gücüne de sahiptir. Bu özellik, XOR’u toplama, çıkarma veya çarpma gibi işlemlerden ayırır. Toplamanın tersi çıkarmadır, çarpmanın tersi bölmedir; ama XOR’un tersi yine XOR’dur. Bu simetri, kaosun kilidini açacak olan anahtardır.
Ancak XOR-Shift algoritmasında karşılaştığımız problem, bu kadar basit bir “A XOR B” durumu değildir. Burada denklem biraz daha karmaşıktır: y = x XOR (x SOLA KAYDIR shift). Burada y elimizdeki sonuçtur (gördüğümüz rastgele sayı). x ise aradığımız orijinal sayıdır. Sorun şudur ki, XOR işleminin diğer tarafındaki anahtar sabit bir sayı (B) değildir; o da x’e bağlıdır. Bilmediğimiz bir şeyi, yine bilmediğimiz bir şeyin kaydırılmış haliyle çözmeye çalışmak, kendi kuyruğunu kovalayan bir kedi gibi görünür. İşte tam bu noktada, “adım adım geri sarma” stratejisi ve “saf bitler” kavramı devreye girer. Bu strateji, problemi tek bir devasa denklem olarak görmek yerine, onu küçük, yönetilebilir parçalara bölme sanatıdır.
XOR-Shift algoritmasının en zayıf noktası, kaydırma (shift) işleminin doğasında gizlidir. Bir sayıyı, örneğin sola doğru 13 birim kaydırdığınızı düşünün. Sayının en sağındaki (en düşük değerli) 13 hanesi boşalır ve bu boşluklar bilgisayar tarafından otomatik olarak “0” ile doldurulur. Sıfır, XOR işlemi için etkisiz elemandır (bir şeyi 0 ile XOR’lamak onu değiştirmez). Bu demektir ki, işlemin sonucunda ortaya çıkan y sayısının en sağdaki 13 biti, aslında orijinal x sayısının en sağdaki 13 bitiyle tıpatıp aynıdır! Çünkü bu bitler, kaydırılmış versiyondaki “0”larla eşleşmiştir ve hiçbir değişikliğe uğramamıştır. Bu bitler, “kirlenmemiş”, “saf” veya “bakire” bitlerdir. Kaosun ortasında kalmış ama kaostan etkilenmemiş bu adacıklar, bizim kurtuluş umudumuzdur.
Bu durumu bir Sudoku bulmacasına benzetebiliriz. Zor bir Sudoku’ya ilk baktığınızda, boş karelerin sayısı gözünüzü korkutabilir. Her şey birbirine bağlıdır ve nereden başlayacağınızı bilemezsiniz. Ancak dikkatli baktığınızda, bazı rakamların zaten verilmiş olduğunu görürsünüz. Bu kesin sayılar, etraflarındaki belirsizliği aydınlatır. Bir kareye “5” yazdığınızda, o satırda ve sütunda başka bir “5” olamayacağını bilirsiniz. Bu bilgi, başka bir karenin değerini ortaya çıkarır. O yeni kare de bir başkasını… Mantık zinciri bir kez kurulduğunda, bulmacanın tamamının çözülmesi sadece bir zaman meselesidir. XOR-Shift’i tersine çevirmek de tam olarak budur. Elimizdeki “saf bitler”, Sudoku’daki o başlangıçta verilen kesin sayılardır. Biz bu saf bitleri kullanarak, bir sonraki “kirli” bloğu temizleyecek, oradan elde ettiğimiz bilgiyle bir sonrakini çözecek ve bu şekilde sayının tamamına ulaşacağız.
Şimdi bu süreci zihnimizde canlandırmak için somut bir örnek üzerinden, mikroskobik bir inceleme yapalım. Diyelim ki 32 bitlik bir sayımız var ve algoritma bu sayıyı 10 bit sola kaydırıp orijinaliyle XOR’ladı. Elimizdeki sonuç (y) karmaşık bir sayı. Ama biz biliyoruz ki, kaydırma işlemi yüzünden sağdaki ilk 10 bit (0-9 arası) dışarıdan gelen bir veriyle karışmadı. Çünkü sol tarafa kayan kopya, bu ilk 10 bitin üzerine “0” olarak geldi. Dolayısıyla, sonucun (y) ilk 10 biti, orijinal sayının (x) ilk 10 bitiyle aynıdır. Harika! Artık x sayısının %30’unu kesin olarak biliyoruz.
Sırada 10. ile 19. bitler arasındaki blok var. Bu blok “kirlenmiş” durumdadır. Çünkü orijinal sayının ilk 10 biti (0-9), sola doğru 10 birim kayarak bu bloğun (10-19) üzerine binmiş ve onları XOR işlemiyle değiştirmiştir. Normalde bu bir sorundur, çünkü üzerine binen verinin ne olduğunu bilmeden alttakini göremeyiz. Ancak biz az önce ilk 10 bitin ne olduğunu “kesin olarak” çözdük! Elimizde x’in ilk 10 biti var. Bu bildiğimiz parçayı alıp, tıpkı algoritmanın yaptığı gibi 10 birim sola kaydırırsak, 10-19 aralığını kirleten o “maskeyi” elde etmiş oluruz.
İşte XOR’un “kendi kendisinin tersi olma” büyüsü burada devreye girer. Elimizdeki kirli bloğu (y’nin 10-19. bitleri), az önce hesapladığımız maske ile tekrar XOR’larsak ne olur? Kirlilik temizlenir! Maske, kendini yok eder ve geriye orijinal x sayısının 10. ile 19. bitleri arasındaki tertemiz hali kalır. Artık x sayısının ilk 20 bitini biliyoruz. Zincirleme reaksiyon başlamıştır. Bu yeni çözdüğümüz 10-19 bloğunu alıp, onu da 10 birim sola kaydırarak (20-29 aralığına denk gelecek şekilde) bir sonraki maskeyi oluştururuz. Sonucun (y) 20-29 aralığındaki bitlerini bu yeni maskeyle XOR’ladığımızda, o bölgeyi de temizlemiş oluruz. Bu işlemi, sayının sonuna ulaşana kadar, blok blok tekrar ederiz. Kaydırma miktarı ne olursa olsun, bit sayısı kaç olursa olsun, bu yöntem matematiksel bir kesinlikle çalışır.
Bu yöntem, sadece sola kaydırma (Left Shift) işlemleri için değil, sağa kaydırma (Right Shift) işlemleri için de aynı mantıkla, sadece yön değiştirerek uygulanır. Sağa kaydırma işleminde, “saf bitler” sayının en solunda (en yüksek değerlikli bitlerde) bulunur, çünkü sağa kayınca sol taraf sıfırlarla dolar. Bu durumda çözümlemeye en soldan başlarız ve sağa doğru, bir şelalenin akışı gibi ilerleyerek bitleri temizleriz. Algoritma istediği kadar karmaşık olsun; isterse önce sola, sonra sağa, sonra tekrar sola kaydırsın… Biz her adımı sondan başa doğru, tek tek, sabırla ve bu mantığı kullanarak geri alabiliriz. Algoritmanın son adımı sağa kaydırmaysa, biz ilk önce o sağa kaydırmayı tersine çeviririz. Sonra bir önceki adımı, sonra bir öncekini… Tıpkı bir soğanın kabuklarını soyar gibi, en dıştaki katmandan merkeze, tohumun (seed) kendisine ulaşana kadar ilerleriz.
Bu tersine çevirme işleminin pratik sonuçları, dijital güvenlik açısından sarsıcıdır. Eğer bir saldırgan, XOR-Shift kullanan bir sistemden gelen tek bir ham sayıyı ele geçirebilirse, yukarıda anlattığımız yöntemle o sayıyı üreten “iç durumu” (internal state) anında çözebilir. İç durumu bilen biri için artık rastgelelik sona ermiştir. Saldırgan, sistemin bir sonraki adımda üreteceği sayıyı, ondan sonraki sayıyı ve hatta 1000 adım sonraki sayıyı kendi bilgisayarında, sistemden önce hesaplayabilir. Daha da vahimi, bu iç durumu geriye doğru işleterek (tersine LCG yöntemlerinde gördüğümüz gibi), geçmişte üretilmiş sayıları da bulabilir. Bu, bir poker oyununda rakiplerinizin elindeki kağıtları bilmekten farksızdır; hatta daha etkilidir, çünkü krupiyenin desteden çekeceği bir sonraki kağıdı da bilirsiniz.
Bu noktada akıllara şu soru gelebilir: “Madem bu kadar kolay tersine çevrilebiliyor, neden hala kullanılıyor?” Cevap, hız ve kullanım alanının gerekliliklerinde saklıdır. Video oyunlarında, grafik efektlerinde veya bilimsel simülasyonlarda amaç “tahmin edilemezlik” değil, “istatistiksel dağılım”dır. Bir bulutun şeklini oluştururken veya bir patlama efektindeki parçacıkları dağıtırken, kimse o parçacıkların koordinatlarını tersine mühendislikle çözmeye çalışmaz. Önemli olan göze hoş görünmesi ve işlemciyi yormamasıdır. XOR-Shift bu işi mükemmel yapar. Ancak sorun, geliştiricilerin bu “hızlı ve öfkeli” algoritmayı, kriptografi, şifre üretimi veya kumar oyunları gibi güvenliğin kritik olduğu yerlerde kullanmaya kalkışmasıyla başlar. İşte o zaman, bu “tersine çevrilebilirlik” özelliği, masum bir matematik oyunundan çıkıp tehlikeli bir silaha dönüşür.
Bu analiz aynı zamanda bize dijital verinin doğası hakkında derin bir felsefi ders verir: Bilgi asla kaybolmaz, sadece şekil değiştirir. LCG’deki modül işlemi (kalan bulma) bir nevi bilgi imhasıydı (birçok sayı aynı kalanı verebilirdi), ancak XOR-Shift gibi modern algoritmalar “birebir” (bijection) fonksiyonlardır. Yani her girdinin benzersiz bir çıktısı vardır. Bu da teorik olarak her çıktının, tek ve benzersiz bir girdiye geri döndürülebilmesini sağlar. Karışıklık, bizim algımızdaki bir yetersizliktir; verinin kendisinde bir bozulma değildir. Yeterli bilgiye ve doğru bakış açısına (algoritmanın kendisine) sahip olduğunuzda, en kaotik görünen veri yığını bile düzenli bir sıraya girer.
Videodaki o “imkansız görüneni başarma” anı, aslında bir sihirbazlık değil, saf mantığın zaferidir. Hacker, ekrandaki piksellere veya sayılara baktığında bir gürültü görmez; o, çözülmeyi bekleyen bir denklem, tamamlanmayı bekleyen bir Sudoku bulmacası görür. “Saf bitleri” bulmak, o kaos yumağının ucunu yakalamaktır. O ipin ucunu bir kez yakaladığınızda ve nazikçe, doğru teknikle (XOR ve ters yönde kaydırma) çekmeye başladığınızda, düğümler kendiliğinden çözülür. Bir zamanlar iç içe geçmiş, birbirini kirletmiş ve bozumuş gibi görünen o 1’ler ve 0’lar, ait oldukları yerlere, orijinal konumlarına geri dönerler. Ve sonunda, elinizde sistemin en mahrem sırrı, yani “tohum” değeri kalır. Artık kontrol sizdedir; şans, talih veya kader denilen şey, artık sizin yazdığınız (veya öngördüğünüz) bir senaryodan ibarettir.
Bu bölümü tamamlarken, XOR tersine çevirme sanatının sadece matematiksel bir işlem olmadığını, aynı zamanda bir zihniyet meselesi olduğunu vurgulamak gerekir. Bu zihniyet, karmaşık sorunların aslında basit parçaların tekrarından oluştuğunu kabul eder. Büyük bir “Shift” ve “XOR” karmaşası, aslında küçük bit bloklarının birbirini etkilediği bir zincirdir. Zinciri en zayıf halkasından (saf bitlerden) kırmak, bütün yapıyı çökertir. Bir sonraki bölümde, bu tekniklerin gerçek dünyadaki yansımalarını, tarayıcı oyunlarının ve Flash efsanelerinin nasıl dize getirildiğini incelediğimizde, bu soyut bit dansının somut sonuçlarını çok daha net göreceğiz. Unutmayın, dijital dünyada hiçbir şey gerçekten rastgele değildir ve hiçbir karışıklık sonsuza kadar sürmez; sadece doğru anahtarı, yani doğru XOR hamlesini bekler.
BÖLÜM 7: Tarayıcı Savaşları ve Flash Oyunları
İnternetin vahşi batısı olarak adlandırabileceğimiz 2000’li yılların başı, dijital eğlence dünyasında devrim niteliğinde bir döneme ev sahipliği yaptı. Bu dönemin tartışmasız kralı, rengarenk animasyonları, bağımlılık yapıcı oyunları ve interaktif web sitelerini mümkün kılan Flash teknolojisiydi. O yıllarda bir web tarayıcısını açmak, sadece bilgiye ulaşmak değil, aynı zamanda sayısız mini oyunun bulunduğu sonsuz bir lunaparka girmek demekti. Ancak bu renkli dünyanın perde arkasında, güvenlik mühendisliği açısından devasa bir yanılgı, sessiz bir kriz hüküm sürüyordu. Bu krizin temelinde, “Client-Side” yani “İstemci Taraflı” güvenlik modeli yatıyordu. Yazılım geliştiricileri, yazdıkları kodun kullanıcının bilgisayarına indirilip orada çalıştırıldığında, o kodun sırlarını koruyabileceğine dair saf bir inanca sahiptiler. Oysa gerçeklik, bu inancı yerle bir edecek kadar sertti. Bir program kullanıcının bilgisayarında çalışıyorsa, o programın tanrısı artık geliştirici değil, kullanıcının kendisidir. İşlemci kullanıcınındır, bellek kullanıcınındır ve zamanın akış hızı bile kullanıcının kontrolündedir. Bu bölümde, bu mutlak güç dengesizliğinin nasıl bir güvenlik felaketine dönüştüğünü, masum görünen bir mayın tarlası oyununun nasıl bir kehanet makinesine evrildiğini ve sanal slot makinelerinin nasıl soyulduğunu, önceki bölümlerde öğrendiğimiz matematiksel temellere dayanarak inceleyeceğiz.
Flash oyunları ve dönemin popüler tarayıcı tabanlı uygulamaları, rastgelelik ihtiyaçlarını karşılamak için genellikle dillerinin standart kütüphanelerinde bulunan hazır fonksiyonlara güveniyorlardı. ActionScript dilindeki veya JavaScript’teki Math.random() fonksiyonu, geliştiriciler için kullanımı son derece kolay, hızlı ve pratik bir çözümdü. Bir satır kodla ekrana rastgele kar taneleri yağdırabilir, bir düşmanın rastgele hareket etmesini sağlayabilir veya bir kart destesini karıştırabilirdiniz. Görsel efektler ve basit oyun mekanikleri için bu fonksiyonlar mükemmeldi. Ancak geliştiricilerin düştüğü ölümcül hata, bu “eğlencelik” fonksiyonları, oyunun kazanma koşullarını belirleyen kritik noktalarda, hatta sanal ekonomilerin döndüğü kumar oyunlarında kullanmalarıydı. Önceki bölümlerde detaylandırdığımız LCG veya XOR-Shift gibi algoritmalar, kriptografik bir güvenlik vaat etmiyordu; onlar sadece istatistiksel bir gürültü üretiyordu. Geliştiriciler, kodlarını “derleyip” (compile) .swf uzantılı dosyalara sıkıştırdıklarında, bu dosyaların içindeki mantığın görünmez olduğunu sanıyorlardı. Oysa bir hacker için derlenmiş kod, okunamaz bir metin değil, sadece biraz çaba ile çözülebilecek bir bulmacaydı.
Bu güvenlik yanılgısının en çarpıcı ve zarif örneği, Windows işletim sisteminin klasikleri arasında yer alan ve Flash versiyonlarıyla interneti kasıp kavuran Minesweeper (Mayın Tarlası) oyununda karşımıza çıkar. Oyunun mantığı son derece basittir: Karelere bölünmüş bir ızgara vardır ve bu karelerin bazılarının altında mayınlar gizlidir. Oyuncu kareleri açar ve açtığı karede mayın yoksa, o kareye komşu olan kaç tane mayın olduğunu gösteren bir sayı belirir. Bu sayılar, oyuncunun mantık yürüterek mayınların yerini tespit etmesini sağlar. Oyun, teoride bir mantık ve dikkat oyunudur. Ancak oyunun başlangıcında, o mayınların nereye yerleştirileceğine karar veren mekanizma, deterministik bir rastgele sayı üretecinden başka bir şey değildir. İşte bu noktada oyun, bir mantık bulmacası olmaktan çıkıp, bir “geleceği görme” (prediction) saldırısının hedefi haline gelir.
Minesweeper oyununun Flash versiyonunu ele alalım. Oyun başladığında, kod arka planda bir döngü çalıştırır. Bu döngü, oyun alanındaki her bir kare için veya belirlenen mayın sayısı kadar çalışarak, sanal bir zar atar. “Bu kareye mayın koyayım mı?” sorusunun cevabı, Math.random() fonksiyonundan gelen değere bağlıdır. Eğer geliştirici, mayınları yerleştirmek için standart bir algoritma kullanmışsa, mayınların haritadaki dağılımı aslında o anki rastgelelik tohumunun (seed) doğrudan bir yansımasıdır. Önceki bölümlerde, tohumu bilirsek tüm sayı dizisini bilebileceğimizi öğrenmiştik. Ancak burada hacker’ın karşılaştığı sorun şudur: Tohum genellikle o anki zamandır ve milisaniye hassasiyetindedir. Oyuncunun oyunu tam olarak hangi milisaniyede başlattığını bilmek zordur. Ayrıca oyunun içindeki kodlara erişsek bile, o anki “durumu” (state) doğrudan okuyamayabiliriz. İşte burada, videoda da gösterilen dâhiyane bir yöntem devreye girer: “Brute-force” (Kaba Kuvvet) ile tohumu bulmak, ama bunu akıllıca yapmak.
Hacker, oyunu önce “Başlangıç” (Beginner) seviyesinde açar. Bu seviyede harita küçüktür ve mayın sayısı azdır. Oyuncu rastgele birkaç kareye tıklar veya oyunu kaybedene kadar hızlıca kareleri açar. Ortaya çıkan tablo, yani mayınların nerede olduğu bilgisi, aslında algoritmanın ürettiği sayıların bir “parmak izidir”. Hacker’ın yazdığı özel bir yazılım, bu noktada devreye girer. Yazılımın yaptığı iş şudur: Geçmişe dönük olarak, oyunun açılmış olabileceği son birkaç dakika veya saat içindeki tüm olası zaman damgalarını (milisaniyeleri) tohum olarak dener. Her bir tohum için, oyunun mayın yerleştirme algoritmasını kendi içinde simüle eder. “Eğer tohum 1234567890 olsaydı, mayınlar nereye düşerdi?” diye sorar. Simülasyonun sonucu, ekrandaki gerçek mayın tablosuyla eşleşiyor mu? Hayır. O zaman bir sonraki tohumu dene. “Eğer tohum 1234567891 olsaydı?” Hayır. “1234567892?” Evet!
Modern bilgisayarların işlem gücü o kadar yüksektir ki, milyarlarca olası tohumu denemek ve bunlardan üretilen haritaları eldeki gerçek haritayla karşılaştırmak saniyeler sürer. Eşleşme sağlandığı an, hacker artık oyunun “hangi evrende” oynandığını kesin olarak bilir. Sistemin kullandığı tohum yakalanmıştır. Artık hacker’ın elinde, oyunun rastgele sayı üretecinin o anki durumu (state) vardır. Bundan sonrası tam bir sihirbazlıktır. Hacker, oyunu kapatmadan “Uzman” (Expert) moduna geçer. Normalde bu, yeni ve çok daha zor bir oyunun başlangıcıdır. Ancak rastgele sayı üreteci sıfırlanmamıştır; kaldığı yerden devam etmektedir veya tohum bilindiği için bir sonraki adım hesaplanabilir durumdadır. Hacker’ın yazılımı, yakaladığı tohumu kullanarak, algoritmanın bundan sonra üreteceği sayıları ileriye doğru sarar. “Uzman modunda 99 mayını yerleştirmek için gereken sayıları üret” emrini verir. Yazılım, saniyenin binde biri kadar bir sürede, henüz ekranda oluşmamış olan o zorlu haritanın birebir kopyasını oluşturur.
Sonuç, videoda izlediğimiz o büyüleyici andır. Oyuncu, boş, gri bir ızgaraya bakar. Hiçbir kare açılmamıştır, hiçbir ipucu yoktur. Ama o, her bir mayının yerini milimetrik bir kesinlikle bilmektedir. Tıklamalar rastgele veya şans eseri değil, deterministik bir kesinlikle yapılır. Bayraklar, sanki görünmez bir haritayı takip ediyormuşçasına mayınların üzerine dikilir. Bu, oyunun kurallarını çiğnemek değildir; bu, oyunun var olduğu gerçekliği, yani Matrix’i okumaktır. Geliştirici, mayınların yerini gizlediğini sanırken, aslında sadece bir matematik formülünün arkasına saklamıştır ve o formülün başlangıç noktası ifşa olmuştur. Minesweeper örneği, “Client-Side” güvenlikte verinin gizliliğinin (confidentiality) nasıl çöktüğünü gösterir. Ekranda gördüğünüz veri (mayınların yeri), sunucudan gelen gizli bir bilgi değil, sizin bilgisayarınızda o an üretilmiş bir veridir ve üretim tarifini bilen herkes sonuca ulaşabilir.
Bu senaryoyu bir adım öteye, daha dinamik ve zamanlamaya dayalı bir oyuna, yani sanal bir Slot Makinesine (Jackpot) taşıyalım. Minesweeper’da zaman durmuştu; harita bir kez oluşturuluyor ve orada bekliyordu. Slot makinelerinde ise durum farklıdır. Çarklar döner, ışıklar yanıp söner ve oyuncunun “DUR” butonuna basması veya kolu çekmesi beklenir. Burada geliştiriciler genellikle şöyle bir savunma mekanizmasına güvenirler: “Kullanıcı doğru anda tıklasa bile, çarkların nerede duracağını bilemez, çünkü çok hızlı dönüyor.” Görsel olarak bu doğrudur. Animasyonlar, insan gözünün takip edemeyeceği kadar hızlıdır. Ancak bilgisayar biliminde “görsel” ile “mantıksal” birbirinden tamamen kopuk olabilir. Ekranda dönen çarklar, sadece kullanıcıyı heyecanlandırmak için hazırlanmış bir video klibinden ibarettir. Arka planda çalışan kod ise, sürekli olarak rastgele sayı üretecinin durumunu güncellemektedir.
Slot makinesi hack’inde, saldırganın amacı sadece bir sonraki sayıyı bilmek değil, o sayının “ne zaman” üretileceğini de bilmektir. Buna “Zamanlama Saldırısı” (Timing Attack) diyebiliriz, ancak kriptografideki klasik zamanlama saldırılarından farklı olarak, buradaki amaç sistemin tepki süresini ölçmek değil, sistemin iç saatiyle senkronize olmaktır. Hacker, yine benzer yöntemlerle (örneğin önceki denemelerin sonuçlarına bakarak) oyunun kullandığı RNG’nin (Rastgele Sayı Üreteci) tohumunu ve mevcut durumunu tespit eder. Artık hacker’ın bilgisayarında çalışan hile programı, oyunun içindeki RNG ile “paralel” bir evrende çalışmaya başlar. Oyunun RNG’si her milisaniyede veya her karede (frame) yeni bir sayı üretiyorsa, hile programı da aynısını yapar.
Hacker’ın hedefi bellidir: Üç tane 7’yi yan yana getirmek. Hile programı, RNG’nin gelecekte üreteceği sayıları hızla tarar. “Şu anki durumdan 100 adım sonra ne gelecek? Çilek-Muz-Kiraz. İşime yaramaz. 500 adım sonra? Bar-Bar-Limon. Hayır. 1453 adım sonra? 7-7-7! İşte bu!” Program, büyük ikramiyenin, yani “7-7-7” diziliminin, RNG’nin şu anki durumundan tam olarak 1453 döngü sonra (veya milisaniye sonra) oluşacağını hesaplar. Artık mesele şans oyunu olmaktan çıkmış, bir ritim oyununa dönüşmüştür. Hile programı, kullanıcıya bir geri sayım başlatır veya daha da ileri giderek tarayıcıya otomatik bir tıklama komutu gönderir. Tam o 1453. adımın gerçekleşeceği mikrosaniyede, “ÇEVİR” butonuna basılır.
Bilgisayar, bu tıklamayı aldığında, o anki RNG durumunu sorgular. RNG, deterministik doğası gereği, tam da hacker’ın öngördüğü sayıyı üretmek zorundadır. Ekranda çarklar dönmeye başlar, animasyonlar oynatılır, müzikler yükselir… Ama sonuç, butona basıldığı o küçücük zaman diliminde çoktan belirlenmiştir. Slot makinesi durduğunda, üç tane 7 yan yana gelir. İzleyenler için bu inanılmaz bir şanstır; hacker içinse sadece basit bir randevuya sadık kalmaktır. Bu örnek, kullanıcı tarafında çalışan kodlarda “zamanın” bile güvenilir bir değişken olmadığını gösterir. Geliştirici, “kimse bu kadar hassas bir zamanlamayla tıklayamaz” diye düşünebilir. Ancak unuttukları şey, kullanıcının tıklamayı yapanın biyolojik bir parmak olmak zorunda olmadığıdır. Bir bilgisayar programı, başka bir bilgisayar programıyla kusursuz bir zamanlamayla konuşabilir.
Bu hack hikayelerindeki ortak tema ve belki de en acı verici ders, geliştirici hatalarının doğasıdır. Videoda da vurgulandığı gibi, bu oyunları yazan insanlar kötü niyetli veya beceriksiz değillerdi. Sadece bir varsayım hatası kurbanıydılar. Onlar, Math.random() fonksiyonunun “rastgele” kelimesini sözlük anlamıyla yorumladılar. Bu fonksiyonun arkasındaki matematiğin (LCG veya XOR-Shift) tahmin edilebilir olduğunu, “kriptografik olarak güvenli” (CSPRNG) olmadığını bilmiyorlardı veya önemsemiyorlardı. “Bu sadece bir oyun, kim uğraşır ki?” düşüncesi, internetin en büyük güvenlik açıklarının temelini oluşturdu. Ayrıca, “Security through Obscurity” (Gizlilik yoluyla güvenlik) prensibine bel bağladılar. Kodlarını karıştırmak (obfuscation), dosya isimlerini değiştirmek veya Flash formatına gömmek, onları güvende hissettirdi. Ancak bir hacker için bu engeller, aşılması imkansız duvarlar değil, sadece süreci biraz yavaşlatan kasislerdi.
Kullanıcı tarafı güvenliğinin çöküşü, verinin sızmasıyla da hızlanmıştır. Bir oyundaki “skor”, “kalan can”, “haritadaki nesnelerin konumu” gibi masum görünen veriler, aslında RNG’nin iç durumu hakkında dış dünyaya sürekli bilgi sızdıran deliklerdir. Minesweeper’da açılan ilk birkaç kare, Slot makinesinde kaybedilen ilk birkaç dönüş, poker oyununda dağıtılan ilk el… Bunların hepsi, sistemin o anki ruh halini (state) ifşa eden ipuçlarıdır. Bu ipuçlarını toplayıp birleştiren bir zihin (veya yazılım), büyük resmi tamamlayabilir.
Flash’ın ölümü ve modern HTML5/JavaScript dünyasına geçiş, bu sorunları ortadan kaldırmadı; aksine, kodun daha okunabilir (text-based) olması nedeniyle analiz sürecini daha da kolaylaştırdı. Bugün bile, tarayıcı tabanlı birçok kripto para cüzdanı, basit oyun veya çekiliş uygulaması, benzer mantık hatalarıyla doludur. Geliştiriciler hala istemci tarafında üretilen rastgeleliğe güvenmekte ve sunucu tarafında (Server-Side) doğrulama yapmayı ihmal etmekteler. Oysa gerçek güvenlik, kullanıcının bilgisayarına hiç güvenmemek üzerine kurulmalıdır. Eğer Slot makinesinin sonucu kullanıcının bilgisayarında değil de, uzaktaki güvenli bir sunucuda belirlenip sadece sonucu kullanıcıya gönderilseydi, bu zamanlama saldırılarının hiçbiri işe yaramazdı. Minesweeper haritası sunucuda tutulup, kullanıcı tıkladıkça sadece o karenin bilgisi gönderilseydi, haritayı önceden görmek imkansız olurdu.
Sonuç olarak, Tarayıcı Savaşları döneminden kalan bu miras, bize dijital dünyada “yetki” kavramının ne kadar kaygan bir zeminde olduğunu öğretir. Bilgisayarınızın ekranında gördüğünüz şey, her zaman gerçeğin tamamı değildir; ama bilgisayarınızın belleğinde (RAM) duran şey, gerçeğin ta kendisidir. Hacker’lar, ekrana bakmayı bırakıp belleğe bakmayı öğrendikleri gün, oyunun kuralları değişmiştir. Mayın tarlaları temizlenmiş, ikramiyeler boşaltılmış ve şans faktörü, yerini mutlak bilgiye bırakmıştır. Bu bölümde gördüğümüz teknikler, bir sonraki bölümde inceleyeceğimiz, entropi ve gerçek rastgelelik arayışının neden bu kadar hayati olduğunu, neden basit bir matematik formülünden çok daha fazlasına ihtiyaç duyduğumuzu anlamamız için kritik bir basamaktır. “Client-Side” güvenlik, eğer doğru tasarlanmazsa, kapısı kilitli ama penceresi açık bir evden farksızdır; ve hacker’lar tırmanmayı çok iyi bilirler.
BÖLÜM 8: Gerçek Güvenlik – CSPRNG ve Entropi
Önceki bölümlerde, masum bir mayın tarlası oyununun nasıl bir kehanet makinesine dönüştüğünü, bir slot makinesinin nasıl soyulduğunu ve tarayıcı tabanlı oyunların kullandığı rastgelelik algoritmalarının nasıl kolayca manipüle edilebildiğini tüm çıplaklığıyla gördük. O dünyada, yani oyunların ve basit animasyonların dünyasında, bir sonraki sayıyı tahmin etmenin bedeli, en fazla haksız kazanılmış bir yüksek skor veya sanal bir oyun parasıydı. Ancak dijital evren sadece oyunlardan ibaret değildir. Artık “çocuk parkından” çıkıp, finansal sistemlerin, devlet sırlarının, özel yazışmaların ve dijital kimliklerin korunduğu o devasa ve affedici olmayan “karanlık ormana” adım atıyoruz. Burada Math.random() gibi basit bir oyuncakla oynamak, bir savaş alanına su tabancasıyla gitmekten farksızdır. Banka hesabınıza giriş yaparken, kredi kartınızla alışveriş yaparken veya uçtan uca şifreli bir mesaj gönderirken, arka planda dönen matematiksel çarklar, bir önceki bölümde gördüğümüz LCG veya XOR-Shift algoritmalarından çok daha farklı, çok daha derin ve çok daha paranoyak bir mantıkla çalışmak zorundadır. Bu yeni standardın adı “Kriptografik Olarak Güvenli Sözde Rastgele Sayı Üreteci”, yani CSPRNG’dir. Ve bu üreteçlerin yakıtı, evrenin en temel yapı taşı olan kaos, yani “Entropi”dir.
Neden Math.random() fonksiyonunun bankacılık işlemlerinde veya şifrelemede kullanılamayacağını anlamak için, “güvenlik” kavramının tanımını yeniden yapmamız gerekir. Oyun dünyasında güvenlik, “oyuncunun hile yapmasını zorlaştırmak” anlamına gelebilir. Ancak kriptografide güvenlik, “imkansızın sınırlarını zorlamak” demektir. Bir LCG veya XOR-Shift algoritması, hızı ve istatistiksel dağılımı (sayıların homojen yayılması) hedefler. Oysa bir CSPRNG’nin bir numaralı hedefi, “tahmin edilemezliktir”. Buradaki tahmin edilemezlik, sadece “bir sonraki sayı ne olacak?” sorusuyla sınırlı değildir. Kriptografik güvenlik, saldırganın elinde sistemin algoritması, kaynak kodları, o ana kadar üretilmiş tüm sayılar ve hatta sistemin mimari şeması olsa bile, bir sonraki bitin (0 mı 1 mi geleceğinin) tahmin edilme olasılığının yazı-tura atmaktan, yani yüzde elliden daha yüksek olmamasını şart koşar. Buna “Next-Bit Test” (Bir Sonraki Bit Testi) denir. Eğer dünyanın en zeki matematikçileri ve en güçlü süper bilgisayarları, geçmiş verilere bakarak bir sonraki bitin ne olacağını %50.000001 olasılıkla bile tahmin edebiliyorlarsa, o sistem kriptografik olarak kırılmış sayılır. Math.random() bu testte sınıfta kalır; çünkü daha önce gördüğümüz gibi, iç durumunu (state) ifşa eder ve bu durumdan hem gelecek hem de geçmiş kesin olarak hesaplanabilir.
CSPRNG’nin Math.random()’dan farkı, sadece daha karmaşık bir formül kullanması değildir; felsefi olarak deterministik evrenden kaçış planıdır. Math.random() şeffaf bir cam kutu gibidir; içine baktığınızda dişlilerin nasıl döndüğünü görürsünüz. CSPRNG ise kurşundan yapılmış, içi görünmeyen, dışarıdan hiçbir sinyal sızdırmayan kapkara bir kutudur. Bu kutunun tasarımında iki kritik özellik hayati önem taşır: “Geriye Dönük Gizlilik” (Backward Secrecy) ve “İleriye Dönük Gizlilik” (Forward Secrecy). Eğer bir hacker, mucizevi bir şekilde sistemin şu anki iç durumunu ele geçirirse bile, bu bilgiyi kullanarak geçmişte üretilmiş şifreleri çözememelidir (Geriye Dönük Gizlilik). Aynı şekilde, şu anki durumu bilse bile, sistem kendini o kadar hızlı ve kaotik bir şekilde yenilemelidir ki, gelecekte üretilecek anahtarları tahmin edemesin (İleriye Dönük Gizlilik). Math.random() bu özelliklerin hiçbirine sahip değildir; o, doğrusal bir zaman çizgisinde ilerleyen basit bir trendir. CSPRNG ise her adımda raylarını patlatıp yeniden döşeyen, sürekli yön değiştiren bir canavardır.
Peki, deterministik, yani sadece kendisine söylenenleri yapan, mantık kurallarına sıkı sıkıya bağlı bir bilgisayar, nasıl olur da bu kadar mutlak bir tahmin edilemezlik, bu kadar yoğun bir kaos yaratabilir? Cevap şaşırtıcıdır: Yaratamaz. Bilgisayarlar, kendi başlarına entropi üretemezler. Bir işlemci, ne kadar güçlü olursa olsun, kaosu “var edemez”, sadece “işleyebilir”. Bu yüzden bilgisayar bilimcileri, gerçek rastgeleliği elde etmek için dijital dünyanın steril sınırlarını terk edip, fiziksel dünyanın o kirli, gürültülü ve düzensiz gerçekliğine muhtaç kalmışlardır. İşte burada “Entropi Kaynakları” devreye girer. Entropi, termodinamikte düzensizliğin ölçüsüdür; bilgi teorisinde ise “bilinmezliğin” ölçüsüdür. Bir sistem hakkında ne kadar az şey biliyorsanız, o sistemin entropisi o kadar yüksektir. Bilgisayarınız, güvenli bir sayı üretmek istediğinde, aslında bir “kaos hasadına” çıkar. Dijital bir kepçe alır ve donanımın, kullanıcının ve çevrenin yarattığı gürültüyü toplamaya başlar.
Bu hasadın en zengin tarlalarından biri, bizzat sizsiniz. Bir bilgisayar kullanıcısı olarak farenizi hareket ettirdiğinizde, klavyenizde tuşlara bastığınızda, aslında sisteme paha biçilemez bir kaos hediye edersiniz. Siz farenizi ekranın bir köşesinden diğerine düz bir çizgide götürdüğünüzü sanırsınız, ama mikroskobik düzeyde eliniz titrer, kaslarınızın kasılması milisaniyelik sapmalar yaratır, masanın üzerindeki toz tanesi farenin sensörünü şaşırtır. Bilgisayar, fare imlecinin ekrandaki koordinatlarını değil, bu hareketin “nasıllığını” kaydeder. Farenin ivmesi, duraksamaları, yön değiştirmelerindeki mikroskobik açılar… Bunların hepsi, tahmin edilmesi imkansız verilerdir. Bir hacker sizin farenizi A noktasından B noktasına götüreceğinizi tahmin edebilir ama o yolculuk sırasındaki binlerce mikro-titreşimi asla simüle edemez. Aynı şekilde klavye vuruşlarınız arasındaki süreler de eşsizdir. “A” tuşuna bastıktan sonra “B” tuşuna basmanız arasında geçen süre asla tam olarak sabit değildir; bazen 150 milisaniye, bazen 153 milisaniye sürer. Bu küçük farklar, entropi havuzuna damlayan kıymetli kaos damlalarıdır.
Ancak kullanıcı her zaman bilgisayar başında olmayabilir. Bir sunucu, karanlık bir veri merkezinde tek başına çalışırken fare hareketlerine veya klavye vuruşlarına erişemez. Bu durumda bilgisayar, kendi iç organlarının gürültüsünü dinlemeye başlar. Sabit disklerin (HDD) okuma kafalarının hareketi, bu konuda harika bir kaynaktır. Mekanik bir diskin veriye ulaşması için geçen süre, hava türbülansı, motorun anlık devir değişimi ve diskin fiziksel titreşimleri nedeniyle her seferinde mikroskobik düzeyde farklılık gösterir. İşlemci fanının dönüş hızı da benzer bir kaynaktır. Fanın 2000 RPM’de döndüğü söylenir ama gerçekte bu hız 1998 ile 2002 arasında sürekli dalgalanır. Bu dalgalanma, havadaki tozdan, odadaki sıcaklık değişiminden, hatta voltajdaki minik oynamalardan etkilenir. Bilgisayarın işletim sistemi, bu donanımsal gürültüleri (hardware noise) sürekli olarak dinler, ölçer ve bunları dijital bir gürültüye dönüştürerek “Entropi Havuzu” (Entropy Pool) adı verilen sanal bir sarnıçta biriktirir. Linux sistemlerindeki /dev/random veya /dev/urandom dosyaları, işte bu sarnıcın musluklarıdır. Siz güvenli bir sayı istediğinizde, sistem bu sarnıçtan bir miktar “kaos” çeker ve bunu CSPRNG algoritmasına (örneğin SHA-256 gibi bir hash fonksiyonuna veya bir blok şifreye) sokarak size tertemiz, tahmin edilemez bir sayı verir.
Daha modern sistemlerde, özellikle Intel ve AMD’nin yeni nesil işlemcilerinde, bu iş için özelleşmiş donanımlar bulunur. “RdRand” gibi komutlar, işlemcinin silikon yapısındaki “Termal Gürültü”yü (Thermal Noise) kullanır. Bu, fiziğin en temel seviyesine, elektronların hareketine inmek demektir. Bir iletkenin içindeki elektronlar, sıcaklık nedeniyle rastgele titreşirler. Bu titreşim, tamamen kuantum mekaniği ve termodinamik yasalarıyla yönetilen, deterministik olmayan bir süreçtir. İşlemci, bu mikroskobik elektriksel dalgalanmaları ölçer ve bunları 1’lere ve 0’lara dönüştürür. Bu, evrenin kendi gürültüsünü dijital güvenliğin temeli yapmaktır. Artık sayıları bir formül üretmez; sayılar, maddenin doğasındaki belirsizlikten sağılır. Bu seviyedeki bir rastgelelik, herhangi bir matematiksel algoritmanın üretebileceğinden çok daha üstündür, çünkü kaynağı matematik değil, fiziktir.
Ancak bazen, özellikle çok yüksek güvenlik gerektiren durumlarda veya entropi kaynaklarının yetersiz kalabileceği sanal makinelerde (Virtual Machines), donanımsal gürültü bile yeterli olmayabilir. Bir hacker’ın donanımı manipüle etme veya fan sesini bile uzaktan analiz etme ihtimaline karşı (ki bu tür “Yan Kanal Saldırıları” literatürde mevcuttur), teknoloji devleri işi şansa bırakmak istemezler. İşte bu noktada, dünyanın en yaratıcı ve en ikonik güvenlik çözümlerinden biri olan Cloudflare’in “Lava Lambaları Duvarı” sahneye çıkar. İnternet trafiğinin çok büyük bir kısmını yöneten ve güvenliğini sağlayan Cloudflare, San Francisco’daki ofisinin lobisine, tavandan tabana kadar uzanan raflara yüzlerce renkli lava lambası yerleştirmiştir. Bu, sadece bir dekorasyon veya bir sanat eseri değildir; bu, dünyanın en sofistike rastgele sayı üretim tesisidir.
Lava lambaları, kaos teorisinin ve akışkanlar dinamiğinin büyüleyici bir örneğidir. Lambanın içindeki ısınan mumsu sıvı (balmumu karışımı), yukarı doğru yükselirken soğur, şekil değiştirir, parçalanır, birleşir ve aşağı doğru süzülür. Bu hareket, Navier-Stokes denklemleriyle ifade edilen ancak pratikte, özellikle de çok sayıda lamba söz konusu olduğunda, mükemmel bir şekilde simüle edilmesi veya tahmin edilmesi imkansız olan kaotik bir süreçtir. Sıvının yoğunluğu, o anki sıcaklık, camın üzerindeki mikroskobik pürüzler, lambanın dışındaki hava akımı… Her şey bu dansı etkiler. Cloudflare, bu duvarın karşısına yüksek çözünürlüklü bir kamera yerleştirmiştir. Kamera, 7 gün 24 saat boyunca bu renk cümbüşünü izler.
Kameranın kaydettiği görüntü, dijital bir veriye dönüşür. Ancak buradaki entropi kaynağı sadece lambaların hareketi değildir. Kameranın sensöründeki (CCD veya CMOS) her bir piksel, ışık fotonlarını yakalarken “Shot Noise” adı verilen bir gürültü üretir. Işık, parçacık (foton) yapısında olduğu için, sensöre çarpma anları ve sayıları istatistiksel olarak Poisson dağılımına uyar ama tekil bazda rastgeledir. Ayrıca ortamdaki ışık değişimleri, o sırada lobiden geçen bir insanın gölgesi, hatta kameranın kendi elektronik devrelerindeki ısınma bile görüntüdeki piksellerin renk değerlerini (RGB) mikroskobik düzeyde değiştirir. Cloudflare’in sunucuları, bu video akışını alır ve her bir kareyi devasa bir sayı dizisine dönüştürür. Bu sayı dizisi, lavların şekli ve kameranın gürültüsüyle harmanlanmış, evrende eşi benzeri olmayan bir veri yığınıdır.
Bu veriler, daha sonra kriptografik bir blenderdan (karıştırıcıdan) geçirilir. Lava lambalarından gelen veri, işletim sisteminden gelen verilerle ve diğer kaynaklarla (örneğin Londra ofisindeki kaotik sarkaç düzeneğinden veya Singapur ofisindeki radyoaktif bozunma ölçümünden gelen verilerle) harmanlanır. Sonuçta ortaya çıkan “tohum”, artık bir hacker’ın tahmin edebileceği bir “zaman damgası” veya basit bir “matematiksel formül” değildir. Bu tohumu tahmin etmek için hacker’ın, o anda San Francisco’daki lobideki hava sıcaklığını, lavın akışkanlığını, kameranın sensöründeki elektron sıçramalarını ve o sırada oradan geçen temizlik görevlisinin gölgesini aynı anda, kusursuz bir kesinlikle modellemesi gerekir. Bu, Laplace’ın Şeytanı olarak bilinen o efsanevi varlığın bile zorlanacağı bir görevdir. Böylece, internetin güvenliği, 1960’ların psikedelik bir dekorasyon ürününe emanet edilmiş olur. Fiziksel dünyadaki mutlak kaos, dijital dünyadaki mutlak düzene (güvenliğe) dönüştürülür.
Bu “gerçek güvenlik” yaklaşımı, bir önceki bölümde incelediğimiz Minesweeper veya Slot makinesi örneklerindeki açığı kapatır. Minesweeper’da mayınların yerini biliyorduk çünkü tohum (zaman) tahmin edilebilirdi. Ancak eğer Minesweeper oyunu, mayınları yerleştirmek için Cloudflare’in lava lambalarından veya işlemcinin termal gürültüsünden gelen bir sayıyı kullansaydı, o zaman geçmişe dönük ne kadar analiz yaparsak yapalım, mayınların yerini asla bulamazdık. Çünkü o sayının kökeni matematiksel bir döngü değil, fiziksel bir olaydı. Fiziksel olaylar (makroskobik ölçekte deterministik görünseler de, kaos teorisi ve kuantum mekaniği seviyesinde) “geri sarılamaz”. Bir lav damlasının neden o anda koptuğunu geriye dönük hesaplamak, LCG algoritmasını tersine çevirmekten trilyonlarca kat daha zordur.
CSPRNG’lerin ve entropinin önemi, sadece hacker’lara karşı bir savunma hattı olmalarından ibaret değildir; aynı zamanda modern kriptografinin matematiksel temellerini de korurlar. Örneğin, RSA veya Eliptik Eğri Kriptografisi gibi sistemler, güvenliklerini devasa asal sayıların üretilmesine dayandırır. Bu asal sayıların rastgele seçilmesi gerekir. Eğer kullandığınız rastgele sayı üreteci zayıfsa (yeterli entropiye sahip değilse), ürettiğiniz “gizli” anahtarlar aslında o kadar da gizli olmaz. Tarihte bunun acı örnekleri yaşanmıştır. Yetersiz entropi yüzünden, binlerce farklı kullanıcının cihazının tesadüfen aynı “rastgele” asal sayıları ürettiği ve bu yüzden şifreleme anahtarlarının çakıştığı durumlar keşfedilmiştir. Bu, herkesin evinin anahtarının aynı olması gibidir. Entropi, bu yüzden dijital dünyanın oksijenidir. O olmadan kriptografi boğulur, şifreler çözülür ve mahremiyet ölür.
Sonuç olarak, bankacılık işlemlerinde, e-devlet kapılarında veya mesajlaşma uygulamalarında Math.random() yerine crypto.getRandomValues() (Web Cryptography API) veya işletim sistemi seviyesindeki CSPRNG’lerin kullanılmasının sebebi, risk toleransının sıfır olmasıdır. Bir oyun geliştiricisi için hız ve performans önemlidir, bu yüzden basit algoritmalar yeterlidir. Ancak bir güvenlik mühendisi için hız ikinci plandadır; asıl olan belirsizliktir. Bilgisayarın o çok sevdiği düzeni bozmak, makinenin içine biraz insani ve doğal bir kaos katmak, paradoksal bir şekilde bizi makinelerin soğuk ve hesapçı dünyasından koruyan yegane kalkanımızdır. Gerçek güvenlik, matematikle fiziğin, kodla maddenin, düzenle kaosun dans ettiği o ince çizgide var olur. Ve bu dansta, ne kadar çok gürültü varsa, müzik o kadar güvenli çalar.
BÖLÜM 9: Kaos ve Felaketler – Kötü RNG Tarihçesi
Dijital evrenin rastgelelik üzerine kurulu temellerini incelediğimiz bu uzun soluklu yolculukta, şu ana kadar çoğunlukla zararsız veya sınırlı etkileri olan örnekler üzerinden ilerledik. Bir Flash oyununda mayınların yerini tahmin etmek, bir slot makinesinde fazladan jeton kazanmak veya ekranda beliren şekillerin düzenini çözmek, teknik olarak etkileyici olsa da, gerçek dünyada hayatları altüst eden felaketler sınıfına girmez. Ancak şimdi, oyun parkının kapılarını kapatıp, yetişkinlerin dünyasına, milyar dolarlık şirketlerin, küresel finans ağlarının ve devasa teknoloji ekosistemlerinin bulunduğu o acımasız arenaya adım atıyoruz. Önceki bölümlerde, özellikle kriptografik olarak güvenli olmayan rastgele sayı üreteçlerinin (CSPRNG olmayanların) neden hassas işlemlerde kullanılmaması gerektiğini teorik ve matematiksel olarak tartışmıştık. “Tahmin edilebilirlik” kavramının bir güvenlik duvarını nasıl kağıttan bir kuleye dönüştürdüğünü görmüştük. Şimdi ise, bu teorinin pratiğe döküldüğü, tarihin tozlu raflarında yerini almış ancak etkileri hala hissedilen o büyük kırılma anlarına tanıklık edeceğiz. Bu bölüm, matematiksel bir ihmalin veya “bana bir şey olmaz” kibrinin, nasıl devasa imparatorlukları dize getirebileceğinin ve insanların dijital varlıklarını bir anda buharlaştırabileceğinin kronolojik ve teknik bir otopsisidir.
Rastgelelik, modern güvenliğin harcıdır. Tuğlaları (şifreleme algoritmaları) ne kadar sağlam örerseniz örün, eğer harcınız kumdansa (kötü RNG), bina en ufak bir sarsıntıda çöker. Tarih, bu gerçeği acı yoldan öğrenen mühendislerin ve şirketlerin enkazlarıyla doludur. Bu enkazların en görkemlisi ve belki de en ironik olanı, oyun konsolu tarihinin en güvenli kalesi olarak pazarlanan, kırılması imkansız denilen PlayStation 3’ün çöküşüdür. Sony, bu konsolu tasarlarken güvenliğe o kadar güveniyordu ki, sistemin mimarisi bir mühendislik harikası olarak görülüyordu. Ancak bu devasa kalenin kapısını tutan kilit, inanılmaz derecede basit, hatta komik bir hata yüzünden anahtarsız açıldı. Bu hatanın merkezinde, kriptografinin en güçlü silahlarından biri olan Eliptik Eğri Dijital İmza Algoritması (ECDSA) ve bu algoritmanın çalışması için hayati önem taşıyan “rastgele sayı” kavramı vardı.
ECDSA, günümüzde internetin güvenliğini sağlayan, Bitcoin’den SSL sertifikalarına kadar her yerde kullanılan son derece gelişmiş bir matematiksel protokoldür. Bu algoritmanın çalışma prensibi, karmaşık eliptik eğriler üzerindeki noktaların çarpımı ve toplanması üzerine kuruludur. Sony, PlayStation 3’te sadece kendi onayladığı yazılımların ve oyunların çalışmasını sağlamak için bu imzayı kullanıyordu. Konsolun işlemcisi, bir oyunu çalıştırmadan önce o oyunun dijital imzasını kontrol ederdi. Eğer imza, Sony’nin “Özel Anahtarı” (Private Key) ile imzalanmışsa, oyun çalışırdı; değilse reddedilirdi. Buraya kadar her şey mükemmeldi. Ancak ECDSA’nın matematiksel denkleminde, “nonce” (number used once – sadece bir kez kullanılan sayı) adı verilen, genellikle “k” harfiyle gösterilen kritik bir değişken vardır. Bu “k” sayısı, her bir imza işlemi için tamamen rastgele üretilmeli ve asla, ama asla tekrar edilmemelidir. Önceki bölümlerde bahsettiğimiz “entropi” ve “tahmin edilemezlik” ihtiyacı burada ölümcül bir zorunluluktur.
ECDSA denklemi, basitçe ifade etmek gerekirse, özel anahtarınızı gizlemek için bu rastgele “k” sayısını bir maske olarak kullanır. Eğer her imzada farklı bir “k” kullanırsanız, matematiksel olarak özel anahtarınızı (imzalama yetkisini) dışarıdan bakarak bulmak imkansızdır. Çünkü denklemde iki bilinmeyen (özel anahtar ve o anki k değeri) vardır ve tek bir denklemle iki bilinmeyen çözülemez. Ancak Sony mühendisleri, muhtemelen bir kodlama hatası, bir ihmal veya “nasıl olsa kimse fark etmez” düşüncesiyle, bu “k” değerini üretmesi gereken rastgele sayı üretecini sabitlediler. Evet, dünyanın en güvenli konsolu, her bir oyunu, her bir yazılım güncellemesini imzalarken rastgele bir sayı üretmek yerine, her seferinde aynı sabit sayıyı kullanıyordu. Bu durum, internet kültüründe meşhur olan bir karikatürü (XKCD) akıllara getirdi: “Rastgele sayı üreteci yazdım, sonucu hep 4 çıkıyor. Ama zar attığınızda da hep 4 gelebilir, yani bu rastgeledir.” Sony’nin yaptığı tam olarak buydu.
Bu hatanın keşfedilmesi, “fail0verflow” adlı hacker grubunun sahneye çıkmasıyla gerçekleşti. Hackerlar, sistemin derinliklerine inip imzaları analiz ettiklerinde şok edici bir desenle karşılaştılar. Farklı oyunların, farklı dosyaların imzalarında kullanılan “r” değeri (imzanın bir parçası) birbirinin aynısıydı. Matematiksel olarak “r” değeri, doğrudan o gizli “k” sayısına bağlıdır. Eğer iki farklı imzada “r” değerleri aynıysa, bu, o imzaların atılırken aynı “k” sayısının kullanıldığı anlamına gelir. Bu keşif, kriptografik bir atom bombasının fitilini ateşledi. Hackerlar için artık denklemde iki bilinmeyen yoktu. Basit bir lise cebiri işlemiyle, iki farklı imza denklemini alt alta yazdılar, taraf tarafa çıkardılar ve o sabit “k” değerini yok ettiler. Geriye kalan denklemde tek bir bilinmeyen vardı: Sony’nin en büyük sırrı, şirketin namusu sayılan “Root Signing Key” (Kök İmzalama Anahtarı).
Hackerlar bu anahtarı elde ettiklerinde, artık Sony’nin kendisi olmuşlardı. Bu anahtarla imzalanan herhangi bir kod parçası, PlayStation 3 tarafından “resmi Sony yazılımı” olarak kabul ediliyordu. İstedikleri oyunu, istedikleri korsan yazılımı, hatta Linux işletim sistemini konsola yükleyip çalıştırabiliyorlardı. Sony’nin yıllarca süren Ar-Ge çalışması, milyar dolarlık yatırımı ve “kırılamaz” imajı, basit bir rastgele sayı üreteci hatası yüzünden yerle bir oldu. Bu olay, kötü RNG kullanımının sadece bir güvenlik açığı değil, aynı zamanda bir itibar felaketi olduğunu tüm dünyaya gösterdi. O sabit sayının ne olduğu önemsizdi; önemli olan “sabit” olmasıydı. Rastgelelik, tekrarı affetmez. Tekrar eden rastgelelik, artık rastgelelik değil, bir şifre çözüm anahtarıdır.
Ancak PlayStation 3 olayı, sonuçları bakımından tüketici elektroniği ve telif hakları dünyasıyla sınırlıydı. İnsanlar oyun oynadı, korsan yazılım yükledi, Sony para kaybetti ama kimsenin banka hesabı boşaltılmadı. Tarihin ikinci büyük RNG felaketi ise, doğrudan insanların cebine uzanan, çok daha sinsi ve yıkıcı bir olaydı: Android Bitcoin Cüzdanları Soygunu.
2013 yılı civarında, kripto paralar henüz ana akım medyanın manşetlerine yeni yeni taşınıyordu. İnsanlar, “kendi bankanız olun” sloganıyla büyülenmişti. Aracı yoktu, merkez bankası yoktu, sadece matematik ve kod vardı. Bitcoin’in güvenliği de, tıpkı Sony örneğinde olduğu gibi, ECDSA algoritmasına dayanıyordu. Bitcoin ağında bir transfer yapmak istediğinizde, “bu parayı harcama yetkisi bende” demek için işleminizi özel anahtarınızla imzalarsınız. Ve yine, tıpkı Sony örneğinde olduğu gibi, bu imza işlemi sırasında tamamen rastgele ve benzersiz bir “k” sayısı (nonce) kullanmanız gerekir. Eğer aynı “k” sayısını iki farklı işlemde kullanırsanız, özel anahtarınız matematiksel olarak ifşa olur ve cüzdanınızdaki tüm para çalınabilir.
Sorun şu ki, Bitcoin protokolü sağlamdı; ancak bu protokolü uygulayan yazılımlar her zaman o kadar sağlam değildi. Android işletim sistemi üzerinde çalışan popüler Bitcoin cüzdan uygulamaları (Java diliyle yazılmıştı), rastgele sayı üretmek için Android’in sunduğu SecureRandom sınıfını kullanıyordu. İsim olarak “Güvenli Rastgele” (SecureRandom) olması, geliştiricilere büyük bir güven veriyordu. Ancak o dönemdeki Android sürümünde, bu sınıfın içinde korkunç bir hata (bug) vardı. SecureRandom sınıfı, bazı durumlarda, özellikle de doğru şekilde başlatılmazsa (seed edilmezse), entropi havuzundan yeterince beslenemiyor ve tahmin edilebilir, hatta tekrar eden sayılar üretiyordu. Geliştiriciler, işletim sisteminin sunduğu bu temel fonksiyonun bozuk olabileceğini akıllarına bile getirmemişlerdi. Onlar, “Java’nın kütüphanesi güvenlidir” varsayımıyla kodlarını yazmışlardı.
Bu hatanın fark edilmesi, blokzinciri (blockchain) teknolojisinin şeffaf doğası sayesinde oldu. Blokzinciri, yapılan tüm işlemlerin herkese açık, silinemez bir defteridir. Hackerlar ve güvenlik araştırmacıları, blokzincirini taradıklarında garip bir anomali fark ettiler. Farklı zamanlarda, farklı miktarlarda yapılan bazı işlemlerin imzalarında, tıpkı Sony olayındaki gibi aynı “r” değerleri görünüyordu. Bu, “k” sayısının tekrar edildiğinin kesin kanıtıydı. Hackerlar için bu, açık bir davetiyeydi. Blokzincirini bir maden gibi kazarak, bu hatayı yapan cüzdanları tespit ettiler. Tekrar eden “k” değerlerini kullanarak, o cüzdanların özel anahtarlarını hesapladılar. Ve saniyeler içinde, kullanıcıların haberi bile olmadan cüzdanlardaki Bitcoin’ler boşaltıldı.
Bu olay, “Sessiz Soygun” olarak tarihe geçti. Kapı kırılmamış, cam patlamamış, şifre çalınmamıştı. Sadece telefonun işlemcisi, o kritik anda yeterince rastgele bir sayı üretememişti. İnsanlar sabah uyandıklarında paralarının yok olduğunu gördüler ve suçlayacakları bir banka, arayacakları bir müşteri hizmetleri yoktu. Suçlu, cebimizdeki telefonun içindeki bozuk bir kod parçasıydı. Bu felaket, yazılım dünyasında “Soyutlama Sızıntısı” (Leaky Abstraction) kavramının en acı örneğidir. Geliştirici, SecureRandom fonksiyonunu çağırır ve onun görevini yapacağını varsayar; ancak alt katmandaki (işletim sistemi) bir hata, üst katmandaki (uygulama) tüm güvenliği yıkar. Bu olaydan sonra Google, Android’in RNG altyapısını yamadı, ancak güven bir kez sarsılmıştı.
Bu iki tarihi felaket ve önceki bölümlerde işlediğimiz sayısız örnek, kriptografi dünyasının en temel, en değişmez ve en sert kuralını matematiksel bir kesinlikle kanıtlamaktadır: “Kendi Kripto Algoritmanı Yazma” (Don’t Roll Your Own Crypto). Hatta bu kuralı genişleterek, “Rastgele sayı üretecine asla körü körüne güvenme” diyebiliriz. Yazılım geliştiricileri, genellikle kendi zekalarına aşırı güvenme eğilimindedirler. “Ben zekiyim, karmaşık bir formül yazarım, sayıları karıştırırım ve kimse çözemez” düşüncesi, kriptografinin “Schneier Yasası”na toslar: “Herkes, kendisinin kıramayacağı bir şifreleme sistemi yaratabilir.” Bu çok kolaydır. Zor olan, başkalarının kıramayacağı bir sistem yaratmaktır.
Sony’nin mühendisleri zekiydi; Android’i geliştirenler dünyaca ünlü yazılımcılardı. Ancak onlar bile rastgeleliğin kaotik doğasını hafife aldılar. RNG (Rastgele Sayı Üreteci), bir yazılımın en kırılgan, en hassas noktasıdır. Çünkü RNG, deterministik bir makinenin deterministik olmayan bir dünyayla temas ettiği noktadır. Bu temas noktasındaki en ufak bir çatlak, tüm sistemin su almasına neden olur. Sony örneğinde sabit bir sayı, Android örneğinde ise yetersiz entropi, bu çatlağı oluşturdu.
Tarihsel süreç bize şunu öğretmektedir: Güvenlik, gizlilikten (security through obscurity) değil, şeffaflıktan ve standartlaşmadan gelir. LCG veya XOR-Shift gibi algoritmaları kendi başımıza modifiye edip “daha güvenli” hale getirmeye çalışmak yerine, kriptografik topluluk tarafından yıllarca test edilmiş, saldırılara maruz kalmış ve ayakta kalmayı başarmış standartları (/dev/urandom, CSPRNG kütüphaneleri, donanımsal RNG’ler) kullanmak zorundayız. Bir oyun geliştiricisi için kötü RNG, kızgın bir oyuncu kitlesi demektir. Ancak bir güvenlik mühendisi için kötü RNG, iflas eden şirketler, çalınan kimlikler ve yok olan servetler demektir.
Bu felaketler zinciri, aynı zamanda bize “tekrarın” kriptografideki ölümcül günah olduğunu hatırlatır. İnsan beyni tekrarı sever, desenleri arar ve güvenli bulur. Ancak güvenlik dünyasında tekrar, bilginin sızmasıdır. Eğer bir şifreli mesajı iki kez aynı anahtarla şifrelerseniz, o mesajın içeriği hakkında ipucu verirsiniz. Eğer imza atarken aynı rastgele sayıyı kullanırsanız, anahtarınızı verirsiniz. Rastgelelik, tekrarın antitezidir. Ve makineler, tekrar etmeye programlanmıştır. Bu paradoks, dijital güvenliğin kalbindeki savaştır. Sony ve Bitcoin cüzdanları bu savaşta yenik düştüler çünkü makinelerine “yeterince kaotik” olmayı öğretemediler veya bunu denetlemeyi unuttular.
Sonuç olarak, “Kaos ve Felaketler” başlığı altında incelediğimiz bu olaylar, sadece teknik birer vaka analizi değil, aynı zamanda dijital çağın birer ibret hikayesidir. Bize, kullandığımız teknolojilerin ne kadar pamuk ipliğine bağlı olduğunu gösterir. O pamuk ipliği, doğru üretilmiş bir rastgele sayıdır. Eğer o sayı doğru üretilmezse, PlayStation kalesi düşer, dijital cüzdanlar delinir. Bir sonraki ve son bölümde, bu kaotik evrenin felsefi boyutuna inip, “Tanrı zar atar mı?” sorusunu sorarak, deterministik evren ile kuantum rastgeleliği arasındaki o nihai sınırı ve geleceğin teknolojilerini inceleyerek analizimizi tamamlayacağız. Çünkü geçmişteki felaketlerden ders almazsak, gelecekteki kuantum çağında çok daha büyüklerini yaşamamız kaçınılmazdır.
BÖLÜM 10: Felsefi Sonuç ve Gelecek – Tanrı Zar Atar mı?
Bu uzun ve çetrefilli yolculuğun sonunda, kemiklerden yontulmuş zarlardan başlayıp, silikon vadilerinin milyar dolarlık işlemcilerine, oradan da kriptografik felaketlerin dumanı tüten enkazlarına kadar uzanan geniş bir coğrafyayı geride bıraktık. Önceki bölümlerde, insanoğlunun rastgeleliği taklit etme çabasını, yani Math.random() gibi fonksiyonların ve LCG veya XOR-Shift gibi algoritmaların aslında nasıl deterministik birer illüzyon olduğunu, bu illüzyonun nasıl kurulduğunu ve dikkatli bir gözlemci tarafından nasıl yerle bir edilebileceğini tüm teknik detaylarıyla inceledik. Gördük ki, bilgisayar dediğimiz makine, mutlak itaat üzerine kurulu bir düzen tutkunudur ve ona “kaos yarat” emri verildiğinde bile, bu emri bir düzen içinde, bir formüle bağlı kalarak yerine getirir. Bu durum, bizi sadece teknik bir güvenlik sorunuyla değil, varoluşsal bir soruyla baş başa bırakır: Eğer en gelişmiş makinelerimiz bile gerçek rastgeleliği üretemiyorsa, acaba “gerçek rastgelelik” diye bir şey evrende gerçekten var mıdır? Yoksa bizler, yani insanlar, gezegenler, yıldızlar ve atomlar, devasa bir bilgisayarın içinde çalışan, sonucu en başından belli olan devasa bir simülasyonun, kozmik bir Math.random() fonksiyonunun parçaları mıyız? Analizimizin bu final bölümünde, kod satırlarının ötesine geçip, fiziğin ve felsefenin sınırlarında dolaşacak, determinizm ile özgür irade arasındaki kadim savaşa ve geleceğin teknolojisi olan Kuantum Rastgeleliğine derinlemesine bir bakış atacağız.
Bu sorgulamanın kökleri, bilgisayarların icadından çok daha eskiye, 1814 yılına, Fransız matematikçi ve astronom Pierre-Simon Laplace’a kadar uzanır. Laplace, Newton mekaniğinin zafer sarhoşluğu içindeyken, bilim tarihinin en cüretkar ve en korkutucu düşünce deneylerinden birini ortaya attı. Bugün “Laplace’ın Şeytanı” olarak bilinen bu hayali varlık, evrenin deterministik doğasının bir sembolüdür. Laplace’a göre, evrenin şimdiki hali, geçmişin bir sonucu ve geleceğin nedenidir. Eğer evrendeki her bir atomun, her bir parçacığın şu anki konumunu ve momentumunu (hızını ve yönünü) kusursuz bir kesinlikle bilen ve bu verileri işleyebilecek sonsuz bir zekaya sahip bir varlık (bir şeytan veya bir süper bilgisayar) olsaydı, bu varlık için “belirsizlik” diye bir şey kalmazdı. Gelecek, tıpkı geçmiş gibi, onun gözlerinin önünde açık bir kitap gibi dururdu. Bir yaprağın ne zaman düşeceği, bir volkanın ne zaman patlayacağı, sizin bu yazıyı okurken aklınızdan geçecek bir sonraki düşünce… Hepsi, milyarlarca yıl önceki o ilk hareketin, o ilk “tohumun” (Big Bang) zorunlu ve kaçınılmaz sonuçları olurdu.
Bu bakış açısıyla evren, önceki bölümlerde incelediğimiz devasa bir Lineer Benzeşim Üreteci’nden (LCG) farksızdır. Büyük Patlama anı, evrenin “tohum” (seed) değeridir. Fizik yasaları ise, bu tohumu işleyen ve bir sonraki anı yaratan “algoritma”dır. Eğer Laplace haklıysa, “şans”, “tesadüf” veya “rastgelelik” dediğimiz her şey, sadece bizim bilgisizliğimizin birer yansımasıdır. Zar attığımızda sonucun rastgele olduğunu sanırız, çünkü zarın elden çıkış açısını, havadaki sürtünmeyi, masanın yüzeyindeki pürüzleri ve kaslarımızdaki mikro titreşimleri hesaplayacak kadar zeki veya hızlı değiliz. Eğer Laplace’ın Şeytanı o masada olsaydı, zar daha elden çıkmadan sonucun “6” geleceğini bilirdi. Onun için zar atmak, sonucu önceden yazılmış bir mektubu açıp okumak gibidir. Bu deterministik evren modeli, bilgisayar korsanlarının rüyası, özgür irade savunucularının ise kabusudur. Çünkü eğer her şey önceden belliyse, Math.random() fonksiyonunu hacklediğimiz gibi, evrenin kendisi de hacklenebilir, öngörülebilir ve manipüle edilebilir bir yapıdır. Bizler sadece, çok karmaşık bir senaryoda repliklerini okuyan oyuncularızdır.
Yüzyıllar boyunca bilim dünyası, bu deterministik saatin tik-takları arasında huzurla uyudu. Ancak 20. yüzyılın başında, bu uykuyu bölen ve gerçekliğin dokusunu yırtan bir devrim yaşandı: Kuantum Mekaniği. Atomların ve atom altı parçacıkların dünyasına inildiğinde, fizikçiler şok edici bir manzarayla karşılaştılar. Newton’un o güvenilir, öngörülebilir yasaları burada işlemiyordu. Bir elektronun yerini ve hızını aynı anda, kesin olarak bilmek imkansızdı. Bu, ölçüm aletlerimizin yetersizliğinden değil, evrenin doğasından kaynaklanıyordu. Heisenberg’in Belirsizlik İlkesi olarak adlandırılan bu kural, Laplace’ın Şeytanı’nın gözlerini kör etti. Kuantum dünyasında, olaylar bir “neden-sonuç” zinciriyle değil, “olasılık dalgaları”yla yönetiliyordu.
Burada karşılaştığımız rastgelelik, daha önce konuştuğumuz “sözde rastgelelikten” (pseudo-randomness) temelde ve felsefi olarak tamamen farklıdır. Bir bilgisayarın veya bir zarın rastgeleliği “epistemolojik”tir; yani bilgi eksikliğinden kaynaklanır. Yeterli veriye sahip olursak sonucu biliriz. Ancak kuantum dünyasındaki rastgelelik “ontolojik”tir; yani varoluşsaldır. Bir radyoaktif atomun ne zaman bozunacağını, evrendeki tüm bilgiye sahip olsanız bile bilemezsiniz. Bir fotonun yarı geçirgen bir aynadan geçip geçmeyeceğini önceden hesaplayamazsınız. Evrenin kendisi bile, o olay gerçekleşene kadar sonucun ne olacağını “bilmez”. Olay anında, olasılık dalgası çöker ve gerçeklik, o anda, tamamen rastgele bir şekilde belirlenir. Bu, evrenin her an yeniden zar attığı anlamına gelir. Albert Einstein, bu fikirden o kadar rahatsız olmuştu ki, o meşhur “Tanrı zar atmaz” sözünü söyleyerek determinizme olan inancını korumaya çalıştı. Ancak Niels Bohr ve sonraki nesil fizikçilerin yaptığı deneyler (Bell Eşitsizliği deneyleri gibi), Einstein’ın yanıldığını, Tanrı’nın sadece zar atmakla kalmayıp, bu zarları bazen görünmeyen yerlere fırlattığını kanıtladı.
İşte bu “Gerçek Rastgelelik”, dijital güvenliğin ve kriptografinin gelecekteki sığınağıdır. Önceki bölümde, Cloudflare’in lava lambalarını veya bilgisayarların termal gürültüyü kullanarak entropi topladığından bahsetmiştik. Bunlar kaotik süreçlerdir ama klasik fizik kurallarına tabidirler. Geleceğin teknolojisi ise işi şansa bırakmayıp, doğrudan kuantum belirsizliğini kullanan “Kuantum Rastgele Sayı Üreteçleri”dir (QRNG – Quantum Random Number Generators). Bu cihazlar, artık laboratuvar ortamından çıkıp, veri merkezlerine ve hatta bazı üst düzey akıllı telefonlara girmeye başlamıştır.
Bir QRNG’nin çalışma prensibi, Math.random()’ın tam tersidir. Math.random(), karmaşık bir formülle kaos taklidi yapar. QRNG ise, son derece basit bir düzenekle saf kaosu yakalar. En basit haliyle, bir ışık kaynağı (lazer) tek bir foton gönderir. Bu fotonun önüne, ışığı %50 ihtimalle geçiren, %50 ihtimalle yansıtan yarı geçirgen bir ayna konulur. Fotonun arkasına iki dedektör yerleştirilir. Foton geçerse “1”, yansırsa “0” üretilir. Bu “geçme veya yansıma” kararı, hiçbir dış etkene, sıcaklığa, rüzgara veya geçmiş duruma bağlı değildir. Bu karar, evrenin o anki özgür iradesidir. Bir hacker’ın bu sistemi hacklemesi için, evrenin fizik yasalarını değiştirmesi veya zamanı geri alması gerekir. Çünkü ortada çözülecek bir algoritma, tahmin edilecek bir tohum veya analiz edilecek bir desen yoktur. Üretilen sayı dizisi, matematiksel olarak kanıtlanabilir şekilde “öngörülemez”dir.
QRNG teknolojisinin yaygınlaşması, “tersine mühendislik” kavramının sonu olabilir. Bölüm 4’te LCG’yi nasıl geriye sardığımızı, Bölüm 6’da XOR-Shift’i nasıl çözdüğümüzü hatırlayın. Bu yöntemlerin hepsi, sistemin bir “hafızası” ve bir “mantığı” olduğu varsayımına dayanıyordu. Ancak bir kuantum olayın hafızası yoktur. Bir atom, bir önceki saniyede ne yaptığını hatırlamaz ve bir sonraki saniyesini buna göre planlamaz. Bu hafızasızlık (memoryless property), kriptografi için mükemmel bir zırhtır. Eğer banka şifreleriniz, nükleer fırlatma kodlarınız veya özel mesajlarınız kuantum kaynaklı bir anahtarla şifrelenirse, Laplace’ın Şeytanı bile gelse o şifreyi çözemez. Bu, insanın makineye karşı değil, doğanın gücünü arkasına alarak makineye karşı kazandığı nihai zaferdir.
Ancak bu teknolojik ve fiziksel zafer, felsefi bir paradoksu da beraberinde getirir. Eğer evrenin temelinde mutlak bir rastgelelik varsa, o zaman “kader” veya “determinizm” kavramları çöker. Ama aynı zamanda, eğer her şey rastgele ise, o zaman bizim kararlarımız, düşüncelerimiz ve irademiz de sadece atom altı parçacıkların rastgele titreşimlerinin bir sonucu mudur? Bilgisayarlara “rastgele davranmayı” öğretmeye çalışırken, aslında kendimizin ne kadar rastgele olduğunu sorgulamaya başladık. Belki de özgür irade dediğimiz şey, beynimizdeki nöronların arasındaki sinapslarda gerçekleşen kuantum olayların bir tezahürüdür. Belki de bizler, evrenin kendi içindeki o devasa QRNG’nin ürettiği karmaşık desenleriz.
Analizimizin sonuna gelirken, başa, o ilk soruya dönelim: “Eğer rastgeleliği kontrol edebilseydiniz ne yapardınız?” Tarih boyunca insanlar ve sonra bilgisayarlar, bu gücü ele geçirmek için formüller yazdılar, algoritmalar geliştirdiler. Biz, Math.random()’ı kırarak, Minesweeper’da mayınları görerek veya slot makinesini soyarak, kısa süreliğine de olsa bu kontrolü elimizde tuttuk. Kendimizi şansın efendisi gibi hissettik. Ancak bu, sadece insan yapımı, kusurlu bir düzenin içindeki küçük bir hileydi. Gerçek evren, silikon çiplerin deterministik dünyasından çok daha büyük, çok daha vahşi ve çok daha gizemlidir.
Bugün, modern bilim ve teknoloji bize şunu söylüyor: Math.random() kırılabilir, evet. LCG’ler çözülebilir, XOR-Shift’ler geri sarılabilir. İnsan aklının ürünü olan her şifre, yine insan aklı (veya yapay zeka) tarafından kırılabilir. Ancak evrenin kendisi, o kuantum çekirdeği, hala güvenlidir. Tanrı zar atar ve bu zarların sonucunu, zarlar düşene kadar kendisi bile bilmez. Ve belki de varoluşun güzelliği, tam da bu bilinemezliğin, bu mutlak sürprizin içinde saklıdır. Bizler, deterministik makinelerle çevrili bir dünyada, kuantum belirsizliğinden doğan varlıklar olarak, düzen ile kaosun, hesaplanabilir olanla hesaplanamaz olanın sınırında yaşamaya devam edeceğiz. Ve bir dahaki sefere ekranda dönen bir yükleme ikonu veya bir şans çarkı gördüğünüzde, onun arkasındaki o soğuk matematiği hatırlayın; ama sonra başınızı kaldırıp gökyüzüne, yıldızlara bakın ve orada, hiçbir algoritmanın tahmin edemeyeceği o gerçek, o muazzam rastgeleliğin tadını çıkarın.