Günümüzde veri gizliliği, özellikle bulut bilişim ve dağıtık sistemlerin yaygınlaşmasıyla birlikte her zamankinden daha kritik bir hâle geldi. Hassas verilerin üçüncü taraf sistemlerde işlenmesi gerekliliği, “veriyi açmadan işlem yapabilir miyiz?” sorusunu da beraberinde getiriyor. Bu soruya kriptografi dünyasının verdiği en güçlü yanıtlardan biri homomorfik şifreleme yaklaşımıdır. Temel olarak üç farklı seviyede karşımıza çıkar: yalnızca tek bir işlem türünü destekleyen partially homomorphic encryption (kismi homomorfik), sınırlı sayıda ve derinlikte işlemlere izin veren somewhat homomorphic encryption (sınırlı homomorfik şifreleme) ve teorik olarak herhangi bir hesaplamayı şifreli veri üzerinde gerçekleştirebilen fully homomorphic encryption (tamamen homomorfik). Bu yazıda odağımız somewhat homomorphic encryption olacak; ancak önce bu üç yaklaşım arasındaki farkları kısaca netleştirip, ardından somewhat yaklaşımının neleri mümkün kıldığını ve hangi noktalarda yetersiz kaldığını inceleyeceğiz. Sınırlı homomorfik şifreleme, kısmi homomorfikten daha kuvvetliyken, tamamen homomorfikten daha zayıf şekilde sınıflandırabiliriz.

Kısmi Homomorfik Şifreleme (Partially Homomorphic Encryption)

Önce RSA ile partially homomorphic özelliği gösterelim:

from lightphe import LightPHE

# build a rsa cryptosystem
cs = LightPHE(algorithm_name="RSA")

# define plaintexts
m1 = 17; m2 = 23

# encrypt plaintexts
c1 = cs.encrypt(m1)
c2 = cs.encrypt(m2)

# homomorphic operation
c3 = c1 * c2

# proof of work
assert cs.decrypt(c3) == m1 * m2

Fakat RSA ile ciphertext’ler üzerinde toplama yapılmaya çalışılırsa aşağıdaki şekilde hata alınacaktır:

with pytest.raises(ValueError, match = "RSA is not homomorphic with respect to the addition"):
   _ = c1 + c2

RSA yerine Paillier kriptosistemini kullanırsak bu sefer toplama yapabiliriz ama çarpma yapamayız:

# build a paillier cryptosystem
cs = LightPHE(algorithm_name="Paillier")

# define plaintexts
m1 = 17; m2 = 23

# encrypt plaintexts
c1 = cs.encrypt(m1)
c2 = cs.encrypt(m2)

# homomorphic operation
c3 = c1 + c2

# proof of work
assert cs.decrypt(c3) == m1 + m2

with pytest.raises(ValueError, match = "Paillier is not homomorphic with respect to the multiplication"):
_ = c1 * c2

Sınırlı Homomorfik Şifreleme (Somewhat Homomorphic)

Sınırlı homomorfik şifreleme algoritması olan Boneh-Goh-Nissim ya da kısaca BGN ile hem toplama hem de çarpma yapabiliyoruz:

# build a bgn cryptosystem
cs = LightPHE(algorithm_name="Boneh-Goh-Nissim", key_size=50)

# define plaintexts
m1 = 17; m2 = 23

# encrypt plaintexts
c1 = cs.encrypt(m1)
c2 = cs.encrypt(m2)

# homomorphic operations
c3 = c1 + c2
c4 = c1 * c2

# proof of work
assert cs.decrypt(c3) == m1 + m2
assert cs.decrypt(c4) == m1 * m2

Peki hem toplama hem de çarpma yapabiliyorsak neden tamamen homomorfik (fully homomorphic) değil de sınırlı homomorfik? Çünkü BGN ile sınırsız sayıda toplama yapabiliyoruz ama çarpma işlemi yalnızca bir kez yapılabiliyor.

with pytest.raises(ValueError, match="Boneh-Goh-Nissim only supports multiplication ciphertexts once!"):
   # c4 was c1 * c2
   _ = c4 * c1

Bunun sebebi, BGN algoritmasının eliptik eğrileri kullanmasıdır ve toplama işlemi aslında eğri üzerindeki nokta toplamaya denk gelmektedir. Ancak eliptik eğriler üzerinde iki noktanın çarpılması işlemi tanımlı değildir. Yalnızca grup toplamı (iki noktanın toplanması) ve skalar çarpım (bir noktanın skalar bir değerle çarpılması) vardır. Bunun için eliptik eğri eşlemesi (pairing) kullanırız. Yani çalıştığımız uzayı eliptik eğri grubu olan G’den G_T’ye taşırız. Çarpma ile uzay bir kere G_T’ye taşındığında, bir daha çarpma yapılamamasının nedeni de tekrar G_T’ye taşınamayacak olmasıdır.

Yine de çarpma ile G_T uzayına geçtikten sonra bu uzaydaki elemanları kendi aralarında toplayabiliriz. Yani çarpma sonrası toplama geçerli bir işlemdir. Peki çok sayıda çarpımın kendi arasında toplanması işlemini nerede kullanıyoruz?

Lineer Regresyon

Lineer regresyon denklemini hatırlarsak:

y = Σ xi wi

Girdiler kendi ağırlıkları ile çarpılır ve bu çarpımlar kendi aralarında toplanır. Aşağıdaki şekilde hem girdileri hem ağırlıkları BGN kriptosistemi ile şifreledikten sonra ciphertext’ler kendi aralarında toplanırsa lineer regresyon sonucunu şifreli olarak elde ederiz.

cs = LightPHE(
   algorithm_name="Boneh-Goh-Nissim",
   key_size=50,
)

# Feature values
x1 = 5
x2 = 3

# Model weights
w1 = 7
w2 = 4

# Encrypt values
x1_enc = cs.encrypt(plaintext=x1)
w1_enc = cs.encrypt(plaintext=w1)

x2_enc = cs.encrypt(plaintext=x2)
w2_enc = cs.encrypt(plaintext=w2)

# Homomorphic multiplications (feature × weight)
x1w1_enc = x1_enc * w1_enc
x2w2_enc = x2_enc * w2_enc

# Homomorphic addition (sum of contributions)
sum_enc = x1w1_enc + x2w2_enc

# Decrypt final result
sum_decrypted = cs.decrypt(sum_enc)

assert sum_decrypted == (x1 * w1 + x2 * w2)

Kosinüs Benzerliği

Eğer kaynak ve hedef vektörleri L2 normalize durumda ise dot product işlemi kosinüs benzerliği verir:

v1 · v2 = Σ xi wi

Vektörün her boyutuna ait değeri BGN ile şifreledikten sonra aynı sıraya ait şifreli boyutlar kendi aralarında çarpılır ve bu çarpımlar kendi aralarında toplanırsa şifreli kosinüs benzerliğini hesap etmiş oluruz. Lineer regresyon implementasyonunda uyguladığımız kodu bire bir dot product ya da kosinüs benzerliği için kullanabiliriz.

Kısmi homomorfik şifreleme algoritmaları ile dot product hesabını kaynak ya da hedef vektörden biri plain durumdaysa toplamsal homomorfik algoritmalar ile gerçekleştirebiliyorduk. Bunu yaparken çarpım için toplamsal homomorfik algoritmaların skalar çarpma özelliğini kullandıktan sonra kendi aralarında toplama yapıyorduk. BGN ile kaynak ve hedef vektörlerin her ikisi de şifreli iken veya yine biri şifreli biri plain durumdaysa da bu işlem yapılabilmektedir.

Öklid Uzaklığı

Öklid uzaklığı formülünün sağ tarafında normalde karekök vardır:

d(v1, v2) = √(xi – yi)²

Öklid uzaklığının karesini hesaplamak istersek sağ taraftaki karekökten kurtuluruz:

d(v1, v2)² = Σ (xi – yi)²

Tabii karar alma adımında Öklid uzaklığı bir eşik değerden büyük mü küçük mü kontrolü yerine, Öklid uzaklığının karesi eşik değerinin karesinden büyük mü küçük mü diye kontrol edeceğiz.

Bu işlemdeki ikinci püf nokta, vektörlerden birini negatif değerleri ile şifrelemek olacaktır. Çünkü homomorfik olarak çıkarma işlemi tanımlı değildir; ancak sadece toplama kullanabiliyoruz. Çiftin biri negatif değerli ise toplamanın dağılım özelliğinde çıkarma sonucunu elde edebiliriz.

cs = LightPHE(algorithm_name="Boneh-Goh-Nissim", key_size=50)

