Kriptografi: Gizlilik ve Güvenlik

def caesar_encrypt(text, shift):
    encrypted = ""
    for char in text:
        if char.isalpha():
            ascii_offset = 65 if char.isupper() else 97
            encrypted += chr((ord(char) - ascii_offset + shift) % 26 + ascii_offset)
        else:
            encrypted += char
    return encrypted
def caesar_decrypt(text, shift):
    return caesar_encrypt(text, -shift)
# Örnek kullanım
message = "MERHABA DUNYA"
shift = 3
encrypted = caesar_encrypt(message, shift)
decrypted = caesar_decrypt(encrypted, shift)
print(f"Orijinal: {message}")
print(f"Şifreli: {encrypted}")
print(f"Çözülmüş: {decrypted}")

def vigenere_encrypt(text, key):
    encrypted = ""
    key = key.upper()
    key_index = 0
    for char in text.upper():
        if char.isalpha():
            shift = ord(key[key_index % len(key)]) - 65
            encrypted += chr((ord(char) - 65 + shift) % 26 + 65)
            key_index += 1
        else:
            encrypted += char
    return encrypted
def vigenere_decrypt(text, key):
    decrypted = ""
    key = key.upper()
    key_index = 0
    for char in text:
        if char.isalpha():
            shift = ord(key[key_index % len(key)]) - 65
            decrypted += chr((ord(char) - 65 - shift) % 26 + 65)
            key_index += 1
        else:
            decrypted += char
    return decrypted
# Örnek kullanım
message = "KRIPTOGRAFI"
key = "ANAHTAR"
encrypted = vigenere_encrypt(message, key)
decrypted = vigenere_decrypt(encrypted, key)
print(f"Şifreli: {encrypted}")
print(f"Çözülmüş: {decrypted}")

from cryptography.fernet import Fernet
# Rastgele bir anahtar oluştur
key = Fernet.generate_key()
cipher_suite = Fernet(key)
# Mesajı şifrele
message = "Bu bir gizli mesajdır.".encode()
cipher_text = cipher_suite.encrypt(message)
# Mesajı çöz
plain_text = cipher_suite.decrypt(cipher_text)
print(f"Orijinal: {message.decode()}")
print(f"Şifreli: {cipher_text}")
print(f"Çözülmüş: {plain_text.decode()}")

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
import binascii
# Anahtar çifti oluştur
key = RSA.generate(2048)
private_key = key.export_key()
public_key = key.publickey().export_key()
# Public key ile şifrele
recipient_key = RSA.import_key(public_key)
cipher_rsa = PKCS1_OAEP.new(recipient_key)
message = "Gizli mesaj".encode()
encrypted = cipher_rsa.encrypt(message)
# Private key ile çöz
private_key_obj = RSA.import_key(private_key)
cipher_rsa = PKCS1_OAEP.new(private_key_obj)
decrypted = cipher_rsa.decrypt(encrypted)
print(f"Şifreli: {binascii.hexlify(encrypted).decode()[:50]}...")
print(f"Çözülmüş: {decrypted.decode()}")

from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.hazmat.primitives.asymmetric import utils
# ECC anahtar çifti oluştur (SECP256R1)
private_key = ec.generate_private_key(ec.SECP256R1())
public_key = private_key.public_key()
# Mesajı imzala
message = b"Bu mesajın imzası atıldı."
signature = private_key.sign(
    message,
    ec.ECDSA(hashes.SHA256())
)
# İmzayı doğrula
try:
    public_key.verify(signature, message, ec.ECDSA(hashes.SHA256()))
    print("İmza doğrulandı: Geçerli")
except Exception as e:
    print("İmza doğrulanamadı: Geçersiz")

import hashlib
def calculate_hash(data, algorithm='sha256'):
    hash_obj = hashlib.new(algorithm)
    hash_obj.update(data.encode())
    return hash_obj.hexdigest()
# Örnek kullanım
text = "Kriptografi öğreniyorum"
sha256_hash = calculate_hash(text, 'sha256')
sha512_hash = calculate_hash(text, 'sha512')
print(f"SHA-256: {sha256_hash}")
print(f"SHA-512: {sha512_hash}")
# Veri bütünlüğü kontrolü
original_hash = sha256_hash
modified_text = "Kriptografi öğreniyorum!"  # ! eklendi
modified_hash = calculate_hash(modified_text, 'sha256')
print(f"Değiştirildi: {original_hash != modified_hash}")

import hashlib
import json
import time
class Block:
    def __init__(self, index, transactions, previous_hash, nonce=0):
        self.index = index
        self.timestamp = time.time()
        self.transactions = transactions
        self.previous_hash = previous_hash
        self.nonce = nonce
        self.hash = self.calculate_hash()
    def calculate_hash(self):
        block_string = json.dumps(self.__dict__, sort_keys=True).encode()
        return hashlib.sha256(block_string).hexdigest()
class Blockchain:
    def __init__(self):
        self.chain = []
        self.create_genesis_block()
    def create_genesis_block(self):
        genesis_block = Block(0, [], "0")
        self.chain.append(genesis_block)
    def get_last_block(self):
        return self.chain[-1]
    def add_block(self, transactions):
        last_block = self.get_last_block()
        new_block = Block(
            index=last_block.index + 1,
            transactions=transactions,
            previous_hash=last_block.hash
        )
        self.chain.append(new_block)
        return new_block
# Basit bir blockchain oluştur
bc = Blockchain()
bc.add_block(["Ali 5 BTC gönderdi"])
bc.add_block(["Ayşe 3 BTC gönderdi"])
for block in bc.chain:
    print(f"Blok {block.index}: {block.hash}")

from cryptography.fernet import Fernet
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.asymmetric import rsa, padding
# Simetrik şifreleme (Fernet = AES + HMAC)
key = Fernet.generate_key()
f = Fernet(key)
token = f.encrypt(b"Gizli veri")
print(f"Şifreli: {token}")
print(f"Çözülmüş: {f.decrypt(token)}")
# Asimetrik şifreleme (RSA)
private_key = rsa.generate_private_key(
    public_exponent=65537,
    key_size=2048
)
public_key = private_key.public_key()
message = b"Gizli mesaj"
encrypted = public_key.encrypt(
    message,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
decrypted = private_key.decrypt(
    encrypted,
    padding.OAEP(
        mgf=padding.MGF1(algorithm=hashes.SHA256()),
        algorithm=hashes.SHA256(),
        label=None
    )
)
print(f"Asimetrik Çözüm: {decrypted}")

import hashlib
import secrets
import string
def generate_salt(length=32):
    return secrets.token_hex(length)
def hash_password(password, salt):
    pwd_salt = password + salt
    pwd_hash = hashlib.sha256(pwd_salt.encode()).hexdigest()
    return pwd_hash
# Kullanım
password = "BenimGüçlüŞifrem123!"
salt = generate_salt()
hashed = hash_password(password, salt)
print(f"Salt: {salt}")
print(f"Hash: {hashed}")
# Doğrulama
def verify_password(password, salt, hashed):
    return hash_password(password, salt) == hashed
print(f"Doğrulama: {verify_password(password, salt, hashed)}")