python import json from typing import Dict

1. Substitution (Yerine Koyma) Şifreleme

substitution_table = { 'A': 'Q', 'B': 'W', 'C': 'E', 'D': 'R', 'E': 'T', 'F': 'Y', 'G': 'U', 'H': 'I', 'I': 'O', 'J': 'P', 'K': 'A', 'L': 'S', 'M': 'D', 'N': 'F', 'O': 'G', 'P': 'H', 'Q': 'J', 'R': 'K', 'S': 'L', 'T': 'Z', 'U': 'X', 'V': 'C', 'W': 'V', 'X': 'B', 'Y': 'N', 'Z': 'M' } reverse_substitution_table = {v: k for k, v in substitution_table.items()}

def substitution_encrypt(text: str) -> str: return ''.join(substitution_table.get(c.upper(), c) for c in text)

def substitution_decrypt(text: str) -> str: return ''.join(reverse_substitution_table.get(c.upper(), c) for c in text)

2. Caesar (Kaydırmalı) Şifreleme

def caesar_encrypt(text: str, shift: int = 3) -> str: result = '' for c in text: if c.isalpha(): base = ord('A') if c.isupper() else ord('a') result += chr((ord(c) - base + shift) % 26 + base) else: result += c return result

def caesar_decrypt(text: str, shift: int = 3) -> str: return caesar_encrypt(text, -shift)

3. Vigenère Şifreleme

def vigenere_encrypt(text: str, key: str) -> str: result = '' key = key.upper() key_length = len(key) key_index = 0 for c in text: if c.isalpha(): base = ord('A') if c.isupper() else ord('a') k = ord(key[key_index % key_length]) - ord('A') result += chr((ord(c) - base + k) % 26 + base) key_index += 1 else: result += c return result

def vigenere_decrypt(text: str, key: str) -> str: result = '' key = key.upper() key_length = len(key) key_index = 0 for c in text: if c.isalpha(): base = ord('A') if c.isupper() else ord('a') k = ord(key[key_index % key_length]) - ord('A') result += chr((ord(c) - base - k) % 26 + base) key_index += 1 else: result += c return result

4. XOR Tabanlı Şifreleme

def xor_encrypt(text: str, key: int = 42) -> str: return ''.join(chr(ord(c) ^ key) for c in text)

def xor_decrypt(cipher: str, key: int = 42) -> str: return xor_encrypt(cipher, key) # XOR işlemi tersinir

5. Matris (Transposition) Şifreleme

def matrix_encrypt(text: str, num_cols: int = 5) -> str: text = text.replace(' ', '_') # Boşlukları korumak için alt çizgiye çeviriyoruz rows = [text[i:i+num_cols] for i in range(0, len(text), num_cols)] cipher = '' for col in range(num_cols): for row in rows: if col < len(row): cipher += row[col] return cipher

def matrix_decrypt(cipher: str, num_cols: int = 5) -> str: num_rows = (len(cipher) + num_cols - 1) // num_cols full_cols = len(cipher) % num_cols matrix = [''] * num_rows idx = 0 for col in range(num_cols): for row in range(num_rows): if col < num_cols - 1 or row < full_cols or full_cols == 0: if idx < len(cipher): matrix[row] += cipher[idx] idx += 1 return ''.join(matrix).replace('_', ' ')

Ana program

if name == "main": text = input("Şifrelenecek metni girin: ") key_vigenere = "KEY" shift_caesar = 3 xor_key = 42 num_cols = 5

results: Dict[str, Dict[str, str]] = {}

# Substitution
sub_enc = substitution_encrypt(text)
sub_dec = substitution_decrypt(sub_enc)
results['substitution'] = {'encrypted': sub_enc, 'decrypted': sub_dec}

# Caesar
caesar_enc = caesar_encrypt(text, shift_caesar)
caesar_dec = caesar_decrypt(caesar_enc, shift_caesar)
results['caesar'] = {'encrypted': caesar_enc, 'decrypted': caesar_dec}

# Vigenère
vigenere_enc = vigenere_encrypt(text, key_vigenere)
vigenere_dec = vigenere_decrypt(vigenere_enc, key_vigenere)
results['vigenere'] = {'encrypted': vigenere_enc, 'decrypted': vigenere_dec}

# XOR
xor_enc = xor_encrypt(text, xor_key)
xor_dec = xor_decrypt(xor_enc, xor_key)
results['xor'] = {'encrypted': xor_enc, 'decrypted': xor_dec}

# Matrix
matrix_enc = matrix_encrypt(text, num_cols)
matrix_dec = matrix_decrypt(matrix_enc, num_cols)
results['matrix'] = {'encrypted': matrix_enc, 'decrypted': matrix_dec}

# Sonuçları JSON dosyasına kaydet
with open('sonuclar.json', 'w', encoding='utf-8') as f:
    json.dump(results, f, ensure_ascii=False, indent=4)