# v1 = [5, 2, 8]
i1, i2, i3 = 5, 2, 8

# v2 = [1, 1, 2]
j1, j2, j3 = 1, 1, 2

# Encrypt v1
i1_enc = cs.encrypt(i1)
i2_enc = cs.encrypt(i2)
i3_enc = cs.encrypt(i3)

# Encrypt negative v2 (to simulate subtraction)
j1_enc = cs.encrypt(-j1)
j2_enc = cs.encrypt(-j2)
j3_enc = cs.encrypt(-j3)

# Compute squared Euclidean distance
euclidean_sqrt_enc = (
   (i1_enc + j1_enc) * (i1_enc + j1_enc)
   + (i2_enc + j2_enc) * (i2_enc + j2_enc)
   + (i3_enc + j3_enc) * (i3_enc + j3_enc)
)

assert (
   cs.decrypt(euclidean_sqrt_enc)
   == (i1 - j1) ** 2 + (i2 - j2) ** 2 + (i3 - j3) ** 2
)

Peki sınırlı homomorfik şifreleme ile ne yapamayız?

Lineer regresyonu modelleyebilmiştik ama lojistik regresyonu, Euler sayısının üssü şeklinde hesaplama gerektirdiği için yapamayız. Ya da deep neural networks hesabı BGN ile yapılamaz.

Yine de kısmi ve sınırlı homomorfik şifreleme algoritmaları, tamamen homomorfik algoritmalara göre daha kısa anahtar boyutu ve daha hızlı işlem süreleri ile geldiğinden, bu işlem setleri için tamamen homomorfik algoritmaları kullanmamız her zaman gerekmiyor.

Özet ve Sonuç

Bu yazıda homomorfik şifrelemenin farklı seviyelerini—partially, somewhat ve fully homomorphic encryption—birbirleriyle karşılaştırarak ele aldık ve özellikle somewhat homomorphic encryption yaklaşımını Boneh–Goh–Nissim (BGN) üzerinden inceledik. RSA ve Paillier gibi kısmi homomorfik sistemlerin yalnızca tek bir işlem türüne izin verdiğini, buna karşın BGN’nin hem toplama hem de sınırlı çarpma desteği sunarak daha geniş bir hesaplama alanı açtığını gördük.

Ancak bu esnekliğin bir bedeli var: işlem derinliği kısıtları. BGN gibi somewhat homomorphic sistemlerde çarpma işlemi sınırlı sayıda yapılabilirken, toplama işlemi çok daha serbesttir. Bu durum, özellikle lineer regresyon, dot product, kosinüs benzerliği ve Öklid uzaklığı gibi lineer cebire dayalı problemlerde güçlü kullanım senaryoları oluşturur. Buna karşılık, lojistik regresyon veya derin sinir ağları gibi yüksek dereceli non-lineer hesaplamalar için bu sistemler yetersiz kalır ve fully homomorphic encryption ihtiyacı ortaya çıkar.

Öte yandan, fully homomorphic encryption sistemlerinin sağladığı evrensellik, beraberinde yüksek hesaplama maliyeti ve büyük anahtar boyutları gibi pratik zorlukları da getirir. Bu nedenle birçok gerçek dünya uygulamasında, “tam homomorfik” yerine “yeterince homomorfik” sistemler daha verimli ve uygulanabilir bir denge sunar.

Sonuç olarak, homomorfik şifreleme bir spektrum olarak düşünüldüğünde, her seviyenin kendine özgü bir kullanım alanı vardır. Hangi yaklaşımın seçileceği ise tamamen problemin hesaplama derinliğine, performans gereksinimlerine ve gizlilik ihtiyaçlarına bağlıdır.

Eğer bu yazı hoşunuza gittiyse LightPHE reposuna GitHub’ta yıldız verebilirsiniz, bu projenin daha çok kişiye ulaşmasına yardımcı oluyor. Destekleriniz için şimdiden teşekkürler!

Özellikle kriptografiyle uğraşanlar ya da teknolojiye hakim kişiler arasında, iletişim bilgilerine GPG anahtarlarını eklediklerini hiç fark ettiniz mi? Uzun bir süredir bunun çok havalı bir şey olduğunu düşünüyordum.

Son zamanlarda üzerinde çalıştığım kurumsal bir proje, GPG’ye olan takdirimi daha da artırdı. Bu proje, bankalara SFTP üzerinden dosya gönderip almayı içeriyordu ve bu da dosyaların GPG ile şifrelenmesini ve şifresinin çözülmesini gerektiriyordu. Bu süreç, bana GPG’nin nasıl çalıştığını ve neden bu kadar güçlü bir araç olduğunu uygulamalı olarak anlamamı sağladı.

Bu yazıda o deneyimi paylacağım. GPG’nin ne olduğunu, PGP’den nasıl farklılaştığını ve en önemlisi nasıl kullanabileceğini anlatacağım. İster dosyalarını güvenli hale getirmek, ister iletişimlerini korumak, ister sadece bir kriptografi ustası gibi hissetmek iste, GPG bilmeye değer bir araç—ve açık anahtarını paylaşmak belki de yapabileceğin en havalı şey olabilir.

Arka Plan

GPG (GNU Privacy Guard), verileri şifrelemek ve dijital olarak imzalamak için kullanılan açık anahtarlı bir kriptografi aracıdır. PGP (Pretty Good Privacy) ile aynı prensiplere dayanır ve onun açık kaynaklı alternatifidir.

GPG, verileri güvenli bir şekilde iletmek için simetrik ve asimetrik şifrelemenin gücünü birleştirir. İşte nasıl çalıştığını basitleştirilmiş bir şekilde anlatan bir açıklama:

1. Adım: Rastgele Bir Simetrik Anahtar Oluşturulur

Bir mesajı veya dosyayı şifrelediğinizde, GPG önce rastgele bir simetrik anahtar üretir. Bu anahtar, içeriği AES gibi hızlı ve güvenli bir simetrik şifreleme algoritmasıyla şifrelemek için kullanılır.

2. Adım: Simetrik Anahtar, Alıcının Açık Anahtarıyla Şifrelenir

Daha sonra GPG, simetrik anahtarın kendisini alıcının açık anahtarıyla şifreler. Bu adım sayesinde yalnızca karşılık gelen özel anahtara sahip olan alıcı, simetrik anahtarı çözüp içeriğe ulaşabilir.

3. Adım: Şifrelenmiş Mesaj ve Anahtar Gönderilir

Şifrelenmiş içerik ve şifrelenmiş simetrik anahtar bir araya getirilir ve alıcıya gönderilir.

4. Adım: Alıcı, Simetrik Anahtarı Çözer

Alıcı, özel anahtarını kullanarak şifrelenmiş simetrik anahtarı çözer. Özel anahtar yalnızca alıcıya ait olduğundan, bu anahtara başkası erişemez.

5. Adım: Simetrik Anahtar, İçeriği Çözmek İçin Kullanılır

Simetrik anahtar çözüldükten sonra, alıcı bu anahtarı kullanarak içerikteki gerçek veriyi şifreli halinden çözer ve orijinal mesaj ya da dosyaya ulaşır.

GPG Neden Güvenli ve Verimlidir?

GPG ile her veri şifrelemede yeni bir simetrik anahtar oluşturulur. Bu rastgelelik, aynı mesajı defalarca şifreleseniz bile her seferinde farklı şifreli çıktılar elde edilmesini sağlar.

AES gibi simetrik şifreleme algoritmaları, asimetrik algoritmalara göre çok daha hızlıdır. Bu hibrit yaklaşım, hem güvenliği hem de verimliliği bir arada sunar.

Açık/özel anahtar kullanımı sayesinde yalnızca hedef alıcı, simetrik anahtarı çözebilir ve bu da sürecin tamamını güvence altına alır.

Simetrik ve asimetrik şifrelemenin bu şekilde bir araya gelmesi, hem performans hem de güvenlik açısından dengeli bir yapı sunar. Bu da GPG’yi güvenli iletişim ve dosya paylaşımı için ideal bir araç haline getirir.

GPG Anahtarlarınızı Oluşturmak

Dosyaları şifrelemeye veya şifresini çözmeye başlamadan önce, kendi GPG anahtarlarınızı oluşturmanız gerekir. Bu işlem, biri açık (public), diğeri özel (private) olmak üzere bir anahtar çifti yaratmayı içerir. Açık anahtar başkalarıyla paylaştığınız anahtardır; özel anahtar ise sizde kalır ve sizin açık anahtarınızla şifrelenmiş mesajları veya dosyaları çözmek için kullanılır.

