Yerine Koyma Şifrelemesi (Substitution Cipher)

Alfabede bulunan her bir karakterin yerine aynı alfabeden başka karakterin koyularak şifreleme yapılmasına Yerine Koyma Şifrelemesi (Substitution Cipher) denir. Hangi karakterin yerine hangisinin geleceği ile ilgili bir kural yoktur. Rastgele seçilebilir.

Sezar Şifrelemesi (Caesar’s Cipher)

Julius Caesar tarafından sunulmuş ve kullanılmıştır. Alfabedeki her harf belirli bir “k” sayısı kadar ötelenir. Ötelemede kullanılan bu “k” sayısı, şifreleme ve çözmede kullanılan anahtardır.

Yerine Koyma Şifrelemesi (Substitution Cipher) yöntemlerinin en eskilerinden biridir. İlkel bir şifreleme tekniğidir fakat o dönemde bulunması ve kullanılması oldukça zekicedir. Günümüzde pek sık tercih edilmemektedir. Çünkü şifreleme türünün Sezar Şifrelemesi olduğu bilinirse en fazla 25 denemede şifrenin çözülmesi mümkündür.

Sezar Şifrelemesi (Caesar’s Cipher) Algoritması

Algoritması oldukça basittir. Ana mesajda bulunan her bir harf, anahtar sayı kadar ileri götürülerek şifreli mesaj oluşturulur. Şifreli mesajı çözmek için ise her harf anahtar sayısı kadar geriye götürülür.

Anahtarı 3 olan bir metni, şifreleyelim. (Latin alfabesine göre yapalım)

Açık Metin: GOKYUZUAVCISI

Şifreli Metin: JRNBXCXDYFLVL

Sezar Şifrelemesi (Caesar’s Cipher) Java Kodu

import java.util.*;
class CaesarCipher{
    public static void main(String[]args)
    {
        Scanner scan = new Scanner(System.in);
        System.out.print("Enter your PlainText: ");
        String message = scan.next();
        int length = message.length();
        System.out.print("Enter the Key: ");
        int key = scan.nextInt();
        String uppercase = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        String lowercase = "abcdefghijklmnopqrstuvwxyz";
        String special = "!#$%&'()*+,-./:;<=>?@[]^_`{|}~";
        String numbers = "0123456789";
        System.out.print("The encrypted Text is: ");
        for(int i = 0 ;i < length ;i++)
        {
            for(int j = 0; j < 26 ;j++)
            {
                if(j < special.length() && message.charAt(i) == special.charAt(j))
                 {
                     System.out.print(special.charAt(j)); //print special charecters as it
is
                 }
                else if(j < numbers.length() && message.charAt(i) == numbers.charAt(j))
                {
                    System.out.print(numbers.charAt(j)); //print numbers as it is
                }
                else if(message.charAt(i) == lowercase.charAt(j))
                {
                    System.out.print(lowercase.charAt((j + key) % 26));
                }
                else if(message.charAt(i) == uppercase.charAt(j))
                {
                    System.out.print(uppercase.charAt((j + key) % 26));
                }          
            }
        }
        System.out.println();
    }
}

Mono Alfabetik Şifreleme (Monoalphabetic Cipher)

Alfabedeki harfler rastgele permutasyon yapılarak anahtar elde edilir. Örneğin her A yerine Y gibi. Bu şifreleme yöntemi, kullanılan harflerin yerini değiştirir ama harflerin kullanım sıklığını (frekansını) değiştiremez. Dolayısıyla çok kısa sürelerde kırılabilmektedir.

Mono Alfabetik Şifreleme (Monoalphabetic Cipher) Java Kodu

package com.sanfoundry.setandstring;
import java.util.Scanner;
public class MonoalphabeticCipher
{
    public static char p[]  = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
            'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
            'w', 'x', 'y', 'z' };
    public static char ch[] = { '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' };
    public static String doEncryption(String s)
    {
        char c[] = new char[(s.length())];
        for (int i = 0; i < s.length(); i++)
        {
            for (int j = 0; j < 26; j++)
            {
                if (p[j] == s.charAt(i))
                {
                    c[i] = ch[j];
                    break;
                }
            }
        }
        return (new String(c));
    }
    public static String doDecryption(String s)
    {
        char p1[] = new char[(s.length())];
        for (int i = 0; i < s.length(); i++)
        {
            for (int j = 0; j < 26; j++)
            {
                if (ch[j] == s.charAt(i))
                {
                    p1[i] = p[j];
                    break;
                }
            }
        }
        return (new String(p1));
    }
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);
        System.out.println("Enter the message: ");
        String en = doEncryption(sc.next().toLowerCase());
        System.out.println("Encrypted message: " + en);
        System.out.println("Decrypted message: " + doDecryption(en));
        sc.close();
    }
}
Çıktı:
Enter the message:  
Sanfoundry
Encrypted message: LQFYGXFRKN 
Decrypted message: sanfoundry