print(\"Tüm yöntemlerle şifreleme ve çözme sonuçları sonuclar.json dosyasına kaydedildi.\")

c #include <stdio.h> #include <string.h> #include <stdlib.h> #include <ctype.h>

// Substitution (Yerine Koyma) Şifreleme Tablosu char substitution_table[26] = { 'Q','W','E','R','T','Y','U','I','O','P', 'A','S','D','F','G','H','J','K','L','Z', 'X','C','V','B','N','M' };

// Substitution Şifreleme void substitution_encrypt(char *text, char *output) { int i; for (i = 0; text[i] != '\0'; i++) { if (isupper(text[i])) output[i] = substitution_table[text[i] - 'A']; else if (islower(text[i])) output[i] = tolower(substitution_table[text[i] - 'a']); else output[i] = text[i]; } output[i] = '\0'; }

// Substitution Çözme void substitution_decrypt(char *text, char *output) { int i, j; for (i = 0; text[i] != '\0'; i++) { if (isupper(text[i])) { for (j = 0; j < 26; j++) { if (substitution_table[j] == text[i]) { output[i] = 'A' + j; break; } } } else if (islower(text[i])) { for (j = 0; j < 26; j++) { if (tolower(substitution_table[j]) == text[i]) { output[i] = 'a' + j; break; } } } else { output[i] = text[i]; } } output[i] = '\0'; }

// Caesar Şifreleme void caesar_encrypt(char *text, char *output, int shift) { int i; for (i = 0; text[i] != '\0'; i++) { if (isupper(text[i])) output[i] = ((text[i] - 'A' + shift) % 26) + 'A'; else if (islower(text[i])) output[i] = ((text[i] - 'a' + shift) % 26) + 'a'; else output[i] = text[i]; } output[i] = '\0'; }

void caesar_decrypt(char *text, char *output, int shift) { caesar_encrypt(text, output, 26 - (shift % 26)); }

// Vigenère Şifreleme void vigenere_encrypt(char *text, char *key, char *output) { int i, j = 0, keylen = strlen(key); for (i = 0; text[i] != '\0'; i++) { if (isalpha(text[i])) { int k = toupper(key[j % keylen]) - 'A'; if (isupper(text[i])) output[i] = ((text[i] - 'A' + k) % 26) + 'A'; else output[i] = ((text[i] - 'a' + k) % 26) + 'a'; j++; } else { output[i] = text[i]; } } output[i] = '\0'; }

void vigenere_decrypt(char *text, char *key, char *output) { int i, j = 0, keylen = strlen(key); for (i = 0; text[i] != '\0'; i++) { if (isalpha(text[i])) { int k = toupper(key[j % keylen]) - 'A'; if (isupper(text[i])) output[i] = ((text[i] - 'A' - k + 26) % 26) + 'A'; else output[i] = ((text[i] - 'a' - k + 26) % 26) + 'a'; j++; } else { output[i] = text[i]; } } output[i] = '\0'; }

// XOR Şifreleme void xor_encrypt(char *text, char *output, char key) { int i; for (i = 0; text[i] != '\0'; i++) { output[i] = text[i] ^ key; } output[i] = '\0'; }

void xor_decrypt(char *text, char *output, char key) { xor_encrypt(text, output, key); // XOR tersinir }

// Matris (Transposition) Şifreleme void matrix_encrypt(char *text, char *output, int num_cols) { int len = strlen(text); int num_rows = (len + num_cols - 1) / num_cols; int k = 0; for (int col = 0; col < num_cols; col++) { for (int row = 0; row < num_rows; row++) { int idx = row * num_cols + col; if (idx < len) { output[k++] = text[idx]; } } } output[k] = '\0'; }

void matrix_decrypt(char *text, char *output, int num_cols) { int len = strlen(text); int num_rows = (len + num_cols - 1) / num_cols; int k = 0; for (int row = 0; row < num_rows; row++) { for (int col = 0; col < num_cols; col++) { int idx = col * num_rows + row; if (idx < len) { output[k++] = text[idx]; } } } output[k] = '\0'; }

// Ana Program int main() { char metin[256] = "Yapay Zeka Türkiye"; char anahtar[] = "ANAHTAR"; int shift = 3; char xor_key = 42; int num_cols = 5; char sifreli[256], cozulmus[256];

// Substitution
substitution_encrypt(metin, sifreli);
substitution_decrypt(sifreli, cozulmus);
printf(\"Substitution: %s -> %s\n\", sifreli, cozulmus);

// Caesar
caesar_encrypt(metin, sifreli, shift);
caesar_decrypt(sifreli, cozulmus, shift);
printf(\"Caesar: %s -> %s\n\", sifreli, cozulmus);

// Vigenère
vigenere_encrypt(metin, anahtar, sifreli);
vigenere_decrypt(sifreli, anahtar, cozulmus);
printf(\"Vigenere: %s -> %s\n\", sifreli, cozulmus);

// XOR
xor_encrypt(metin, sifreli, xor_key);
xor_decrypt(sifreli, cozulmus, xor_key);
printf(\"XOR: (gizli karakterler) -> %s\n\", cozulmus);

// Matris
matrix_encrypt(metin, sifreli, num_cols);
matrix_decrypt(sifreli, cozulmus, num_cols);
printf(\"Matris: %s -> %s\n\", sifreli, cozulmus);

return 0;

}