Öncelikle, sisteminizde GPG yüklü olduğundan emin olun. Aşağıdaki komutları kullanarak GPG’yi yükleyebilirsiniz:

sudo apt update
sudo apt install gnupg

Anahtar oluşturma sürecini başlatmak için aşağıdaki komutu çalıştırın:

gpg --full-generate-key

Bu komut sizi kurulum süreci boyunca yönlendirecektir. Aşağıdaki bilgileri girmeniz istenecek:

Anahtar Türü (Key type): Varsayılan seçeneği, yani genellikle “RSA and RSA” olanı seçin. Bu seçenek hem imzalama hem de şifreleme için RSA algoritmasını kullanır.

Anahtar Boyutu (Key size): Bir anahtar boyutu belirtin. Önerilen 3072-bit RSA anahtarıdır. Bu uzunluk, 128-bit AES anahtarına denktir ve 2030 sonrasına kadar güvenli olduğu düşünülmektedir.

Geçerlilik Süresi (Expiration date): Süresiz geçerli olması için bu değeri 0 olarak ayarlayın. Dilerseniz belirli bir süre de tanımlayabilirsiniz.

Kullanıcı Kimliği (User ID): Adınızı ve e-posta adresinizi girin. Bu bilgiler, anahtarı listelerken onun kimliğini tanımlamak için kullanılır.

Parola (Passphrase): Özel anahtarınızı korumak için güçlü bir parola belirleyin. Bu parola, anahtarınızı izinsiz kullanıma karşı korur.

Anahtarınız oluşturulduktan sonra, aşağıdaki komutu kullanarak onu listeleyebilirsiniz:

# list public keys
gpg --list-keys
 
# list private keys
gpg --list-secret-keys

# açık anahtarımı dışa aktar
gpg --armor --export serengil@gmail.com > serengil-pub.asc

# özel anahtarımı dışa aktar
gpg --armor --export-secret-keys serengil@gmail.com > serengil-priv.asc

gpg --import tanja-2020.asc

gpg: key 82865C3243CECE97: public key "Tanja Lange <tanja@hyperelliptic.org>" imported
gpg: Total number processed: 1
gpg:               imported: 1

gpg --list-keys

/home/sefik/.gnupg/pubring.kbx
------------------------------
pub   rsa3072 2024-12-19 [SC]
      ECA0B32A46F96AA70CEEFD7C30F6E6D21EE91C2F
uid           [ultimate] Sefik Serengil <serengil@gmail.com>
sub   rsa3072 2024-12-19 [E]
 
pub   rsa4096 2020-02-09 [SC]
      A0DD00F5AEFA6086FEEF178E82865C3243CECE97
uid           [ unknown] Tanja Lange <tanja@hyperelliptic.org>
sub   rsa4096 2020-02-09 [E]

# create a plain message
echo "Dear Dr. Lange, I have been following your research for a long time, and you influenced me a lot. Wanted to share my respect. Regards." > message.txt
 
# encrypt message
gpg --armor --output message.gpg --encrypt --recipient tanja@hyperelliptic.org message.txt

-----BEGIN PGP MESSAGE-----
 
hQIMAz3PgQH4JT+0AQ/+Mx/WlxGC0C0F/oTdp/fndAmuXWt/Wzog3Cf42tG8ryc9
KuUE37QcXJQ/7d1AXDbOvq6hmYL+QRgVet4BahfqfBibk4ZIwT9uj2eJgdrsi9Dd
nOsM4AXIwLAZc7uGO+yYYrEHSEEdRIz4RlXz7UpTIYAxylESXBi5ElL76dm6FsSM
qvD1lodZNFkcOdZ5J+PZLurpD7Fh+9MloKI51SlaDp40d1cREp3MPffXdk5ZWzYS
avtaBD2qVj7syVuqSSzF23qP7a+sZhdtXlg1YY81Ft0f3PD4VbWZwHOSmrGKqCTA
Mg/HI6/5Lq24+ovAdPYhxpjy32CgWUBLyNaq0GYh7jA+Vn7u7bXbMz3f1Mc4CMcy
k9h3tLBB/4NvwHMFCD6Xn4GpGBetkLTc8vLpR8PbpHEfrJ/kHl0TuBDxR3Pw+2VL
16c+2ziEKDZxz+93ypvoA93V+sY4Crox7aFv5up7a4TioSHYff+6IgtuQufX4F1L
HAEuT8XouCstf79XsrY+m/mx8Vf65hFist2jIzlSp9TkInJf3fvK0WpBZ9WFhuHb
/9gf4lFP7zV0QApb4aQsMzkIL1HxsizOp+bObdZTCHn8PsIPUaercUMu/pzkZaef
cnW1GrVyLztxc7wdbT9RuG9RnEAE+WtKBjeHO79x6lWzT61pIHFwbKFZ6hD1fKfS
sAGE8iUhOo7ZoFvojA11GzcM2HQqtSjQouLh2uBvAATvRcQGRlnUWY6smBU6DY07
46IPh+B4ccVBAEkaxXi9Kk+rBYJjNmpx2bqvLva60iV6wuktCo5tMOP5EXzKWLlz
XmIL3Pc5LAi2lhuMXY9fFpv35DLvI10CwZxOwpnHqgZ953vp9V/xWsbLWANjppOQ
c54xgMiI7SMHPr86/znV8DzlYSUOp0Ot8HgJ1QbsOeP6
=K5xQ
-----END PGP MESSAGE-----

gpg --armor --output message.gpg --encrypt --sign --local-user serengil@gmail.com --recipient tanja@hyperelliptic.org message.txt

gpg --output decrypted-message.txt --decrypt message.gpg

pip install python-gnupg

import gnupg
 
# Initialize the GPG instance
gpg = gnupg.GPG()
 
name, mail, key_file = ("Tanja Lange", "tanja@hyperelliptic.org", "tanja-2020.asc")
imported_users = [imported_key["uids"][0] for imported_key in gpg.list_keys()]
 
if f"{name} <{email}>" not in imported_users:
   with open(key_file, 'r') as key_file:
      gpg.import_keys(key_file.read())

message = "This is a secret message for Someone."
 
encrypted_data = gpg.encrypt(
    message,
    recipients=['tanja@hyperelliptic.org'],
    sign="serengil@gmail.com",
    always_trust=True  # Trust the recipient's key without manual confirmation
)
 
assert encrypted_data.ok is True
 
# Save the encrypted message to a file
with open('message.gpg', 'w') as encrypted_file:
    encrypted_file.write(str(encrypted_data))

with open('message.gpg', 'r') as encrypted_file:
    encrypted_message = encrypted_file.read()
 
decrypted_data = gpg.decrypt(
    encrypted_message, passphrase=MY_PASSPHRASE
)
 
assert decrypted_data.ok is True
assert decrypted_data.signature is True:
 
print(f"decrypted message is {decrypted_data.data.decode()}")
print(f"Signed by: {decrypted_data.username}")

Dijital imzalar, modern sistemlerde veri bütünlüğünü ve kimlik doğrulamasını sağlamak için kritik bir rol oynar. Belgeleri imzalamaktan işlemleri doğrulamaya ve iletişim kanallarını güvence altına almaya kadar, dijital imzalar mesajların güvenilir kaynaklardan geldiğini ve değiştirilmediğini garanti eder. Bu yazıda, birden fazla imzalama algoritmasını ve eliptik eğri konfigürasyonunu destekleyen hafif ve esnek bir kriptografi aracı olan LightDSA kütüphanesini kullanarak Python’da dijital imzaların nasıl uygulanacağını inceleyeceğiz.

Vlog

Dijital İmzalar Nedir?

Dijital imzalar, şifreleme tekniklerini kullanarak dijital mesajların veya belgelerin bütünlüğünü ve kaynağını doğrulayan kriptografik yapılar olarak işlev görür. Geleneksel el yazısı imzalar gibi, dijital imzalar da bir mesajın kimden geldiğini kanıtlamak için kullanılır, ancak çok daha güvenli ve sahteciliğe karşı dayanıklıdırlar.

Dijital bir imza üç temel özelliği garanti eder:

• Kimlik Doğrulama: Mesajın belirli bir gönderen tarafından gönderildiğini doğrular.
• Bütünlük: Mesajın aktarım sırasında değiştirilmediğini doğrular.
• İnkar Edilememe: Gönderen daha sonra mesajı göndermediğini iddia edemez.

LightDSA Nedir?