Doğrusal Şifreleme (Affine Cipher)

Affine Cipher (Doğrusal Şifreleme) yöntemi de bir Yerine Koyma Şifrelemesi (Substitution Cipher) yöntemidir. Hangi karakterin hangisi yerine geleceği bir formüle bağlı olarak gerçekleştirilir.

Amaç, doğrunun denklemi olarak bilinen y=ax+b doğrusal fonksiyonunu şifrelemek için kullanmaktır.

Şifreleme yapılırken a ve b olmak üzere iki tamsayı seçilir. a ve b tamsayıları şifreleme anahtarını oluşturur. Şifrelenecek metnin bütün karakterleri alfabedeki değerine (sırasına) dönüştürülür.

A=0, B=1, C=2, D=3…

Her bir harf yerine şu işlem yapılmaktadır.

 E(x) = (ax+b) mod n

Mod aldığımız n değeri, alfabedeki karakter sayısıdır. Örneğin Türkçe alfabenin karakter uzayı olarak alındığı varsayılırsa, n değeri 29 olacaktır.

A harfini şifrelemek istersek ve a=3 ve b=1 şeçersek,

0.3+1 = 1

Sonuç 1 çıkar ve bu da B harfine denk gelir. A yerine B yazılması ile şifreleme yapılır. Her harf için tek tek yapılmaktadır.

Affine Cipher Python Kodu

def egcd(a, b): 
  x,y, u,v = 0,1, 1,0
  while a != 0: 
    q, r = b//a, b%a 
    m, n = x-u*q, y-v*q 
    b,a, x,y, u,v = a,r, u,v, m,n 
  gcd = b 
  return gcd, x, y 
def modinv(a, m): 
  gcd, x, y = egcd(a, m) 
  if gcd != 1: 
    return None # modular inverse does not exist 
  else: 
    return x % m 
 def encrypt(text, key): 
  #E = (a*x + b) % 26 
  return ''.join([ chr((( key[0]*(ord(t) - ord('A')) + key[1] ) % 26) + ord('A')) for t in text.upper().replace(' ', '') ]) 
def decrypt(cipher, key): 
  #D(E) = (a^-1 * (E - b)) % 26
  return ''.join([ chr((( modinv(key[0], 26)*(ord(c) - ord('A') - key[1])) % 26) +ord('A')) for c in cipher ]) 
# Driver Code to test the above functions 
def main(): 
  text = 'VAMSI KRISHNA'
  key = [7, 20] 
  # calling encryption function 
  enc_text = encrypt(text, key) 
  print('Encrypted Text: {}'.format(enc_text)) 
  # calling decryption function 
  print('Decrypted Text: {}'.format(decrypt(enc_text, key) )) 
if __name__ == '__main__': 
  main() 
Çıktı
Encrypted Text: LUAQYMJYQRHU
Decrypted Text: VAMSIKRISHNA

Şimdiye kadar ki bahsedilen tarihsel süreçteki en temel kripto algoritmaları 9.yy’da Arap bilim adamı Al-Kindi tarafından ortaya konulan Frekans Analizi ile kolaylıkla çözülebilmektedir. Harflerin kullanılma frekansı hesaplanarak şifreli bir metin çözümlenmektedir.

Simetrik ve asimetrik şifreleme algoritmaları yazımı okumak için buraya tıklayabilirsiniz.

Kaynakça: 
Implementation of Affine Cipher in Python
Implement Caesar Cipher in Java
https://www.sanfoundry.com/java-program-implement-monoalphabetic-cypher/
1 yorum
Bir cevap yazın

E-posta hesabınız yayımlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

Bunları da okumak ister misiniz