LightDSA, Python’da RSA, DSA, ECDSA (Elliptic Curve Digital Signature Algorithm), EdDSA (Edwards-Curve Digital Signature Algorithm) gibi çeşitli dijital imzalama algoritmalarını destekleyen açık kaynaklı bir kütüphanedir. Ayrıca eliptik eğri formunu (Weierstrass, Koblitz veya Edwards), yüzlerce hazır eğri arasından seçimini (örneğin, bitcoin protokolü weierstrass formu ve secp256k1 eğrisini kullanır) ve anahtar uzunluklarını özelleştirme esnekliği sunar. LightDSA, özellikle farklı algoritmaları tek bir standart arayüzle karşılaştırmak ve test etmek isteyen geliştiriciler için idealdir.

LightDSA’yı pip aracılığıyla kolayca kurabilirsiniz:

pip install lightdsa

Sonrasında kütüphaneyi kullanmak için bağımlılığı şu şekilde berlitmeniz gerekiyor:

from lightdsa import LightDSA

Böylelikle artık LightDSA’ya ait fonksiyoneliteleri kullanabilirsiniz.

Eliptik Eğri Tabanlı Algoritmalar

LightDSA’nın portföyünde ECDSA ve EdDSA olmak üzere 2 eliptik eğri tabanlı modern algoritma bulunmaktadır.

Örneğin ECDSA ile hazır eğriler kullanarak kriptosistemimizi şu şekilde oluşturabiliriz. Bu işlem rastgele gizli ve açık anahtar çiftini üretecektir.

# bitcoin protokolunde kullanilan algoritma, form ve egri
dsa = LightDSA(
    algorithm_name = "ecdsa",
    form_name = "weierstrass",
    curve_name = "secp256k1",
)

Ya da daha modern bir algoritma olan EdDSA varsayılan form olarak edwards formunu ve ed25519 eğrisini kullanır.

dsa = LightDSA(
    algorithm_name = "eddsa",
    form_name = "edwards",
    curve_name = "ed25519"
)

Tabi ECDSA kullanırken edwards ya da EdDSA kullanırken Weierstrass formunu kullanmamıza bir engel yok ama pratikte çok kullanılmazlar.

Son olarak, Koblitz formu kriptografik donanım tasarımı için özelleştirilmiş asal alanlar yerine (prime field) ikili alanları (binary field) kullanan bir yöntemdir. Koblitz formuna ait bir kriptosistem üretmek için:

dsa = LightDSA(
    algorithm_name = "ecdsa",
    form_name = "koblitz",
    curve_name = "k163"
)

Özetle ECDSA ve EdDSA dijital imza algoritmaları için Weierstrass, Koblitz ya da Edwards formlarından birini seçebilirken bu formlara ait hazır eğrilerin listesine buradan erişebilirsiniz.

RSA ve DSA

Eliptik eğri tabanlı olmayan RSA ve DSA algoritmaları da LightDSA’nın portföyünde bulunmaktadır.

RSA için

# rsa kriptosisteminin insasi
dsa = LightDSA(
    algorithm_name = "rsa",
)

DSA için

# dsa kriptosisteminin insasi
dsa = LightDSA(
    algorithm_name = "dsa",
)

Anahtar Boyutları

RSA ve DSA ile insa edilen kriptosistemleri daha güvenli hale getirmek için inşa işlemi sırasında anahtar boyutlarını arttırabilirsiniz. RSA için varsayılan anahtar boyutu 3072, DSA için de 2048 bit’tir.

dsa = LightDSA(
    algorithm_name = "rsa", # or dsa
    key_size=7680
)

Anahtar boyutu belirleme işleminde bu tabloyu göz önünde bulundurmanızda fayda var.

Öte yandan ECDSA ve EdDSA için anahtar boyutu değiştirmek yerine eğrinin kendisini değiştirmelisiniz. Çünkü eliptik eğrinin toplam nokta sayısı zaten bellidir. Eğri listesinin bulunduğu tabloda “n (bits)” kolonu bu sayıyı belirler ve doğrudan kriptosistemin güvenliği ile ilişkilidir.

Gizli ve Açık Anahtarların Dışarı Aktarılması

İnşa ettiğiniz bir kriptosistemi bundan sonra hep kullanacaksınız. LightDSA objesini her inşa ettiğinizde size rastgele bir gizli – açık anahtar çifti üretecektir. Bunun önüne geçmek için kriptosistem bir kere inşa edildiğinde anahtarı şu şekilde dışarı aktarmalısınız:

# export private key
dsa.export_keys("secret.txt")
 
# export public key
dsa.export_keys("public.txt", public = True)

Kriptosistemin Restorasyonu

Gizli ve açık anahtarları dışarı aktardıysanız bunlarla kriptosistemi sıfırdan inşa etmek yerine şu şekilde restore edebilirsiniz:

signer_dsa = LightDSA(
    algorithm_name = algorithm_name,
    form_name = form_name,
    curve_name = curve_name,
    key_file = "secret.txt"
)
 
verifier_dsa = LightDSA(
    algorithm_name = algorithm_name,
    form_name = form_name,
    curve_name = curve_name,
    key_file = "public.txt"
)

Bunu yaparken aynı algoritma adı, form adı ve eğri adını göndermeniz gerekiyor.

İmza

Gizli anahtara sahip olduğunuz sürece imzalama işlemi oldukça basittir:

message = "Hello, world!"
signature = dsa.sign(message)

Doğrulama

Açık anahtara sahip olduğunuz sürece ise doğrulama oldukça basit olacaktır:

verifier_dsa.verify(message, signature)

Doğrulama methodu imzayı mesajdan doğrulayamazsa hata fırlatacaktır.

Sonuç

Özetleyecek olursak, neden LightDSA’yı kullanmalısınız?

• Hafifsiklet ve kullanımı kolay
• Tamamen konfigüre edilebilir kriptografik arka yüz
• Modern kriptografik standartları destekler
• Öğrenme, prototipleme ve hatta üretim ortamında kullanım için uygundur

LightDSA, farklı dijital imza algoritmaları ve eliptik eğri formları ve portföyündeki yüzlerce hazır eğri ile denemeler yapmanızı kolaylaştırır. İster güvenli sistemler geliştiriyor olun, ister modern kriptografinin nasıl çalıştığını öğrenmek istiyor olun, Python araç setinizde bulunması harika bir araçtır.

LightDSA kütüphanesine GitHub üzerinden yıldız vererek projeyi destekleyebilirsiniz!

Referans

S. I. Serengil, Digital Signatures in Python, 2025, Nisan.

Eliptik Eğri Kriptografisi (Elliptic Curve Cryptography – ECC), günümüz kriptografik sistemlerinin temel taşlarından biri haline geldi. Blockchain teknolojilerinde cüzdan adreslerinin oluşturulmasından işlem imzalarına kadar birçok alanda aktif olarak kullanılıyor. Peki ECC neden bu kadar popüler? RSA’dan farkı ne? Ve Python ile bunu nasıl uygulayabiliriz? Bu yazıda ECC’nin teorisine kısa bir giriş yaptıktan sonra, LightECC kütüphanesi ile sadece birkaç satır Python kodu yazarak eliptik eğri işlemlerini nasıl gerçekleştirebileceğimize odaklanacağız.

Elliptic Eğri Kriptografisi Python Kütüphanesi

Neden ECC Bu Kadar Yaygın?

ECC, özellikle Bitcoin ve Ethereum gibi blockchain sistemlerinde yoğun olarak kullanılıyor. Popüler imzalama algoritmaları olan ECDSA ve EdDSA da eliptik eğriler üzerine kuruludur.

Yakın zamanda GnuPG, varsayılan algoritmalarında RSA’dan vazgeçti. Artık şifreleme için Elliptic Curve Diffie-Hellman (ECDH), imzalama için ise EdDSA varsayılan olarak geliyor. Bu da ECC’nin geldiği noktayı gösteriyor.

Her ne kadar kuantum bilgisayarlara karşı kırılgan olsa da, Apple’ın iMessage protokolü hâlâ ECC kullanıyor—üstelik kuantum dirençli algoritmalarla birlikte, hibrit olarak.

ECC ve RSA Karşılaştırması: Verimlilik Meselesi

RSA, modüler üs alma gibi kavramlara dayandığı için insanlara daha anlaşılır geliyor olabilir. Ancak bilgisayarlar açısından bakıldığında ECC çok daha verimli: sadece toplama ve çarpma işlemleriyle çalışıyor.

Güvenliği artırmak için RSA’da anahtar boyutunu büyütmek gerekir ve bu da üstel şekilde işlem süresini artırır. Ancak ECC’de aynı güvenliği daha küçük anahtarlarla sağlayabiliriz ve işlem süresi lineer olarak artar. Örneğin, 256-bit ECC anahtarı ≈ 3072-bit RSA anahtarı ile aynı güvenlik seviyesini sunar.

ECC Karmaşık mı? Evet Ama Sorun Değil

ECC’nin kafa karıştırıcı olmasının bir sebebi de farklı eğri formlarının olmasıdır. Her formun kendi denklemi ve aritmetiği vardır. En yaygın 3 form şunlardır:

• Weierstrass: ECDSA’nın temel aldığı klasik form (örneğin secp256k1). y² = x³ + ax + b denklemini kullanır.
• Koblitz: Özel donanım tasarımları için daha verimli çalışan ikili (binary) alan için tasarlanmış eğriler. y² + xy = x³ + ax² + b denklemini kullanır.
• Edwards: EdDSA’nın kullandığı form, daha hızlı ve güvenli. x² + y² = 1 + dx²y² denklemini kullanır.

Grafiksel Yaklaşım

Weierstrass ve Koblitz: İki nokta arasında çizilen doğrunun eğriyi kestiği üçüncü noktayı alır, sonra x eksenine göre simetriği alınarak toplama işlemi tamamlanır.

Edwards eğrileri grafiksel olarak gösterilmez, ama işlemleri tümevarım ile ispatlanabilir.

Hadi Kodlayalım: Python ile ECC

ECC’yi sıfırdan kodlamak zorunda değilsiniz. LightECC kütüphanesi sayesinde eğri tanımlamak ve işlemler yapmak oldukça kolay.

LightECC Kurulumu için python package index (pypi / pip) üzerinden paketi şu şekilde kurmamız gerekiyor.

pip install lightecc

Daha sonra kütüphaneyi yükledikten sonra eğriyi istediğimiz form adı ve eğri adını belirterek tanımlarız

from lightecc import LightECC
 
# egri tanimlanir
ec = LightECC(
    form_name = "edwards", # veya weierstrass, koblitz. varsayilan weierstrass formudur.
    curve_name = "ed25519", # desteklenen egriler bolumune goz atin
)

Her eğrinin önceden tanımlanmış bir başlangıç baz noktası (generator base point) vardır ve bu herkes tarafından bilinir

# baz nokta
G = ec.G

Sonrasında baz noktadan yola çıkarak toplama, çıkarma, çarpma ve bölme operatörlerini kullanarak eğri üzerindeki farklı noktalara ulaşabiliriz.

# toplama
_2G = G + G
_3G = _2G + G
_5G = _3G + _2G
_10G = _5G + _5G
 
# cikarma
_9G = _10G - G
 
# carpma
_20G = 20 * G
_50G = 50 * G
 
# bolme
_25G = _50G / G

Örneğin bitcoin için seçtiğiniz gizli anahtar 25 ise, 25 * G hesaplaması sizin cüzdan adresinizi oluşturacaktır.

Bölme? O Kadar Kolay Değil…

LightECC, bölme işlemini destekliyor ancak bu işlem verimli değil. Aslında bu durum ECC’nin temel güvenlik prensibi olan Eliptik Eğri Ayrık Logaritma Problemi (ECDLP) ile açıklanabilir. Yani P = k * G ise, k’yı belli P ve G çiftinden bulmak bugünkü işlemci gücü ile çok ama çok zordur. Bu, ECC’yi güvenli yapan şeydir. Ama k ve G’yi biliyorsanız P’yi hesaplamak çok kolay ve hızlıdır.

Tüm Bu Detayları Bilmemiz Şart mı?

Aslında değil. Çoğu zaman kriptografik kütüphaneleri bir “siyah kutu” gibi kullanıyoruz.

Örneğin ECDSA ve EdDSA ile imzalama işlemlerini yapmanızı sağlayan LightDSA kütüphanesi eliptik eğri aritmetik işlemleri için doğrudan LightECC’yi kullanır.

Aynı şekilde Eliptic Eğri ElGamal algoritması ile kısmi homomorfik işlemi yapmanızı sağlayan LightPHE de eliptik eğri kriptografisi aritmetik işlemleri için LightECC’yi kullanıyor.

Ancak ECC’nin nasıl çalıştığını anlamak, doğru araçları seçmekte, daha güvenli sistemler tasarlamakta ve hatta katkı sağlamakta büyük rol oynar.

Sonuç

ECC hem güvenli, hem verimli, hem de matematiksel açıdan oldukça zarif bir teknolojidir. İlk başta karmaşık gibi görünse de, biraz emekle arkasındaki mantığı anlamak mümkün. LightECC gibi kütüphaneler sayesinde Python ile eğri aritmetiğini deneyimlemek artık çok kolay.

Son olarak, LightECC‘yi GitHub’ta yızdızlayarak bu çalışamaya destekte bulunabilirsiniz.

Referans

S. I. Serengil, Elliptic Curve Cryptography in Python, 2025, Nisan.

Veri tabanı derslerinde anlatılan normal formlar 90’lı yıllarda disklerin yüksek maliyetli olmaları sebebiyle veri çoklamayı önlemek üzere ortaya atılmış tekniklerdir. Günümüzde özellikle de bulut sistemler hayatımıza girdiğinden beridir verinin saklanması çok ucuzlamıştır. Fakat verinin bize ait olmayan üçüncü parti sistemlerde saklanması sebebiyle verinin güvenliği bugün hiç olmadığı kadar önem kazanmıştır.

Bulutta yer alan bir veri tabanında çalışanlarınızın maaşlarını saklamak istediğinizi varsayalım. Maaş bilgileri bulut sisteme açık olarak gönderilirse ve bulut ortamında şifrelenirse, anahtar bilgisi ele geçirilebileceğinden tüm maaş bilgilerinin çalınması ile karşılaşabiliriz.

Yerel sistemimizde 128 bitlik bir anahtar ürettikten sonra maaş bilgilerinin yine burada şifreleyip buluta şifrelenmiş maaşları gönderirsek çok güvenli bir sistem tasarlamış oluruz. Bulut ortama sızma olsa bile maaş bilgileri şifreli olacağı için bunun kırılması neredeyse imkansızdır.

Ancak bu dizaynda da bir handikap bulunmaktadır. Zam almanız durumunda maaşınızın güncellenmesi için buluttan şifreli maaş bilgisi yerel ortama çekilecek, yerel ortamda bu bilgi deşifrelenecek ve açık maaşınız elde edilecektir. Daha sonra açık maaş bilgisi zaman oranıyla güncellenecek, güncellenmiş maaş aynı anahtar kullanılarak yeniden şifrelenecek ve son olarak da güncellenmiş ve şifrelenmiş maaş bulut ortama aktarılacaktır. Bu tasarımda tüm hesaplama gücü yerel sistemde kullanılmış, bulut sistemin hesaplama gücünden neredeyse faydalanılmamıştır.

Peki daha iyi bir tasarım mümkün müdür?

Homomorfik Şifreleme

Şifreli veriler üzerinde toplama, çarpma gibi matematiksel işlemler yapmamıza izin veren kriptografik özelliklere homomorfik şifreleme diyoruz. Kriptografik algoritmalar toplama ya da çarpma üzerinde homomorfik özellik göstermesi halinde kısmi homomorfik (partially homomorphic), hem toplama hem de çarpma için homomorfik özellik göstermesi halinde de tamamen homomorfik (fully homomorphic) olarak sınıflandırıyoruz.

Homomorfik Algoritmalar

Örneğin RSA çarpımsal homomorfik iken, Paillier, Damgard-Jurik, Okamoto–Uchiyama, Benaloh, Naccache–Stern algoritmaları toplamsal homomorfiktir. Goldwasser–Micali algoritması ise XOR işlemi üzerinde homomorfik özellikler göstermektedir.

İstisna olarak ElGamal algoritması çarpımsal olarak homomorfik iken şifreleme fonksiyonunda yapılan ufak bir modifikasyon ile toplamsal olarak homomorfik hale dönüşmekte ancak çarpımsal olarak homomorfik özelliğini kaybetmektedir. Ayrıca bu modifikasyon kriptosistemin deşifreleme adımında ayrık logaritma probleminin çözümünü ilaveten getirdiğinden majör olarak zorlaştırmaktadır.

Bunun dışında elliptik eğri kriptografisi ve ElGamal kriptosistemlerinin birlikte kullanımı da bize toplamsal homomorfik özellik göstermekte. Ancak modifiye edilmiş ElGamal gibi deşifreleme adımı elliptik eğri ayrık logaritma probleminin çözümünü gerektirdiği için praktikten çok deneysel bir algoritma.

2009 yılında Craig Gentry, Stanford Üniversitesi’de doktora yaparken sunduğu tez çalışmasında tamamen homomorfizmin mümkün olduğunu gösterdiğinden beri Seal, TenSEAL gibi kütüphaneler ile tamamen homomorfik şifreleme pratik olarak hayatımızda yer almakta. Ancak anahtar boyutlarının ve şifreli metinlerin geleneksel açık anahtarlı şifreleme yöntemlerine göre çok çok uzun olması bu yöntemi daha çok deneysel bir yere koymakta.

Dolayısıyla bu yazımızda algoritmaların temellerine girmeden büyük resme odaklanarak kısmi homomorfik şifreleme yöntemleri kullanarak homomorfik şifrelemenin nasıl işlediğini anlatmaya çalışacağız. Prensip olarak aynı kurgu tamamen homomorfik şifreleme yöntemleri ile de uygulanabilir.

Hafif Siklet Kısmi Homomorfik Şifreleme Kütüphanesi

Deneylerimizde Python tabanlı LightPHE kütüphanesini kullanacağız. Kütüphaneyi ilk defa kullanacaksanız Python paket indeks üzerinden aşağıdaki komut ile kütüphaneyi indirebilirsiniz.

!pip install lightphe

# onprem.py
cs = LightPHE(algoritm_name = "Paillier")

# onprem.py
cs.export_keys(target_file="public.txt", public = True)

# cloud.py
cs = LightPHE(algoritm_name = "Paillier", key_file = "public.txt")

# onprem.py
m1 = 10000 # maas
m2 = 2000 # zam

c1 = cs.encrypt(m1).value
c2 = cs.encrypt(m2).value

# cloud.py
c1 = cs.create_ciphertext_obj(c1)
c2 = cs.create_ciphertext_obj(c2)

# cloud.py
pytest.raises(
   ValueError,
   match="You must have private key to perform decryption"
):
cs.decrypt(c1)


pytest.raises(
   ValueError,
   match="You must have private key to perform decryption"
):
cs.decrypt(c2)

# onprem.py
assert cs.decrypt(c1) == m1
assert cs.decrypt(c2) == m2

# cloud.py
c3 = c1 + c2
c3 = c3.value

# onprem.py
c3 = cs.create_ciphertext_obj(c3)
assert cs.decrypt(c3) == m1 + m2

# cloud.py
pytest.raises(
   ValueError,
   match="Paillier is not homomorphic with respect to the multiplication"
):
c1 * c2

# cloud.py
c4 = c1 * 1.05
c4 = c4.value

# onprem.py
c4 = cs.create_ciphertext_obj(c4)
assert cs.decrypt(c4) == m1 * 1.05

Kütüphane çeşitliliği python programlama dilini günümüzde bu kadar popüler yapan tetikleyicidir. Bu aynı zamanda açık kaynak kültürünü de benimsemeyi teşvik eden bir etkendir. Bu notkada PyPI (Python Package Index) conda gibi alternatifleri olsa da standart haline gelmiştir. Komut satırında pip install komutundan sonra indirmek istediğiniz paketin ismini yazmanız kurulumu gerçekleştirmeniz için yeterlidir. Kurulumun kolaylığı ile tezat bir şekilde ilk kez paket yayınlayacaklar için süreç biraz problematik. Son dönemlerde bir kaç açık kaynak kodlu projemi PyPI üzerinde yayınlama imkanı buldum. Yine bu blogta detaylarını paylaştığım deepface kütüphanesini hangi adımlar ile yayınladığıma bu yazıda değineceğim.

Kurulum rehberi

Öncelikle ana dizinde bir setup.py dosyası oluşturmanız gerekmekte.

import setuptools
 
with open("README.md", "r", encoding="utf-8") as fh:
    long_description = fh.read()
 
setuptools.setup(
    name="deepface",  
    version="0.0.11",
    author="Sefik Ilkin Serengil",
    author_email="sxxx@gmail.com",
    description="Deep Face Anaylsis Framework for Face Recognition and Demography",
    long_description=long_description,
    long_description_content_type="text/markdown",
    url="https://github.com/serengil/deepface",
    packages=setuptools.find_packages(),
    classifiers=[
        "Programming Language :: Python :: 3",
        "License :: OSI Approved :: MIT License",
        "Operating System :: OS Independent",
    ],
    python_requires='>=3.5.5',
    install_requires=["numpy>=1.14.0", "pandas>=0.23.4", "tqdm>=4.30.0", "gdown>=3.10.1", "matplotlib>=2.2.2", "opencv-python>=3.4.4", "Pillow>=5.2.0", "tensorflow>=1.9.0", "keras>=2.2.0"]
)

Pip paket ismini ilk almak isteyene rezerve ettiği için name argumanında gönderilecek isim tekil olmak zorunda. Aşağıdaki örnekte isim olarak deepface belirlenmiş. Pip üzerinden bu paket pip install deepface şeklinde indirilecek.

GitHub repo’larından aşina olduğumuz README.md dosyası paketin uzun açıklaması (long_description) olarak belirlenmiş.

Versiyon bilgisini (version) hep yapacağınız güncelleme için daha sonra arttırmalısınız. Çünkü yayınladığınız bir versiyonda bir hata fark ederseniz yayınlanmış o versiyonu silmenize izin olsa bile aynı versiyon ile bir daha bir şey yayınlayamıyorsunuz.

Bununla birlikte paketinizin bağımlı olduğu python dağılımı ve harici bağımlı kütüphaneleri de python_requires ve install_requires argumanlarında gönderebiliyorsunuz. Böylelikle pip install deepface komutu çalıştırıldığında ilk numpy 1.14’ün kurulumu gerçekleştiriliyor olacak.

Setup scriptinin olduğu dizinde paketinizin ismi ile aynı olan bir klasör yaratmalı ve tüm kaynak kodunuzu burada saklamalısınız. Birim testleriniz de aynı dizinde yer alabilirler.

Öncül konfigürasyonlar

Kaynak kodumuzun bulunduğu dizin ve tüm alt klasörlerde içi boş olsa da __init__.py dosyasını oluşturmamız gerekmekte.

deepface/__init__.py

deepface/basemodels/__init__.py

deepface/extendedmodels/__init__.py

deepface/commons/__init__.py

Klasör yapısı

Klasör yapısını baştan düzenlemeniz gerekecek. Örneğin deepface/DeepFace.py dosyasından deepface/basemodels/Facenet.py’i import etmek istiyoruz. Normal şartlarda aşağıdaki şekilde referans göstermemiz yetecekti.

from basemodels import Facenet

Ancak artık basemodels klasörünün deepface altında olduğunu belirtmem gerekecek.

from deepface.basemodels import Facenet

Yerel testler

Klasör yapınız düzenlendikten sonra artık kodunuz pypi’de yayınlanmaya hazır olacaktır. Ancak test etmeden paket yayınlamak çok mantıklı olmayacaktır. Setup scriptinin olduğu dizine gittikten sonra komut satırı çalıştırmanız gerekmekte.

pip install -e .

Yerel kurulum tamamlandıktan sonra artık paketinizi import edebileceksiniz. deepface klasörü altındaki DeepFace.py arayüzünün sunduğu tüm fonksiyonlara artık erişebileceksiniz.

from deepface import DeepFace

Yayınlamadan hemen önce

Yayınlama aşamasında pip üzerinden indirebileceğiniz 2 pakete ihtiyacımız olacak. Komut satırında aşağıdaki komutları çalıştırırsanız paketler hali hazırda kuruluysa güncelleyecek, değillerse de baştan indirecektir.

python -m pip install --user --upgrade setuptools wheel
python -m pip install --user --upgrade twine

Aynı zamanda PyPI.org adresine kayıt olmanız gerekmektedir. Yayınlama aşamasında kullanıcı adı ve şifrenizi komut satırında girmeniz beklenecek.

Yayınlama

Setup scriptini aşağıdaki şekilde çağıracağız öncelikle.

python setup.py sdist bdist_wheel

Bu ana dizinde dist adında bir klasör yaratacak ve paketinizin sıkıştırılmış halini içerecek.

Şimdi bu sıkıştırılmış paketi twine aracılığıyla pypi’ye yükleyeceğiz. Twine.exe pip ile indirildiği zaman benim yerel bilgisayarımda aşağıdaki dizine kaydedildi.

C:\Users\Sefik\AppData\Roaming\Python\Python36\Scripts\twine.exe

Bu dizini ortam değişkeni olarak eklerseniz twine komutunu çalıştırabileceksiniz. Ya da uzun uzun dizin bilgisi ile birlikte twine demeniz gerekecektir.

twine upload dist/*

Twine komutu çağırıldıktan sonra size pypi üyelik bilgilerinizi soracak. Kullanıcı adı ve şifrenizi komut satırına girdikten sonra paketiniz pypi üzerinden indirilebilir hale gelecektir.

Böylelikle paket yayınlama işlemi tamamlanmış olacak. Paketiniz pip install komutu ile artık indirilebilir. Böylelikle paketiniz daha çok kişiye ulaşabilir olacak. Açık kaynağın gelecek olduğunu unutmayın!

Bu yazı Publishing Python Packages on Pip and PyPI yazısından Türkçe’ye çevrilmiştir.

Merhaba Arkadaşlar ,

Bu makalemizde big data (büyük veri) uygulamaları yapabilmemizi sağlayan spark’ın kurulum ve üzerinde basit uygulamalar yapacağız.

Spark basit manada  ne yapıyor diyecek olursak  anlık veri işleyen , belirlediğimiz queryleri aralıklarla çalıştıran , makine öğrenmesi yapabilen ve en son olarak farklı veri tiplerimizi aynı platform üzerinde işlememize yardımcı olan  bir veri işleme motorudur.

Spark’ın çok hızlı bir biçimde verileri işler bunun nedeni ise verileri memory üzerinde manipüle eder.Verileri hafızada  nasıl depoluyor diyecek olrusak RDD(Resilient Distributed Datasets) yani esnek dağıtılmış veri setleri sayesinde bu işlemi yapıyor. Spark HDFS ,Cassandra Mongodb  vs . bunların yanı sıra işletim sistemi üzerindeki hemen hemen bütün dosya türler üzerinde koşabililr.

RDD hakkında biraz değinecek olursak bu datasetlere atılan veriler değiştirelemez. Bu yüzden bir veri üzerinde çalıştıktan sonra eğer değiştirmek yada tekrar o veri üzerinden işlem yapmak istiyorsak yeni bir dataset oluşturmalıyız. Bunu  yanı sıra rdd’ler memory cache çalışırlar bir referans üzerinde birden çok işlem yapacak olursak spark bunu tekrar tekrar oluşturmaz varolanı kullanır.

Şimdi ise yavaştan kuruluma geçelim ilk önce bilgisayarımızda python kurulmuş olması lazım. Python kurulumu için https://www.python.org/downloads/   bu adresten python’u indirelim. İndirdikten sonra bilgisayarımızda belirlediğiniz bir dizine çıkarın. Benim  C:pythonPythonPython35-32 dizinin altında bulunuyor. Python kurulumu bilgisayarımıza ortam değişkeni olarak ekledikten sonra bitiyor.

python kurulumu doğru yapmışmıyız diye komut satırını açıp “python” diyerek test edebilirsiniz. Herşey düzgün yapıldı ise çıktınız şu şekilde olacaktır.

Bundan sonra ise bilgisayarınızda javanın kurulu olması gerkiyor. Aynı Sonrasında ise aynı adımları izleyerek ortam değişkenlerini java_path ayarlamamız gerekiyor. Bu adresten jdk indirebilirsiniz.
http://www.oracle.com/technetwork/pt/java/javase/downloads/jdk8-downloads-2133151.html

Bu adımlardan sonra apache spark kurmaya hazırız. İlk önce bilgisayarımıza apache sparkı indirmeliyiz.

Adres: https://spark.apache.org/downloads.html

Ben version olarak “2.0.2-bin-hadoop2.7” indirdim. İndirme işlemini bitirdikten sonra belirlediğimiz dizinimize zipli dosyayı çıkartıyoruz. Benim çıkarttığım dizin “C:sparkspark-2.0.2-bin-hadoop2.7” bu şekildedir.

Sonrasında ise işletim sistemimizin  ortam değişkenlerimize spark’ı eklemeliyiz.

Artık tüm kurulumları tamamladık ve spark’ı çalıştıralım .  Apache Spark’ı çalıştırabilmek için  komut satırı açıp spark’ın kurulu olduğu dizinin altında bin klasörüne gitmemiz lazım.

cmd>>cdC:sparkspark-2.0.2-bin-hadoop2.7bin

Sonrasında ise komut satırında bu dizine geldikten sonra pyspark diyerek spark’ı çalıştırabiliriz. Kurulumunuz sorunsuz ise aşağıdaki gibi bir çıktı almanız gerekiyor.

Herşey tamam ise basit birkaç örnek yapalım . ilk önce bir tane rdd oluştutup belirli bir dosyamızın içinde count almayı deneyelim. Ben “yazarlar.bilisim.io” adlı dosyamızı bin dizinin altına kaydettim.

Şimdi ise count almayı deneyelim.

İlk önce dosyamızı rdd’ye tanımlayalım. Bunun için bu komut’u yazıyoruz.

>>>bilisimYazarlarRdd=sc.textFile(‘yazarlar.bilisim.io’)

Bu komut ile artık rdd file oluşturmuş olduk. Şimdi ise dosyamızın içinden count alalım. Dosyamızın içeriği şu şekildeydi.

Oluşturduğumuz rdd datasetimizden count almak için ise komutumuz şu şekilde olacaktır.

>>> bilisimYazarlarRdd.count()

Çıktısı şu şekildedir.

Şimdi ise aynı dosyamız içersinde filtreleme yaparak  yeni rdd olusturup bunun count’unu alalım. Neden ayrı rdd olusturuyoruz diye sorarsak makalemizin baındada rdd’ler ile iliglili bahsetmiştik değiştirelemeyeceklerini bu yüzden yeni rdd olusturup onun countunu alacağız.

>>> yazarlarRddFilter = bilisimYazarlarRdd.filter(lambda line:’Mehmet’ in line)
bu satırda eski rddmizi filtreleyip içerisindeki aratacağımız kelimeyi yazıyoruz . ve yeni rddmizi oluşturmuş oluyoruz.

Yeni rdd’mizde count aldığımızda  şöyle bir çıktı almamız lazım . Ben bir kaç örnek daha yaptım resimde yazarların post sayılarına göre filtreledim.

>>> yazarlarRddFilter.count()

Çıktısı şu şekildedir :

Bazı  spark komutları :

bilisimYazarlarRdd.first()   —>rdd içerisindeki ilk elamanı verir.

bilisimYazarlarRdd.map(lambda line: len(line.split())).reduce(lambda a, b: a if (a > b) else b)  —>Bu komut satırı ise tüm dosyadaki lineları okuyor ve boşluğu referans alarak yanyana en çok kaç tane kelime yazılmış onun size’ını alıyor.

Daha çok  komutları incelemek için ise https://spark.apache.org/docs/2.0.2/quick-start.html adresinden bakabilirsiniz.

Kurulum ve basit örnekler ile şimdilik yazımı sonlandırıyorum .Apache  Spark serisine devam edeceğim konu “Spark Streaming ve Kafka Entegrasyonu” olacaktır.  Sitemizi takip ederek bu konuyuda öğrenebilirsiniz.

Umarım Yararlı olmuştur.

iyi Çalışmalar

Herkese tekrardan selamlar, Python yazı serisinin ikinci etabına hoş geldiniz. Bu yazıda Python ile yazacağımız kodları kullanıcı ile etkileşime nasıl geçireceğimize ve değişkenlere değineceğiz. Peki nedir bu kullanıcı ile etkileşim? Kullanıcıya bir kaç soru soracağız ve kullanıcı bu sorulara cevap verecek kullanıcıdan gelen cevapları ise değişkenlerimizin içerisine koyup kullanıcıdan gelen veri ile işlem yapabilecek hale gelmiş olacağız.

Giriş seviyesinden başlayıp ileri seviyelere devam edeceğimizi önceki yazımda belirtmiştim bazı arkadaşlar için bu yol biraz sıkıcı olabilir fakat 4-5 hafta içerisinde herkes için çok daha eğlenceli ve daha karmaşık kodlar yazmaya başlamış olacağız.

Dönelim konumuza şimdi kullanıcıdan aldığı iki sayıyı birbiri ile çarpan sonrasında bu çarpım işleminin sonucunu ekrana yazdıran kodumuzu yazalım.

sayi1 = input('Birinci sayi: ')
sayi2 = input('Ikinci sayi: ')

Öncelikle kullanıcıdan sırasıyla iki adet sayı istemiş olduk. Fakat input fonksiyonu bu sayıları sayi1 ve sayi2 değişkenlerine atarken bunları string veri tipi olarak aktardı bu demek oluyor ki biz bu iki değişken üzerinde matematiksel bir işlem yapamayız. Bunun için ne yapmamız gerekir? Öncelikle bu iki değişken ile matematiksel bir işlem yapmaya kalkıştığımızda karşımıza ne gibi bir hata çıkacağını görelim ve kodumuza alttaki satırları ekleyelim.

sonuc = sayi1 * sayi2
print("Sonuc: ", sonuc)

Bir önceki yazımızda uygun çalışma ortamının nasıl kurulduğuna değinmiştik. Ben yazı serisi boyunca aynı kurulum ortamında devam edeceğim.

Şimdi kodumuzu çalıştıralım.

Kodu çalıştırdığımız zaman yukarıdaki hata ile karşılaşıyoruz. Bunun sebebi string(str) tipinde yani karakter değeri taşıyan iki değişkeni birbiri ile çarpmaya çalışmamızdan kaynaklı. Python yukarıda bize bu işlemi gerçekleştiremeyeceğini belirtiyor. Peki bu problemden kurtulmanın yolu nedir? Çok kolay

sonuc = int(sayi1) * int(sayi2)
print("Sonuc: ", sonuc)

Son iki satırımızı yukarıdaki kod ile değiştiriyoruz. Burada tür dönüşümü yapmış olduk yani kullanıcıdan aldığımız sayi1 ve sayi2 değişkenleri bize ilk etapta string veri tipi olarak döndü fakat biz bununla matematiksel bir işlem gerçekleştirebilmek adına int() fonksiyonu yardımı ile string to integer tür dönüşümünü gerçekleştirip değişkenlerimizi integer veri tipine dönüştürmüş olduk bu da bize artık bu iki değişkeni kullanarak matematiksel işlem yapabilme özgürlüğünü tanımış oldu.

Değişkenleri yazı serimiz boyunca her an çok yoğun bir şekilde kullanmaya devam edeceğiz onlar bizim boş kovalarımız olacak her zaman onları doldurarak devam edeceğiz. Özel olarak değişkenlere değinmedim çünkü yeri geldikçe tüm değişken tiplerini görüyor olacağız ve her yeni değişken tiplerini nasıl kullanacağımızı ve neler yapmamız gerektiğini yazı serimiz boyunca sizlere anlatıyor olacağım.

Kodumuzun son hali aşağıdaki hale gelmiş oldu.

sayi1 = input('Birinci sayi: ')
sayi2 = input('Ikinci sayi: ')
sonuc = sayi1 * sayi2
print("sonuc: ", sonuc)

Önümüzdeki hafta if-elif-else blokları ile yazımıza devam edeceğiz. Şimdilik hoşçakalın

Python, öğrenmesi ve sözdizimi olarak çok kolay olsa da, aslında çok geniş bir dünya sunan yazılım dillerinden biri. Bu nedenle, sadece Python sözdizimini öğrenmek, Python ile her şeyi yapabilecek yetkinliğine kavuştuğunuz anlamına gelmiyor maalesef. Bir adım ileri gidip, Python için yayınlanmış paketleri de öğrenmelisiniz. Örneğin; kariyer hedefiniz veri bilimcisi (data scientist) olmak ise öğrenmeniz gereken iki ana paket mevcut: Numpy ve Pandas. Bu iki pakete ve daha ileri adımlarda neler öğrenmeniz gerekeceğine, yazımızın ilerleyen haftalardaki bölümlerinde ayrıntılı olarak değineceğiz. Şimdi öncelikle Python’a dair temel giriş bilgilerini öğrenmekle başlayalım.

Python’ı kim, ne zaman geliştirdi?

Python, Hollandalı yazılımcı Guido Van Rossum tarafından 1990 yılında geliştirilmeye başlandı. Yani, birçoğunuz Python’ı yeni yeni duymaya başlamış olsa da Python zannedildiği kadar taze bir dil değil.

Kimler kullanır?

Bu sorunun cevabını ben kendi sosyal çevremde “Kim neden kullanmasın ki?” şeklinde cevaplıyorum fakat bu cevap bu platformda sizler için yeterli olmayacaktır 🙂 O nedenle Python’ı kullanan çevre kısaca şu şekilde sıralanabilir:

• Veri Bilimcileri (Data Scientists),
• Web Geliştiricileri (Web Developers),
• Yazılım Kalite Güvence Mühendisleri (Software QA Engineers),
• Makine Öğrenimi Mühendisleri (Machine Learning Engineers),
• Masaüstü yazılımları yapmak isteyenler,
• Oyun geliştirmek isteyenler.

Python ile Arduino, Raspi ve benzeri programlanabilir elektronik kartlar bile kodlayabilirsiniz fakat bu örneklendirme çok uzun bir liste halinde devam edebilir sizi sıkmamak adına burada kesiyorum.

Nasıl kullanılır?

Python kullanabilmek için öncelikle kurulumunu yapmak gerekir. Tam olarak bu sebepten dolayı “Python ile ne yapılamaz?” sorusuna verilebilecek cevaplardan biri “Python ile işletim sistemi yazılamaz!” olacaktır.

Gelelim nasıl kurulum yapacağımıza. Öncelikle https://www.python.org/downloads/ adresi üzerinden Python son versiyonunu indirelim. İndirdiğimiz dosyaya çift tıklayıp alışık olduğumuz kurulum aşamalarını tamamladıktan sonra, Python bilgisayarımızda kullanılabilir hale gelecektir.

Terminal’i açıp python3 yazıp enter tuşuna bastığımızda karşımıza aşağıdaki görsele benzer bir ekran geliyorsa da, yüklememiz sorunsuz bir şekilde tamamlandı demektir.

Terminal üzerinde de Python kodu yazıp çalıştırabilirsiniz fakat bu yöntem pek kullanışlı olmayacağı için ilk ve geleneksek Hello World örneğimizi aşağıdaki shell komutlarını teker teker Terminal üzerinde çalıştırarak Python çalışma ortamımızı kuruyoruz:

1. cd Desktop —> Bilgisayarımızda Desktop dizinine erişmemizi sağladı,
2. mkdir PythonBilisimIO —> Desktop dizini içerisinde yeni bir klasör oluşturduk,
3. touch main.py —> Python kodlarımızı yazacağımız .py uzantılı dosyamızı oluşturmuş olduk,

Şimdi PythonBilisimIO dosyamızı bir kod editörü yardımı ile açalım (Sublime Text, VS Code). Ben Visual Studio Code’u kullanmayı tercih ediyorum ve serinin devamında da VS Code kullanırken göreceksiniz.

İlk örneğimiz olarak ekrana 10 kez “Hello World” yazdıran kodumuzu oluşturalım. Eğer kodlamaya yeni başlayan biriyseniz “Döngüler neydi, while neydi?!” diye korkup kaçmayın. Zira bu yazı dizisinde temel seviyeden başlayıp ileri seviyeye kadar Python ile ilgili her şeyi sizlere anlatmaya çalışacağım. İlerleyen yazılarda” while ve for döngülerine”, “ if else yapılarına” değineceğiz ve bunlarla sınırlı kalmayıp birkaç meslek grubunun Python’ı nasıl kullandıklarını da örnekler üzerinden beraber göreceğiz.

i = 0 # i degiskeni var olmadigi icin oncelikle i degiskenimizi tanimliyor ve 0 degerini atiyoruz
while i < 10: # ekrana 10 kez yazdirabilmek icin 10 kez donecek bir dongu kuruyoruz
    print(i, " Hello World") # i'nin degerini ve "Hello World" yazan print fonksiyonumuz
    i = i + 1 # dongu her ekrana Hello World yazdirdiginda i degerini +1 
              # arttiriyoruz ki sonsuz dongu icerisine girmeyelim

# python kodlarini calistirmanin ne kadar kolay olduguna gelelim
# terminal yardimi ile PythonBilisimIO dosyamizin icerisine gidelim VS CODE ile integrated terminal kullanirsaniz
# direkt olarak VS CODE'da acik olan dosyanin icerisinde bir Terminal acmis oluyor size
# Terminal'e:
# python3 main.py
# yazıp enter tusuna bastigimiz zaman ekrana 10 tane Hello World yazdirdigini goreceksiniz.

Haftada bir yayınlanacak Python yazı dizisinin ilk bölümüne şimdilik noktayı koyuyoruz. Zaman ayırdığınız için teşekkürler. Gelecek hafta görüşmek üzere

Bir sonraki yazı: Bir Python Yazı Dizisi: Kullanıcı ile etkileşim ve değişkenler