Python ile Kriptografi - Hızlı Kılavuz

Kriptografi, iki kullanıcı arasında kodlanmış mesajlar aracılığıyla iletişim kurma sanatıdır. Kriptografi bilimi, bir partiden diğerine aktarılan gizli mesajların güvenliğini sağlamanın temel amacı ile ortaya çıktı.

Kriptografi, bilgi güvenliğinde tanındığı şekliyle mahremiyet ve gizlilik sağlamak için mesajı gizleme sanatı ve bilimi olarak tanımlanır.

Kriptografi Terminolojileri

Kriptografide sık kullanılan terimler burada açıklanmıştır -

Düz Metin

Düz metin mesajı, okunabilen ve tüm kullanıcılar tarafından anlaşılabilen metindir. Düz metin, kriptografiden geçen mesajdır.

Şifreleme Metni

Şifreleme metni, düz metin üzerine kriptografi uygulandıktan sonra elde edilen mesajdır.

Şifreleme

Düz metni şifreli metne dönüştürme işlemine şifreleme denir. Kodlama olarak da adlandırılır.

Şifre çözme

Şifreli metni düz metne dönüştürme işlemine şifre çözme denir. Aynı zamanda kod çözme olarak da adlandırılır.

Aşağıda verilen şema, tüm kriptografi sürecinin bir örneğini göstermektedir -

Modern Kriptografinin Özellikleri

Modern kriptografinin temel özellikleri aşağıdaki gibidir -

  • Bit dizileri üzerinde çalışır.

  • Bilginin güvenliğini sağlamak için matematiksel algoritmalar kullanır.

  • Gizliliğe ulaşmak için güvenli iletişim kanalıyla ilgilenen tarafların olmasını gerektirir.

Çoklu şifreleme olarak da adlandırılan çift güçlü şifreleme, önceden şifrelenmiş bir metni aynı veya farklı algoritma / model ile bir veya daha fazla kez şifreleme işlemidir.

Çift güçlü şifrelemenin diğer adları, kademeli şifreleme veya kademeli şifreleme içerir.

Çift Güçlü Şifreleme Düzeyleri

İki kat güçlü şifreleme, burada aşağıda açıklanan çeşitli şifreleme düzeylerini içerir:

İlk şifreleme katmanı

Şifreleme metni, karma algoritmalar ve simetrik anahtarlar kullanılarak orijinal okunabilir mesajdan üretilir. Daha sonra simetrik anahtarlar asimetrik anahtarlar yardımıyla şifrelenir. Bu model için en iyi örnek, şifre metninin karma özetini bir kapsül halinde birleştirmektir. Alıcı, metnin arada oynanmadığını doğrulamak için önce özeti hesaplayacak ve sonra metnin şifresini çözecektir.

İkinci şifreleme katmanı

İkinci şifreleme katmanı, metni aynı veya farklı algoritma ile şifrelemek için bir katman daha ekleme işlemidir. Genellikle bunun için 32 bit karakter uzunluğunda simetrik bir parola kullanılır.

Üçüncü şifreleme katmanı

Bu süreçte şifrelenmiş kapsül, SSL / TLS bağlantısı aracılığıyla iletişim ortağına iletilir.

Aşağıdaki şema, resimsel olarak çift şifreleme işlemini göstermektedir -

Hibrit Kriptografi

Hibrit kriptografi, her bir şifrenin faydalarını dahil ederek farklı türlerde birden çok şifrenin birlikte kullanılması işlemidir. Simetrik bir şifre için rastgele bir gizli anahtar oluşturmak ve daha sonra bu anahtarı asimetrik anahtar kriptografisi yoluyla şifrelemek için genellikle izlenen yaygın bir yaklaşım vardır.

Bu model nedeniyle, orijinal mesajın kendisi simetrik şifre ve ardından gizli anahtar kullanılarak şifrelenir. Alıcı, mesajı aldıktan sonra, kendi özel anahtarını kullanarak önce gizli anahtarı kullanarak mesajın şifresini çözer ve ardından mesajın şifresini çözmek için belirtilen anahtarı kullanır.

Python, yüksek seviyeli, yorumlanmış, etkileşimli ve nesne yönelimli açık kaynaklı bir betik dilidir. Oldukça okunabilir olacak şekilde tasarlanmıştır. Python dilinin sözdiziminin anlaşılması kolaydır ve sık sık İngilizce anahtar sözcükler kullanır.

Python Dilinin Özellikleri

Python aşağıdaki ana özellikleri sağlar -

Yorumlandı

Python, yorumlayıcı kullanılarak çalışma zamanında işlenir. Yürütülmeden önce bir programı derlemeye gerek yoktur. PERL ve PHP'ye benzer.

Nesne odaklı

Python, nesneye yönelik stili ve tasarım modellerini takip eder. Kapsülleme ve çok biçimlilik gibi çeşitli özelliklerle sınıf tanımını içerir.

Python Dilinin Temel Noktaları

Python programlama dilinin temel noktaları aşağıdaki gibidir -

  • İşlevsel ve yapılandırılmış programlama ve yöntemlerin yanı sıra nesne yönelimli programlama yöntemlerini içerir.

  • Komut dosyası dili veya programlama dili olarak kullanılabilir.

  • Otomatik çöp toplamayı içerir.

  • Üst düzey dinamik veri türlerini içerir ve çeşitli dinamik tür denetimini destekler.

  • Python, C, C ++ ve Java gibi dillerle entegrasyon özelliği içerir.

Python dili için indirme bağlantısı aşağıdaki gibidir - www.python.org/downloads Windows, MacOS ve Linux dağıtımları gibi çeşitli işletim sistemleri için paketler içerir.

Python Dizeleri

Dizelerin temel beyanı aşağıda gösterilmiştir -

str = 'Hello World!'

Python Listeleri

Python listeleri, virgülle ayrılmış ve köşeli parantez ([]) içine alınmış bileşik veri türleri olarak tanımlanabilir.

list = [ 'abcd', 786 , 2.23, 'john', 70.2 ]
tinylist = [123, 'john']

Python Tuples

Bir demet, virgülle ayrılmış değerlerin sayısından oluşan dinamik Python veri türüdür. Tuple'lar parantez içine alınır.

tinytuple = (123, 'john')

Python Sözlüğü

Python sözlüğü bir tür karma tablodur. Bir sözlük anahtarı, genellikle sayılar veya dizeler olan hemen hemen her veri türü Python olabilir.

tinydict = {'name': 'omkar','code':6734, 'dept': 'sales'}

Kriptografi Paketleri

Python, kriptografik tarifler ve ilkeller sağlayan kriptografi adlı bir paket içerir. Python 2.7, Python 3.4+ ve PyPy 5.3+ 'yi destekler. Şifreleme paketinin temel kurulumu aşağıdaki komutla gerçekleştirilir -

pip install cryptography

Hem yüksek seviyeli tariflere hem de düşük seviyeli arayüzlere sahip çeşitli paketler vardır. symmetric ciphers, message digests ve key derivation functions.

Bu eğitim boyunca, kriptografik algoritmaların uygulanması için çeşitli Python paketlerini kullanacağız.

Önceki bölüm, yerel bilgisayarınıza Python kurulumuna genel bir bakış sunmuştu. Bu bölümde ters şifreleme ve kodlaması hakkında detaylı bilgi edineceksiniz.

Ters Şifreleme Algoritması

Ters şifreleme algoritması aşağıdaki özellikleri barındırır -

  • Ters Şifreleme, şifreli metin olarak dönüştürmek için düz metin dizesini tersine çeviren bir model kullanır.

  • Şifreleme ve şifre çözme süreci aynıdır.

  • Şifreleme metninin şifresini çözmek için, kullanıcının düz metni elde etmek için şifre metnini tersine çevirmesi yeterlidir.

Dezavantaj

Ters şifrelemenin en büyük dezavantajı, çok zayıf olmasıdır. Bir bilgisayar korsanı, orijinal mesajı almak için şifre metnini kolayca kırabilir. Bu nedenle, güvenli iletişim kanalını sürdürmek için ters şifreleme iyi bir seçenek olarak görülmez.

Misal

İfadenin bulunduğu bir örnek düşünün This is program to explain reverse cipherters şifreleme algoritması ile uygulanacaktır. Aşağıdaki python kodu, çıktıyı elde etmek için algoritmayı kullanır.

message = 'This is program to explain reverse cipher.'
translated = '' #cipher text is stored in this variable
i = len(message) - 1

while i >= 0:
   translated = translated + message[i]
   i = i - 1
print(“The cipher text is : “, translated)

Çıktı

Aşağıdaki resimde gösterildiği gibi çıktı olan tersine çevrilmiş metni görebilirsiniz -

Açıklama

  • Düz metin, değişken mesajda saklanır ve çevrilen değişken, oluşturulan şifre metnini saklamak için kullanılır.

  • Düz metnin uzunluğu kullanılarak hesaplanır for döngü ve yardımıyla index number. Karakterler şifreli metin değişkeninde saklanırtranslated son satırda yazdırılan.

Son bölümde, ters şifreleme konusunu ele aldık. Bu bölüm Sezar şifresinden ayrıntılı olarak bahsediyor.

Sezar Şifreleme Algoritması

Sezar şifresinin algoritması aşağıdaki özelliklere sahiptir -

  • Sezar Şifreleme Tekniği, şifreleme tekniğinin basit ve kolay yöntemidir.

  • Basit bir ikame şifresi türüdür.

  • Her düz metindeki harf, alfabenin bulunduğu sabit sayıda konumu olan bir harfle değiştirilir.

Aşağıdaki diyagram, Sezar şifreleme algoritması uygulamasının çalışmasını göstermektedir -

Sezar şifreleme algoritmasının program uygulaması aşağıdaki gibidir -

def encrypt(text,s):
result = ""
   # transverse the plain text
   for i in range(len(text)):
      char = text[i]
      # Encrypt uppercase characters in plain text
      
      if (char.isupper()):
         result += chr((ord(char) + s-65) % 26 + 65)
      # Encrypt lowercase characters in plain text
      else:
         result += chr((ord(char) + s - 97) % 26 + 97)
      return result
#check the above function
text = "CEASER CIPHER DEMO"
s = 4

print "Plain Text : " + text
print "Shift pattern : " + str(s)
print "Cipher: " + encrypt(text,s)

Çıktı

Sezar şifresini görebilirsiniz, bu çıktı aşağıdaki resimde gösterildiği gibi -

Açıklama

Düz metin karakteri teker teker taranır.

  • Verilen düz metindeki her karakter için, metnin şifreleme ve şifre çözme prosedürüne bağlı olarak verilen karakteri kurala göre dönüştürün.

  • Adımlar izlendikten sonra, şifre metni olarak adlandırılan yeni bir dize oluşturulur.

Sezar Şifreleme Algoritmasının Hacklenmesi

Şifreleme metni çeşitli olasılıklarla hacklenebilir. Böyle olasılıklardan biriBrute Force Technique,bu, olası her şifre çözme anahtarını denemeyi içerir. Bu teknik fazla çaba gerektirmez ve bir bilgisayar korsanı için nispeten basittir.

Sezar şifreleme algoritmasını hacklemek için program uygulaması aşağıdaki gibidir -

message = 'GIEWIVrGMTLIVrHIQS' #encrypted message
LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

for key in range(len(LETTERS)):
   translated = ''
   for symbol in message:
      if symbol in LETTERS:
         num = LETTERS.find(symbol)
         num = num - key
         if num < 0:
            num = num + len(LETTERS)
         translated = translated + LETTERS[num]
      else:
         translated = translated + symbol
print('Hacking key #%s: %s' % (key, translated))

Önceki örnekte şifrelenmiş şifre metnini düşünün. Ardından, anahtarla olası hackleme yöntemleri ve kaba kuvvet saldırısı tekniğinin kullanıldığı çıktı aşağıdaki gibidir -

Şimdiye kadar, ters şifreleme ve Sezar şifreleme algoritmalarını öğrendiniz. Şimdi, ROT13 algoritmasını ve uygulanmasını tartışalım.

ROT13 Algoritmasının Açıklaması

ROT13 şifresi, kısaltılmış formu ifade eder Rotate by 13 places. Bu, geçişin her zaman 13 olduğu Sezar Cipher'in özel bir durumudur. Mesajı şifrelemek veya şifresini çözmek için her harf 13 sıra kaydırılır.

Misal

Aşağıdaki şema ROT13 algoritma sürecini resimli olarak açıklamaktadır -

Program kodu

ROT13 algoritmasının program uygulaması aşağıdaki gibidir -

from string import maketrans

rot13trans = maketrans('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz', 
   'NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm')

# Function to translate plain text
def rot13(text):
   return text.translate(rot13trans)
def main():
   txt = "ROT13 Algorithm"
   print rot13(txt)
	
if __name__ == "__main__":
   main()

ROT13 çıktısını aşağıdaki resimde gösterildiği gibi görebilirsiniz -

Dezavantaj

ROT13 algoritması 13 vardiya kullanır. Bu nedenle, şifre metninin şifresini çözmek için karakterleri tersine kaydırmak çok kolaydır.

ROT13 Algoritmasının Analizi

ROT13 şifreleme algoritması, Sezar Şifreleme'nin özel bir durumu olarak kabul edilir. Çok güvenli bir algoritma değildir ve frekans analizi ile veya sadece olası 25 anahtar denenerek kolayca kırılabilirken, ROT13 13 basamak kaydırılarak kırılabilir. Bu nedenle pratik kullanım içermez.

Transposition Cipher, düz metindeki alfabe sırasının bir şifre metni oluşturmak için yeniden düzenlendiği bir kriptografik algoritmadır. Bu süreçte, gerçek düz metin alfabeleri dahil edilmemiştir.

Misal

Transpozisyon şifresi için basit bir örnek: columnar transposition cipherdüz metindeki her karakter, belirtilen alfabe genişliğinde yatay olarak yazılır. Şifre dikey olarak yazılır ve bu tamamen farklı bir şifre metni oluşturur.

Düz metni düşünün hello worldve aşağıda gösterildiği gibi basit sütunlu transpozisyon tekniğini uygulayalım

Düz metin karakterleri yatay olarak yerleştirilir ve şifreli metin dikey formatta oluşturulur. : holewdlo lr. Şimdi, alıcının şifreli metnin şifresini düz metin olarak çözmek için aynı tabloyu kullanması gerekir.

Kod

Aşağıdaki program kodu, sütunlu aktarım tekniğinin temel uygulamasını göstermektedir -

def split_len(seq, length):
   return [seq[i:i + length] for i in range(0, len(seq), length)]
def encode(key, plaintext):
   order = {
      int(val): num for num, val in enumerate(key)
   }
ciphertext = ''

for index in sorted(order.keys()):
   for part in split_len(plaintext, len(key)):
      try:ciphertext += part[order[index]]
         except IndexError:
            continue
   return ciphertext
print(encode('3214', 'HELLO'))

Açıklama

  • İşlevi kullanma split_len(), Sütunlu veya satır biçiminde yerleştirilebilen düz metin karakterlerini bölebiliriz.

  • encode yöntemi, sütun sayısını belirten anahtarla şifreli metin oluşturmaya yardımcı olur ve her sütundan karakterleri okuyarak şifre metnini yazdırır.

Çıktı

Sütunlu aktarım tekniğinin temel uygulaması için program kodu aşağıdaki çıktıyı verir:

Note- Kriptanalistler, aktarım tekniği uygulandığında kripto güvenliğinde önemli bir gelişme gözlemledi. Ayrıca, aynı transpozisyon şifresini kullanarak şifre metnini yeniden şifrelemenin daha iyi güvenlik yarattığını da belirttiler.

Önceki bölümde, Transpozisyon Şifresi hakkında bilgi sahibi olduk. Bu bölümde şifrelemesini tartışalım.

Pyperclip

Ana kullanımı pyperclipPython programlama dilinde eklenti, metni panoya kopyalamak ve yapıştırmak için çapraz platform modülü gerçekleştirmektir. Python kurabilirsinizpyperclip modülü gösterildiği gibi komutu kullanarak

pip install pyperclip

Gereksinim sistemde zaten mevcutsa, aşağıdaki çıktıyı görebilirsiniz -

Kod

Pyperclip'in ana modül olduğu aktarım şifresini şifrelemek için python kodu aşağıda gösterildiği gibidir -

import pyperclip
def main():
   myMessage = 'Transposition Cipher'
   myKey = 10
   ciphertext = encryptMessage(myKey, myMessage)
   
   print("Cipher Text is")
   print(ciphertext + '|')
   pyperclip.copy(ciphertext)

def encryptMessage(key, message):
   ciphertext = [''] * key
   
   for col in range(key):
      position = col
      while position < len(message):
         ciphertext[col] += message[position]
			position += key
      return ''.join(ciphertext) #Cipher text
if __name__ == '__main__':
   main()

Çıktı

Aktarım şifresini şifrelemek için program kodu pyperclip ana modül aşağıdaki çıktıyı verir -

Açıklama

  • İşlev main() arar encryptMessage() karakterleri kullanarak bölme prosedürünü içeren len işlevi ve bunları sütun biçiminde yinelemek.

  • Uygun çıktıyı elde etmek için en sonunda ana işlev başlatılır.

Bu bölümde, transpozisyon şifresinin şifresini çözme prosedürünü öğreneceksiniz.

Kod

Bir aktarım şifresinin şifresini çözmenin daha iyi anlaşılması için aşağıdaki kodu inceleyin. Mesaj için şifre metniTransposition Cipher anahtar ile 6 olarak getirildi Toners raiCntisippoh.

import math, pyperclip
def main():
   myMessage= 'Toners raiCntisippoh'
   myKey = 6
   plaintext = decryptMessage(myKey, myMessage)
   
   print("The plain text is")
   print('Transposition Cipher')

def decryptMessage(key, message):
   numOfColumns = math.ceil(len(message) / key)
   numOfRows = key
   numOfShadedBoxes = (numOfColumns * numOfRows) - len(message)
   plaintext = float('') * numOfColumns
   col = 0
   row = 0
   
   for symbol in message:
      plaintext[col] += symbol
      col += 1
      if (col == numOfColumns) or (col == numOfColumns - 1 and row >= numOfRows - numOfShadedBoxes):
         col = 0 row += 1 return ''.join(plaintext)
if __name__ == '__main__':
   main()

Açıklama

Şifreleme metni ve bahsedilen anahtar, karakterleri sütun formatında yerleştirerek ve yatay bir şekilde okuyarak şifreleme metnini ters teknikte deşifre etmek veya deşifre etmek için girdi parametreleri olarak alınan iki değerdir.

Harfleri bir sütun biçiminde yerleştirebilir ve daha sonra aşağıdaki kod parçasını kullanarak bunları birleştirebilir veya birleştirebilirsiniz:

for symbol in message:
   plaintext[col] += symbol
   col += 1
   
   if (col == numOfColumns) or (col == numOfColumns - 1 and row >= numOfRows - numOfShadedBoxes):
   col = 0
   row += 1
return ''.join(plaintext)

Çıktı

Transpozisyon şifresinin şifresini çözmek için program kodu aşağıdaki çıktıyı verir -

Python'da, dosyaları bir iletişim kanalına iletmeden önce şifrelemek ve şifresini çözmek mümkündür. Bunun için eklentiyi kullanmanız gerekecekPyCrypto. Bu eklentiyi aşağıda verilen komutu kullanarak kurabilirsiniz.

pip install pycrypto

Kod

Dosyayı şifre koruyucuyla şifrelemek için program kodu aşağıda belirtilmiştir -

# =================Other Configuration================
# Usages :
usage = "usage: %prog [options] "
# Version
Version="%prog 0.0.1"
# ====================================================
# Import Modules
import optparse, sys,os
from toolkit import processor as ps
def main():
   parser = optparse.OptionParser(usage = usage,version = Version)
   parser.add_option(
      '-i','--input',type = 'string',dest = 'inputfile',
      help = "File Input Path For Encryption", default = None)
   
   parser.add_option(
      '-o','--output',type = "string",dest = 'outputfile',
      help = "File Output Path For Saving Encrypter Cipher",default = ".")
	
   parser.add_option(
      '-p','--password',type = "string",dest = 'password',
      help = "Provide Password For Encrypting File",default = None)
	
   parser.add_option(
      '-p','--password',type = "string",dest = 'password',
      help = "Provide Password For Encrypting File",default = None)
	
   (options, args)= parser.parse_args()
	
   # Input Conditions Checkings
   if not options.inputfile or not os.path.isfile(options.inputfile):
      print " [Error] Please Specify Input File Path"
      exit(0)
   if not options.outputfile or not os.path.isdir(options.outputfile):
      print " [Error] Please Specify Output Path"
      exit(0)
   if not options.password:
      print " [Error] No Password Input"
      exit(0)
   inputfile = options.inputfile

   outputfile = os.path.join(
      options.outputfile,os.path.basename(options.inputfile).split('.')[0]+'.ssb')
   password = options.password
   base = os.path.basename(inputfile).split('.')[1]
   work = "E"

   ps.FileCipher(inputfile,outputfile,password,work)
   return

   if __name__ == '__main__':
   main()

Şifreleme işlemini parola ile birlikte yürütmek için aşağıdaki komutu kullanabilirsiniz -

python pyfilecipher-encrypt.py -i file_path_for_encryption -o output_path -p password

Çıktı

Yukarıda verilen kodu çalıştırdığınızda aşağıdaki çıktıyı gözlemleyebilirsiniz -

Açıklama

Şifreler, MD5 karma algoritması kullanılarak oluşturulur ve değerler, aşağıda gösterilen değerleri içeren Windows sistemindeki basitçe güvenli yedekleme dosyalarında saklanır -

Bu bölümde, Python kullanarak kriptografide dosyaların şifresinin çözülmesini tartışalım. Şifre çözme işlemi için aynı prosedürü izleyeceğimizi, ancak çıkış yolunu belirtmek yerine, giriş yoluna veya şifrelenmiş gerekli dosyaya odaklanacağımızı unutmayın.

Kod

Aşağıda, Python kullanarak kriptografide dosyaların şifresini çözmek için örnek bir kod verilmiştir -

#!/usr/bin/python
# ---------------- READ ME ---------------------------------------------
# This Script is Created Only For Practise And Educational Purpose Only
# This Script Is Created For http://bitforestinfo.blogspot.in
# This Script is Written By
#
#
##################################################
######## Please Don't Remove Author Name #########
############### Thanks ###########################
##################################################
#
#
# =================Other Configuration================
# Usages :
usage = "usage: %prog [options] "
# Version
Version="%prog 0.0.1"
# ====================================================
# Import Modules
import optparse, sys,os
from toolkit import processor as ps
def main():
   parser = optparse.OptionParser(usage = usage,version = Version)
   parser.add_option(
      '-i','--input',type = 'string',dest = 'inputfile',
      help = "File Input Path For Encryption", default = None)
   
   parser.add_option(
      '-o','--output',type = "string",dest = 'outputfile',
      help = "File Output Path For Saving Encrypter Cipher",default = ".")
   
   parser.add_option(
      '-p','--password',type = "string",dest = 'password',
      help = "Provide Password For Encrypting File",default = None)
      (options, args) =  parser.parse_args()
      # Input Conditions Checkings
      if not options.inputfile or not os.path.isfile(options.inputfile):
         print " [Error] Please Specify Input File Path"
         exit(0)
      if not options.outputfile or not os.path.isdir(options.outputfile):
         print " [Error] Please Specify Output Path"
         exit(0)
      if not options.password:
         print " [Error] No
         exit(0)
      inputfile = options.inputfile
      outputfile = options.outputfile
      password = options.password
      work = "D"
      ps.FileCipher(inputfile,outputfile,password,work)
      return
if __name__ == '__main__':
   main()

Yukarıdaki kodu çalıştırmak için aşağıdaki komutu kullanabilirsiniz -

python pyfilecipher-decrypt.py -i encrypted_file_path -p password

Çıktı

Yukarıda gösterilen komutu çalıştırdığınızda aşağıdaki kodu gözlemleyebilirsiniz -

Note - Çıktı, şifrelemeden önce ve şifre çözmeden sonra karma değerlerini belirtir; bu, aynı dosyanın şifrelendiğini ve işlemin başarılı olduğunu not eder.

Base64 kodlaması, ikili verileri, kullanıcının metni güvenli bir şekilde işleyebileceği iletişim kanalından geçen metin biçimine dönüştürür. Base64 olarak da adlandırılırPrivacy enhanced Electronic mail (PEM) ve öncelikle e-posta şifreleme işleminde kullanılır.

Python adında bir modül içerir BASE64 aşağıda verildiği gibi iki temel işlevi içeren -

  • base64.decode(input, output) - Belirtilen giriş değeri parametresinin kodunu çözer ve kodu çözülen çıktıyı bir nesne olarak saklar.

  • Base64.encode(input, output) - Belirtilen giriş değeri parametresini kodlar ve kodu çözülen çıktıyı bir nesne olarak saklar.

Kodlama Programı

Base64 kodlamasını gerçekleştirmek için aşağıdaki kod parçasını kullanabilirsiniz -

import base64
encoded_data = base64.b64encode("Encode this text")

print("Encoded text with base 64 is")
print(encoded_data)

Çıktı

Base64 kodlama kodu size şu çıktıyı verir:

Kod Çözme Programı

Base64 kod çözme gerçekleştirmek için aşağıdaki kod parçasını kullanabilirsiniz -

import base64
decoded_data = base64.b64decode("RW5jb2RlIHRoaXMgdGV4dA==")

print("decoded text is ")
print(decoded_data)

Çıktı

Base64 kod çözme kodu size aşağıdaki çıktıyı verir -

ASCII ve base64 arasındaki fark

Veri kodlamak için ASCII ve base64 üzerinde çalışırken aşağıdaki farklılıkları gözlemleyebilirsiniz:

  • ASCII'de metni kodladığınızda, bir metin dizesiyle başlar ve onu bir bayt dizisine dönüştürürsünüz.

  • Base64'te verileri kodladığınızda, bir bayt dizisi ile başlar ve onu bir metin dizesine dönüştürürsünüz.

Dezavantaj

Base64 algoritması genellikle şifreleri veritabanında saklamak için kullanılır. En büyük dezavantajı, kodu çözülen her kelimenin herhangi bir çevrimiçi araçla kolayca kodlanabilmesi ve davetsiz misafirlerin bilgileri kolayca alabilmesidir.

Bu bölümde, XOR sürecini Python'daki kodlamasıyla birlikte anlayalım.

Algoritma

XOR şifreleme ve şifre çözme algoritması, düz metni ASCII bayt biçiminde dönüştürür ve onu belirli bir bayta dönüştürmek için XOR prosedürünü kullanır. Kullanıcılarına aşağıdaki avantajları sunar -

  • Hızlı hesaplama
  • Sol ve sağ tarafta fark yok
  • Anlaması ve analiz etmesi kolay

Kod

XOR işlemini gerçekleştirmek için aşağıdaki kod parçasını kullanabilirsiniz -

def xor_crypt_string(data, key = 'awesomepassword', encode = False, decode = False):
   from itertools import izip, cycle
   import base64
   
   if decode:
      data = base64.decodestring(data)
   xored = ''.join(chr(ord(x) ^ ord(y)) for (x,y) in izip(data, cycle(key)))
   
   if encode:
      return base64.encodestring(xored).strip()
   return xored
secret_data = "XOR procedure"

print("The cipher text is")
print xor_crypt_string(secret_data, encode = True)
print("The plain text fetched")
print xor_crypt_string(xor_crypt_string(secret_data, encode = True), decode = True)

Çıktı

XOR işleminin kodu size şu çıktıyı verir -

Açıklama

  • İşlev xor_crypt_string() kodlama ve kod çözme modunu ve ayrıca dize değerini belirtmek için bir parametre içerir.

  • Temel işlevler, düz metni / şifreleme metnini şifrelemek veya deşifre etmek için XOR prosedürünü / işlemini izleyen base64 modülleri ile alınır.

Note - XOR şifreleme, verileri şifrelemek için kullanılır ve kaba kuvvet yöntemiyle kırılması zordur, yani doğru şifre metniyle eşleşecek rastgele şifreleme anahtarları oluşturarak.

Sezar şifreleme tekniğini kullanırken, sembolleri şifreleme ve deşifre etme, basit bir temel toplama veya çıkarma prosedürü ile değerleri sayılara dönüştürmeyi içerir.

Çarpma metnini şifrelemeye dönüştürmek için kullanılıyorsa, buna wrap-arounddurum. Aşağıda gösterildiği gibi kullanılacak harfleri ve ilgili sayıları düşünün -

Sayılar çarpma prosedürü için kullanılacak ve ilgili anahtar 7'dir. Böyle bir senaryoda çarpımsal bir şifre oluşturmak için kullanılacak temel formül aşağıdaki gibidir -

(Alphabet Number * key)mod(total number of alphabets)

Çıktı üzerinden alınan sayı yukarıda belirtilen tabloda eşleştirilir ve karşılık gelen harf şifreli harf olarak alınır.

Python'da çarpımsal bir şifrenin temel modülasyon işlevi aşağıdaki gibidir -

def unshift(key, ch):
   offset = ord(ch) - ASC_A
   return chr(((key[0] * (offset + key[1])) % WIDTH) + ASC_A)

Note- Çarpımsal şifrelemenin avantajı, 8,953,851 gibi çok büyük anahtarlarla çalışabilmesidir. Bir bilgisayarın dokuz milyon anahtarın çoğunluğunu kullanarak kaba kuvvet uygulaması oldukça uzun zaman alırdı.

Affine Cipher, Multiplicative Cipher ve Caesar Cipher algoritmasının birleşimidir. Afin şifresinin temel uygulaması aşağıdaki resimde gösterildiği gibidir -

Bu bölümde, şifreleme ve şifre çözme için iki temel işlevi içeren ilgili sınıfını oluşturarak afin şifreleme uygulayacağız.

Kod

Afin bir şifre uygulamak için aşağıdaki kodu kullanabilirsiniz -

class Affine(object):
   DIE = 128
   KEY = (7, 3, 55)
   def __init__(self):
      pass
   def encryptChar(self, char):
      K1, K2, kI = self.KEY
      return chr((K1 * ord(char) + K2) % self.DIE)
		
   def encrypt(self, string):
      return "".join(map(self.encryptChar, string))
   
   def decryptChar(self, char):
      K1, K2, KI = self.KEY
      return chr(KI * (ord(char) - K2) % self.DIE)
   
   def decrypt(self, string):
      return "".join(map(self.decryptChar, string))
		affine = Affine()
print affine.encrypt('Affine Cipher')
print affine.decrypt('*18?FMT')

Çıktı

Afin bir şifre uyguladığınızda aşağıdaki çıktıyı gözlemleyebilirsiniz -

Çıktı, düz metin mesajı için şifrelenmiş mesajı görüntüler Affine Cipher ve giriş olarak gönderilen mesaj için şifresi çözülmüş mesaj abcdefg.

Bu bölümde, monoalphabetic şifreleme ve Python kullanarak hacklenmesi hakkında bilgi edineceksiniz.

Monoalphabetic Şifreleme

Bir Monoalphabetic şifre, tüm mesajı şifrelemek için sabit bir ikame kullanır. JSON nesnelerine sahip bir Python sözlüğü kullanan monoalphabetic bir şifre burada gösterilmektedir -

monoalpha_cipher = {
   'a': 'm',
   'b': 'n',
   'c': 'b',
   'd': 'v',
   'e': 'c',
   'f': 'x',
   'g': 'z',
   'h': 'a',
   'i': 's',
   'j': 'd',
   'k': 'f',
   'l': 'g',
   'm': 'h',
   'n': 'j',
   'o': 'k',
   'p': 'l',
   'q': 'p',
   'r': 'o',
   's': 'i',
   't': 'u',
   'u': 'y',
   'v': 't',
   'w': 'r',
   'x': 'e',
   'y': 'w',
   'z': 'q',
	' ': ' ',
}

Bu sözlük yardımı ile JSON nesnesinde değer olarak ilişkili harfleri içeren harfleri şifreleyebiliriz. Aşağıdaki program, şifreleme ve şifre çözmenin tüm işlevlerini içeren bir sınıf temsili olarak bir monoalphabetic programı oluşturur.

from string import letters, digits
from random import shuffle

def random_monoalpha_cipher(pool = None):
   if pool is None:
      pool = letters + digits
   original_pool = list(pool)
   shuffled_pool = list(pool)
   shuffle(shuffled_pool)
   return dict(zip(original_pool, shuffled_pool))

def inverse_monoalpha_cipher(monoalpha_cipher):
   inverse_monoalpha = {}
   for key, value in monoalpha_cipher.iteritems():
      inverse_monoalpha[value] = key
   return inverse_monoalpha

def encrypt_with_monoalpha(message, monoalpha_cipher):
   encrypted_message = []
   for letter in message:
      encrypted_message.append(monoalpha_cipher.get(letter, letter))
   return ''.join(encrypted_message)

def decrypt_with_monoalpha(encrypted_message, monoalpha_cipher):
   return encrypt_with_monoalpha(
      encrypted_message,
      inverse_monoalpha_cipher(monoalpha_cipher)
   )

Bu dosya daha sonra aşağıda belirtilen Monoalphabetic şifrelemenin şifreleme ve şifre çözme sürecini uygulamak için çağrılır -

import monoalphabeticCipher as mc

cipher = mc.random_monoalpha_cipher()
print(cipher)
encrypted = mc.encrypt_with_monoalpha('Hello all you hackers out there!', cipher)
decrypted = mc.decrypt_with_monoalpha('sXGGt SGG Nt0 HSrLXFC t0U UHXFX!', cipher)

print(encrypted)
print(decrypted)

Çıktı

Yukarıda verilen kodu uyguladığınızda aşağıdaki çıktıyı gözlemleyebilirsiniz -

Böylece, şifreleme metnini gerçek düz metne ayıran, belirtilen anahtar değer çiftine sahip bir monoalphabetic şifreyi kırabilirsiniz.

Basit ikame şifresi, en yaygın kullanılan şifredir ve her şifreli metin karakteri için her düz metin karakterinin yerini alan bir algoritma içerir. Bu süreçte, alfabeler Sezar şifreleme algoritmasına göre karıştırılır.

Misal

Basit bir ikame şifresi için anahtarlar genellikle 26 harften oluşur. Örnek bir anahtar -

plain alphabet : abcdefghijklmnopqrstuvwxyz
cipher alphabet: phqgiumeaylnofdxjkrcvstzwb

Yukarıdaki anahtarı kullanan bir şifreleme örneği:

plaintext : defend the east wall of the castle
ciphertext: giuifg cei iprc tpnn du cei qprcni

Aşağıdaki kod, basit ikame şifresini uygulamak için bir programı gösterir -

import random, sys

LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def main():
   message = ''
   if len(sys.argv) > 1:
      with open(sys.argv[1], 'r') as f:
         message = f.read()
   else:
      message = raw_input("Enter your message: ")
   mode = raw_input("E for Encrypt, D for Decrypt: ")
   key = ''
   
   while checkKey(key) is False:
      key = raw_input("Enter 26 ALPHA key (leave blank for random key): ")
      if key == '':
         key = getRandomKey()
      if checkKey(key) is False:
		print('There is an error in the key or symbol set.')
   translated = translateMessage(message, key, mode)
   print('Using key: %s' % (key))
   
   if len(sys.argv) > 1:
      fileOut = 'enc.' + sys.argv[1]
      with open(fileOut, 'w') as f:
         f.write(translated)
      print('Success! File written to: %s' % (fileOut))
   else: print('Result: ' + translated)

# Store the key into list, sort it, convert back, compare to alphabet.
def checkKey(key):
   keyString = ''.join(sorted(list(key)))
   return keyString == LETTERS
def translateMessage(message, key, mode):
   translated = ''
   charsA = LETTERS
   charsB = key
   
   # If decrypt mode is detected, swap A and B
   if mode == 'D':
      charsA, charsB = charsB, charsA
   for symbol in message:
      if symbol.upper() in charsA:
         symIndex = charsA.find(symbol.upper())
         if symbol.isupper():
            translated += charsB[symIndex].upper()
         else:
            translated += charsB[symIndex].lower()
				else:
               translated += symbol
         return translated
def getRandomKey():
   randomList = list(LETTERS)
   random.shuffle(randomList)
   return ''.join(randomList)
if __name__ == '__main__':
   main()

Çıktı

Yukarıda verilen kodu uyguladığınızda aşağıdaki çıktıyı gözlemleyebilirsiniz -

Bu bölümde, aşağıda verildiği gibi rastgele dizeler oluşturmaya yardımcı olan çeşitli yöntemler kullanarak ikame şifresini test etmeye odaklanacağız -

import random, string, substitution
def main():
   for i in range(1000):
      key = substitution.getRandomKey()
      message = random_string()
      print('Test %s: String: "%s.."' % (i + 1, message[:50]))
      print("Key: " + key)
      encrypted = substitution.translateMessage(message, key, 'E')
      decrypted = substitution.translateMessage(encrypted, key, 'D')
      
      if decrypted != message:
         print('ERROR: Decrypted: "%s" Key: %s' % (decrypted, key))
         sys.exit()
      print('Substutition test passed!')

def random_string(size = 5000, chars = string.ascii_letters + string.digits):
   return ''.join(random.choice(chars) for _ in range(size))
if __name__ == '__main__':
   main()

Çıktı

Çıktıyı, aşağıda gösterildiği gibi, rastgele düz metin mesajları oluşturmaya yardımcı olan rastgele oluşturulmuş dizeler olarak gözlemleyebilirsiniz -

Test başarıyla tamamlandıktan sonra çıkış mesajını gözlemleyebiliriz Substitution test passed!.

Böylece, sistematik bir şekilde bir ikame şifresini kırabilirsiniz.

Bu bölümde, basit ikame şifreleme tekniğinde kullanılan mantığa göre şifrelenmiş ve şifresi çözülmüş mesajı görüntüleyen ikame şifresinin basit uygulamasını öğrenebilirsiniz. Bu, alternatif bir kodlama yaklaşımı olarak düşünülebilir.

Kod

Basit değiştirme şifresini kullanarak şifre çözme yapmak için aşağıdaki kodu kullanabilirsiniz -

import random
chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + \
   'abcdefghijklmnopqrstuvwxyz' + \
   '0123456789' + \
   ':.;,?!@#$%&()+=-*/_<> []{}`~^"\'\\'

def generate_key():
   """Generate an key for our cipher"""
   shuffled = sorted(chars, key=lambda k: random.random())
   return dict(zip(chars, shuffled))

def encrypt(key, plaintext):
   """Encrypt the string and return the ciphertext"""
   return ''.join(key[l] for l in plaintext)

def decrypt(key, ciphertext):
   """Decrypt the string and return the plaintext"""
   flipped = {v: k for k, v in key.items()}
   return ''.join(flipped[l] for l in ciphertext)

def show_result(plaintext):
   """Generate a resulting cipher with elements shown"""
   key = generate_key()
   encrypted = encrypt(key, plaintext)
   decrypted = decrypt(key, encrypted)
   
   print 'Key: %s' % key
	print 'Plaintext: %s' % plaintext
   print 'Encrypted: %s' % encrypted
   print 'Decrypted: %s' % decrypted
show_result('Hello World. This is demo of substitution cipher')

Çıktı

Yukarıdaki kod size burada gösterilen çıktıyı verir -

Bu bölümde, Python'daki çeşitli kriptografi modülleri hakkında ayrıntılı bilgi edineceksiniz.

Kriptografi Modülü

Tüm tarifleri ve ilkelleri içerir ve Python'da üst düzey bir kodlama arayüzü sağlar. Aşağıdaki komutu kullanarak kriptografi modülünü kurabilirsiniz -

pip install cryptography

Kod

Şifreleme modülünü uygulamak için aşağıdaki kodu kullanabilirsiniz -

from cryptography.fernet import Fernet
key = Fernet.generate_key()
cipher_suite = Fernet(key)
cipher_text = cipher_suite.encrypt("This example is used to demonstrate cryptography module")
plain_text = cipher_suite.decrypt(cipher_text)

Çıktı

Yukarıda verilen kod aşağıdaki çıktıyı üretir -

Burada verilen kod, parolayı doğrulamak ve karmasını oluşturmak için kullanılır. Ayrıca, kimlik doğrulama amacıyla parolayı doğrulama mantığını da içerir.

import uuid
import hashlib

def hash_password(password):
   # uuid is used to generate a random number of the specified password
   salt = uuid.uuid4().hex
   return hashlib.sha256(salt.encode() + password.encode()).hexdigest() + ':' + salt

def check_password(hashed_password, user_password):
   password, salt = hashed_password.split(':')
   return password == hashlib.sha256(salt.encode() + user_password.encode()).hexdigest()

new_pass = input('Please enter a password: ')
hashed_password = hash_password(new_pass)
print('The string to store in the db is: ' + hashed_password)
old_pass = input('Now please enter the password again to check: ')

if check_password(hashed_password, old_pass):
   print('You entered the right password')
else:
   print('Passwords do not match')

Çıktı

Scenario 1 - Doğru bir şifre girdiyseniz, aşağıdaki çıktıyı bulabilirsiniz -

Scenario 2 - Yanlış şifre girersek, aşağıdaki çıktıyı bulabilirsiniz -

Açıklama

Hashlibpaketi, şifreleri bir veritabanında saklamak için kullanılır. Bu programda,salt karma işlevini uygulamadan önce parola dizesine rastgele bir sıra ekleyen kullanılır.

Vignere Cipher, şifreleme ve şifre çözme için kullanılan Caesar Cipher algoritmasına sahip bir bükülme içerir. Vignere Cipher, Caesar Cipher algoritmasına benzer şekilde çalışır ve yalnızca bir ana ayrım vardır: Caesar Cipher, tek karakterli geçiş için algoritma içerirken, Vignere Cipher çoklu alfabe kaydırmalı anahtarı içerir.

Matematiksel Denklem

Şifreleme için matematiksel denklem aşağıdaki gibidir -

$$ E_ {k} \ left (M {_ {i {}}} \ sağ) = \ left (M_ {i} + K_ {i} \ sağ) \; \; \; mod \; \; 26 $

Şifre çözme için matematiksel denklem aşağıdaki gibidir -

$$ D_ {k} \ sol (C {_ {i {}}} \ sağ) = \ sol (C_ {i} -K_ {i} \ sağ) \; \; \; mod \; \; 26 $

Vignere şifresi birden fazla ikame seti kullanır ve bu nedenle aynı zamanda polyalphabetic cipher. Vignere Cipher, sayısal tuş temsili yerine bir harf anahtarı kullanacaktır: A harfi 0 tuşu için, B harfi 1 tuşu için vb. Kullanılır. Şifreleme işleminden önceki ve sonraki harflerin sayıları aşağıda gösterilmiştir -

Vignere anahtar uzunluğuna dayalı olası anahtar sayısının olası kombinasyonu aşağıda verilmiştir ve bu, Vignere Cipher Algorithm'in ne kadar güvenli olduğunun sonucunu verir

Vignere Tableau

Vignere şifrelemesi için kullanılan tablo aşağıda gösterildiği gibidir -

Bu bölümde, Vignere şifresinin nasıl uygulanacağını anlayalım. Metni düşününThis is basic implementation of Vignere Cipher kodlanacak ve kullanılan anahtar PIZZA.

Kod

Python'da bir Vignere şifresi uygulamak için aşağıdaki kodu kullanabilirsiniz -

import pyperclip

LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def main():
   myMessage = "This is basic implementation of Vignere Cipher"
   myKey = 'PIZZA'
   myMode = 'encrypt'
   
   if myMode == 'encrypt':
      translated = encryptMessage(myKey, myMessage)
   elif myMode == 'decrypt':
      translated = decryptMessage(myKey, myMessage)
   
   print('%sed message:' % (myMode.title()))
   print(translated)
   print()
def encryptMessage(key, message):
   return translateMessage(key, message, 'encrypt')
def decryptMessage(key, message):
   return translateMessage(key, message, 'decrypt')
def translateMessage(key, message, mode):
   translated = [] # stores the encrypted/decrypted message string
   keyIndex = 0
   key = key.upper()
   
   for symbol in message:
      num = LETTERS.find(symbol.upper())
      if num != -1:
         if mode == 'encrypt':
            num += LETTERS.find(key[keyIndex])
				elif mode == 'decrypt':
               num -= LETTERS.find(key[keyIndex])
            num %= len(LETTERS)
            
            if symbol.isupper():
               translated.append(LETTERS[num])
            elif symbol.islower():
               translated.append(LETTERS[num].lower())
            keyIndex += 1
            
            if keyIndex == len(key):
               keyIndex = 0
         else:
            translated.append(symbol)
      return ''.join(translated)
if __name__ == '__main__':
   main()

Çıktı

Yukarıda verilen kodu uyguladığınızda aşağıdaki çıktıyı gözlemleyebilirsiniz -

Vignere şifresini hacklemenin olası kombinasyonları neredeyse imkansızdır. Bu nedenle, güvenli bir şifreleme modu olarak kabul edilir.

Tek seferlik ped şifresi, aşağıdaki özellikleri içeren bir tür Vignere şifresidir:

  • Kırılmaz bir şifredir.

  • Anahtar, şifrelenen mesajın uzunluğu ile tamamen aynıdır.

  • Anahtar, rastgele sembollerden oluşur.

  • Adından da anlaşılacağı gibi, anahtar yalnızca bir kez kullanılır ve başka herhangi bir mesajın şifrelenmesi için bir daha asla kullanılmaz.

Bu nedenle, şifrelenmiş mesaj bir kriptanalist için saldırılara açık olacaktır. Tek seferlik ped şifresi için kullanılan anahtara denirpad, kağıt pedlerine basıldığı için.

Neden Kırılmaz?

Aşağıdaki özellikler sayesinde anahtar kırılamaz -

  • Anahtar, verilen mesaj kadar uzun.

  • Anahtar gerçekten rastgele ve özel olarak otomatik oluşturulmuştur.

  • Modulo 10/26/2 olarak hesaplanan anahtar ve düz metin.

  • Her anahtar bir kez kullanılmalı ve hem gönderen hem de alıcı tarafından imha edilmelidir.

  • İki anahtar kopyası olmalıdır: biri gönderenle, diğeri alıcıyla.

Şifreleme

Bir harfi şifrelemek için, kullanıcının düz metnin altına bir anahtar yazması gerekir. Düz metin harf üstte ve anahtar harf solda yer alır. İki harf arasında elde edilen kesit düz metindir. Aşağıdaki örnekte açıklanmıştır -

Şifre çözme

Bir harfin şifresini çözmek için, kullanıcı soldaki anahtar harfi alır ve o satırda şifreli metin harfini bulur. Düz metin harfi, kullanıcının şifre metni harfini bulabileceği sütunun üst kısmına yerleştirilir.

Python, aşağıdakiler için hacky uygulama modülü içerir: one-time-padşifre uygulaması. Paket adı, tek seferlik ped şifreleme algoritmasına benzer şifreleme mekanizmasını kullanan bir komut satırı şifreleme aracı içeren One-Time-Pad olarak adlandırılır.

Kurulum

Bu modülü kurmak için aşağıdaki komutu kullanabilirsiniz -

pip install onetimepad

Komut satırından kullanmak isterseniz, aşağıdaki komutu çalıştırın -

onetimepad

Kod

Aşağıdaki kod, tek seferlik bir ped şifresi oluşturmaya yardımcı olur -

import onetimepad

cipher = onetimepad.encrypt('One Time Cipher', 'random')
print("Cipher text is ")
print(cipher)
print("Plain text is ")
msg = onetimepad.decrypt(cipher, 'random')

print(msg)

Çıktı

Yukarıda verilen kodu çalıştırdığınızda aşağıdaki çıktıyı gözlemleyebilirsiniz -

Note - Anahtarın uzunluğu mesajın uzunluğundan (düz metin) azsa şifrelenmiş mesajın kırılması çok kolaydır.

Her durumda, anahtarın rastgele olması gerekmez, bu da bir kerelik anahtar şifresini değerli bir araç haline getirir.

Bu bölümde simetrik ve asimetrik kriptografiyi detaylı olarak tartışalım.

Simetrik Kriptografi

Bu türde, şifreleme ve şifre çözme işlemi aynı anahtarı kullanır. Olarak da adlandırılırsecret key cryptography. Simetrik kriptografinin temel özellikleri aşağıdaki gibidir -

  • Daha basit ve daha hızlı.
  • İki taraf anahtarı güvenli bir şekilde değiştirir.

Dezavantaj

Simetrik kriptografinin en büyük dezavantajı, anahtar saldırgana sızdırılırsa, mesajın kolayca değiştirilebilmesi ve bunun bir risk faktörü olarak kabul edilmesidir.

Veri Şifreleme Standardı (DES)

En popüler simetrik anahtar algoritması Veri Şifreleme Standardıdır (DES) ve Python, DES algoritmasının arkasındaki mantığı içeren bir paket içerir.

Kurulum

DES paketini yükleme komutu pyDES Python'da -

pip install pyDES

DES algoritmasının basit program uygulaması aşağıdaki gibidir -

import pyDes

data = "DES Algorithm Implementation"
k = pyDes.des("DESCRYPT", pyDes.CBC, "\0\0\0\0\0\0\0\0", pad=None, padmode=pyDes.PAD_PKCS5)
d = k.encrypt(data)

print "Encrypted: %r" % d
print "Decrypted: %r" % k.decrypt(d)
assert k.decrypt(d) == data

Değişkeni çağırır padmode DES algoritması uygulamasına göre tüm paketleri getirir ve şifreleme ve şifre çözmeyi belirli bir şekilde izler.

Çıktı

Yukarıda verilen kodun bir sonucu olarak aşağıdaki çıktıyı görebilirsiniz -

Asimetrik Kriptografi

Olarak da adlandırılır public key cryptography.Simetrik kriptografinin tersi şekilde çalışır. Bu, iki anahtar gerektirdiği anlamına gelir: biri şifreleme, diğeri şifre çözme için. Genel anahtar şifreleme için kullanılır ve özel anahtar şifre çözmek için kullanılır.

Dezavantaj

  • Anahtar uzunluğu nedeniyle daha düşük şifreleme hızına katkıda bulunur.
  • Anahtar yönetimi çok önemlidir.

Python'daki aşağıdaki program kodu, RSA algoritması ve uygulamasını kullanarak asimetrik kriptografinin çalışmasını göstermektedir -

from Crypto import Random
from Crypto.PublicKey import RSA
import base64

def generate_keys():
   # key length must be a multiple of 256 and >= 1024
   modulus_length = 256*4
   privatekey = RSA.generate(modulus_length, Random.new().read)
   publickey = privatekey.publickey()
   return privatekey, publickey

def encrypt_message(a_message , publickey):
   encrypted_msg = publickey.encrypt(a_message, 32)[0]
   encoded_encrypted_msg = base64.b64encode(encrypted_msg)
   return encoded_encrypted_msg

def decrypt_message(encoded_encrypted_msg, privatekey):
   decoded_encrypted_msg = base64.b64decode(encoded_encrypted_msg)
   decoded_decrypted_msg = privatekey.decrypt(decoded_encrypted_msg)
   return decoded_decrypted_msg

a_message = "This is the illustration of RSA algorithm of asymmetric cryptography"
privatekey , publickey = generate_keys()
encrypted_msg = encrypt_message(a_message , publickey)
decrypted_msg = decrypt_message(encrypted_msg, privatekey)

print "%s - (%d)" % (privatekey.exportKey() , len(privatekey.exportKey()))
print "%s - (%d)" % (publickey.exportKey() , len(publickey.exportKey()))
print " Original content: %s - (%d)" % (a_message, len(a_message))
print "Encrypted message: %s - (%d)" % (encrypted_msg, len(encrypted_msg))
print "Decrypted message: %s - (%d)" % (decrypted_msg, len(decrypted_msg))

Çıktı

Yukarıda verilen kodu çalıştırdığınızda aşağıdaki çıktıyı bulabilirsiniz -

RSA algoritması, bir açık anahtar şifreleme tekniğidir ve en güvenli şifreleme yöntemi olarak kabul edilir. 1978 yılında Rivest, Shamir ve Adleman tarafından icat edildi ve dolayısıyla adıRSA algoritması.

Algoritma

RSA algoritması aşağıdaki özellikleri barındırır -

  • RSA algoritması, asal sayılar da dahil olmak üzere tamsayılar üzerinde sonlu bir alanda popüler bir üstelemedir.

  • Bu yöntem tarafından kullanılan tamsayılar yeterince büyüktür ve çözülmesini zorlaştırır.

  • Bu algoritmada iki anahtar grubu vardır: özel anahtar ve genel anahtar.

RSA algoritması üzerinde çalışmak için aşağıdaki adımları izlemeniz gerekecek -

Adım 1: RSA modülünü oluşturun

İlk prosedür, p ve q olmak üzere iki asal sayının seçilmesiyle başlar ve ardından gösterildiği gibi, N çarpımının hesaplanmasıyla başlar -

N=p*q

Burada, N belirtilen büyük sayı olsun.

Adım 2: Türetilmiş Sayı (e)

E sayısını 1'den büyük ve (p-1) ve (q-1) 'den küçük olması gereken türetilmiş bir sayı olarak düşünün. Birincil koşul, 1 dışında (p-1) ve (q-1) ortak faktörlerinin olmaması olacaktır.

3. Adım: Genel anahtar

Belirtilen sayı çifti n ve e RSA genel anahtarını oluşturur ve herkese açık hale getirilir.

4. Adım: Özel Anahtar

Özel anahtar dp, q ve e sayılarından hesaplanır. Sayılar arasındaki matematiksel ilişki şu şekildedir:

ed = 1 mod (p-1) (q-1)

Yukarıdaki formül, girdi parametreleri olarak p ve q'yu alan Genişletilmiş Öklid Algoritması için temel formüldür.

Şifreleme Formülü

Açık anahtarı olan birine düz metin mesajı gönderen bir göndereni düşünün (n,e). Verilen senaryoda düz metin mesajını şifrelemek için aşağıdaki sözdizimini kullanın -

C = Pe mod n

Şifre Çözme Formülü

Şifre çözme süreci çok basittir ve sistematik bir yaklaşımla hesaplama için analitik içerir. Alıcıyı düşünmek C özel anahtara sahip dsonuç modülü şu şekilde hesaplanacaktır -

Plaintext = Cd mod n

Bu bölümde, Python kullanarak RSA algoritmasının adım adım uygulanmasına odaklanacağız.

RSA anahtarları oluşturma

Aşağıdaki adımlar, RSA anahtarlarının oluşturulmasına dahildir -

  • Yani iki büyük asal sayı oluşturun p ve q. Bu numaraların ürünü aranacakn, nerede n= p*q

  • Göreceli olarak asal olan rastgele bir sayı oluşturun (p-1) ve (q-1). Numaranın şöyle çağrılmasına izin verin e.

  • E'nin modüler tersini hesaplayın. Hesaplanan ters şu şekilde adlandırılacaktır:d.

RSA anahtarları oluşturmak için algoritmalar

Python kullanarak RSA anahtarları oluşturmak için iki ana algoritmaya ihtiyacımız var - Cryptomath module ve Rabin Miller module.

Cryptomath Modülü

RSA algoritmasının tüm temel uygulamasını takip eden cryptomath modülünün kaynak kodu aşağıdaki gibidir -

def gcd(a, b):
   while a != 0:
      a, b = b % a, a
   return b

def findModInverse(a, m):
   if gcd(a, m) != 1:
      return None
   u1, u2, u3 = 1, 0, a
   v1, v2, v3 = 0, 1, m
   
   while v3 != 0:
      q = u3 // v3
         v1, v2, v3, u1, u2, u3 = (u1 - q * v1), (u2 - q * v2), (u3 - q * v3), v1, v2, v3
   return u1 % m

RabinMiller Modülü

RSA algoritmasının tüm temel uygulamasını takip eden RabinMiller modülünün kaynak kodu aşağıdaki gibidir -

import random
def rabinMiller(num):
   s = num - 1
   t = 0
   
   while s % 2 == 0:
      s = s // 2
      t += 1
   for trials in range(5):
      a = random.randrange(2, num - 1)
      v = pow(a, s, num)
      if v != 1:
         i = 0
         while v != (num - 1):
            if i == t - 1:
               return False
            else:
               i = i + 1
               v = (v ** 2) % num
      return True
def isPrime(num):
   if (num 7< 2):
      return False
   lowPrimes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 
   67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 
   157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 
   251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313,317, 331, 337, 347, 349, 
   353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 
   457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 
   571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 
   673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 
   797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 
   911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997]
	
   if num in lowPrimes:
      return True
   for prime in lowPrimes:
      if (num % prime == 0):
         return False
   return rabinMiller(num)
def generateLargePrime(keysize = 1024):
   while True:
      num = random.randrange(2**(keysize-1), 2**(keysize))
      if isPrime(num):
         return num

RSA anahtarları oluşturmak için tam kod aşağıdaki gibidir -

import random, sys, os, rabinMiller, cryptomath

def main():
   makeKeyFiles('RSA_demo', 1024)

def generateKey(keySize):
   # Step 1: Create two prime numbers, p and q. Calculate n = p * q.
   print('Generating p prime...')
   p = rabinMiller.generateLargePrime(keySize)
   print('Generating q prime...')
   q = rabinMiller.generateLargePrime(keySize)
   n = p * q
	
   # Step 2: Create a number e that is relatively prime to (p-1)*(q-1).
   print('Generating e that is relatively prime to (p-1)*(q-1)...')
   while True:
      e = random.randrange(2 ** (keySize - 1), 2 ** (keySize))
      if cryptomath.gcd(e, (p - 1) * (q - 1)) == 1:
         break
   
   # Step 3: Calculate d, the mod inverse of e.
   print('Calculating d that is mod inverse of e...')
   d = cryptomath.findModInverse(e, (p - 1) * (q - 1))
   publicKey = (n, e)
   privateKey = (n, d)
   print('Public key:', publicKey)
   print('Private key:', privateKey)
   return (publicKey, privateKey)

def makeKeyFiles(name, keySize):
   # Creates two files 'x_pubkey.txt' and 'x_privkey.txt' 
      (where x is the value in name) with the the n,e and d,e integers written in them,
   # delimited by a comma.
   if os.path.exists('%s_pubkey.txt' % (name)) or os.path.exists('%s_privkey.txt' % (name)):
      sys.exit('WARNING: The file %s_pubkey.txt or %s_privkey.txt already exists! Use a different name or delete these files and re-run this program.' % (name, name))
   publicKey, privateKey = generateKey(keySize)
   print()
   print('The public key is a %s and a %s digit number.' % (len(str(publicKey[0])), len(str(publicKey[1])))) 
   print('Writing public key to file %s_pubkey.txt...' % (name))
   
   fo = open('%s_pubkey.txt' % (name), 'w')
	fo.write('%s,%s,%s' % (keySize, publicKey[0], publicKey[1]))
   fo.close()
   print()
   print('The private key is a %s and a %s digit number.' % (len(str(publicKey[0])), len(str(publicKey[1]))))
   print('Writing private key to file %s_privkey.txt...' % (name))
   
   fo = open('%s_privkey.txt' % (name), 'w')
   fo.write('%s,%s,%s' % (keySize, privateKey[0], privateKey[1]))
   fo.close()
# If makeRsaKeys.py is run (instead of imported as a module) call
# the main() function.
if __name__ == '__main__':
   main()

Çıktı

Genel anahtar ve özel anahtarlar, aşağıdaki çıktıda gösterildiği gibi, ilgili dosyalara oluşturulur ve kaydedilir.

Bu bölümde, RSA şifreleme şifrelemesinin farklı uygulamalarına ve bununla ilgili işlevlere odaklanacağız. RSA şifreleme algoritması uygulamasını uygulamak için bu python dosyasına başvurabilir veya dahil edebilirsiniz.

Şifreleme algoritması için dahil edilen modüller aşağıdaki gibidir -

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA512, SHA384, SHA256, SHA, MD5
from Crypto import Random
from base64 import b64encode, b64decode
hash = "SHA-256"

Daha iyi güvenlik amacıyla hash değerini SHA-256 olarak başlattık. Aşağıdaki kodu kullanarak yeni anahtarlar veya bir çift genel ve özel anahtar oluşturmak için bir işlev kullanacağız.

def newkeys(keysize):
   random_generator = Random.new().read
   key = RSA.generate(keysize, random_generator)
   private, public = key, key.publickey()
   return public, private
def importKey(externKey):
   return RSA.importKey(externKey)

Şifreleme için, RSA algoritmasını takip eden aşağıdaki işlev kullanılır -

def encrypt(message, pub_key):
   cipher = PKCS1_OAEP.new(pub_key)
   return cipher.encrypt(message)

İki parametre zorunludur: message ve pub_keyGenel anahtarı ifade eder. Şifreleme için bir genel anahtar kullanılır ve şifre çözme için özel anahtar kullanılır.

Şifreleme prosedürü için eksiksiz program aşağıda belirtilmiştir -

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA512, SHA384, SHA256, SHA, MD5
from Crypto import Random
from base64 import b64encode, b64decode
hash = "SHA-256"

def newkeys(keysize):
   random_generator = Random.new().read
   key = RSA.generate(keysize, random_generator)
   private, public = key, key.publickey()
   return public, private

def importKey(externKey):
   return RSA.importKey(externKey)

def getpublickey(priv_key):
   return priv_key.publickey()

def encrypt(message, pub_key):
   cipher = PKCS1_OAEP.new(pub_key)
   return cipher.encrypt(message)

Bu bölüm, RSA algoritmasını kullanarak şifrelemenin adım adım uygulanmasını izlediğimiz ve bu konuda ayrıntılı olarak tartıştığımız önceki bölümün devamıdır.

Şifreleme metninin şifresini çözmek için kullanılan işlev aşağıdaki gibidir -

def decrypt(ciphertext, priv_key):
   cipher = PKCS1_OAEP.new(priv_key)
   return cipher.decrypt(ciphertext)

Açık anahtar şifrelemesi veya asimetrik anahtar şifrelemesi için iki önemli özelliği korumak önemlidir: Authentication ve Authorization.

yetki

Yetkilendirme, mesajı gönderenin tek kişi olduğunu onaylama işlemidir. Aşağıdaki kod bunu açıklıyor -

def sign(message, priv_key, hashAlg="SHA-256"):
   global hash
   hash = hashAlg
   signer = PKCS1_v1_5.new(priv_key)
   
   if (hash == "SHA-512"):
      digest = SHA512.new()
   elif (hash == "SHA-384"):
      digest = SHA384.new()
   elif (hash == "SHA-256"):
      digest = SHA256.new()
   elif (hash == "SHA-1"):
      digest = SHA.new()
   else:
      digest = MD5.new()
   digest.update(message)
   return signer.sign(digest)

Doğrulama

Kimlik doğrulama, aşağıda açıklanan doğrulama yöntemi ile mümkündür -

def verify(message, signature, pub_key):
   signer = PKCS1_v1_5.new(pub_key)
   if (hash == "SHA-512"):
      digest = SHA512.new()
   elif (hash == "SHA-384"):
      digest = SHA384.new()
   elif (hash == "SHA-256"):
      digest = SHA256.new()
   elif (hash == "SHA-1"):
      digest = SHA.new()
   else:
      digest = MD5.new()
   digest.update(message)
   return signer.verify(digest, signature)

Dijital imza, gönderen ve alıcının ayrıntıları ile birlikte doğrulanır. Bu, güvenlik amacıyla daha fazla ağırlık yaşı ekler.

RSA Şifreli Şifre Çözme

RSA şifresi çözme için aşağıdaki kodu kullanabilirsiniz -

from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Signature import PKCS1_v1_5
from Crypto.Hash import SHA512, SHA384, SHA256, SHA, MD5
from Crypto import Random
from base64 import b64encode, b64decode
hash = "SHA-256"

def newkeys(keysize):
   random_generator = Random.new().read
   key = RSA.generate(keysize, random_generator)
   private, public = key, key.publickey()
   return public, private

def importKey(externKey):
   return RSA.importKey(externKey)

def getpublickey(priv_key):
   return priv_key.publickey()

def encrypt(message, pub_key):
   cipher = PKCS1_OAEP.new(pub_key)
   return cipher.encrypt(message)

def decrypt(ciphertext, priv_key):
   cipher = PKCS1_OAEP.new(priv_key)
   return cipher.decrypt(ciphertext)

def sign(message, priv_key, hashAlg = "SHA-256"):
   global hash
   hash = hashAlg
   signer = PKCS1_v1_5.new(priv_key)
   
   if (hash == "SHA-512"):
      digest = SHA512.new()
   elif (hash == "SHA-384"):
      digest = SHA384.new()
   elif (hash == "SHA-256"):
      digest = SHA256.new()
   elif (hash == "SHA-1"):
      digest = SHA.new()
   else:
      digest = MD5.new()
   digest.update(message)
   return signer.sign(digest)

def verify(message, signature, pub_key):
   signer = PKCS1_v1_5.new(pub_key)
   if (hash == "SHA-512"):
      digest = SHA512.new()
   elif (hash == "SHA-384"):
      digest = SHA384.new()
   elif (hash == "SHA-256"):
      digest = SHA256.new()
   elif (hash == "SHA-1"):
      digest = SHA.new()
   else:
      digest = MD5.new()
   digest.update(message)
   return signer.verify(digest, signature)

RSA şifresini kesmek küçük asal sayılarla mümkündür, ancak büyük sayılarla kullanılması imkansız kabul edilir. RSA şifresini kırmanın neden zor olduğunu belirten nedenler aşağıdaki gibidir:

  • Üzerinde çalışmak için çok fazla olası anahtar olduğundan kaba kuvvet saldırısı çalışmayacaktır. Ayrıca, bu çok fazla zaman tüketir.

  • RSA algoritmasında, anahtarlar sayısal olduğundan ve içinde herhangi bir karakter bulunmadığından sözlük saldırısı çalışmayacaktır.

  • Tek bir şifreli blok çeşitli karakterleri temsil ettiğinden karakterlerin frekans analizini takip etmek çok zordur.

  • RSA şifresini kırmak için belirli bir matematiksel numara yoktur.

RSA şifre çözme denklemi -

M = C^d mod n

Küçük asal sayıların yardımıyla, RSA şifresini hacklemeyi deneyebiliriz ve bunun için örnek kod aşağıda belirtilmiştir -

def p_and_q(n):
   data = []
   for i in range(2, n):
      if n % i == 0:
         data.append(i)
   return tuple(data)

def euler(p, q):
   return (p - 1) * (q - 1)

def private_index(e, euler_v):
   for i in range(2, euler_v):
      if i * e % euler_v == 1:
         return i

def decipher(d, n, c):
   return c ** d % n
	def main():
      e = int(input("input e: "))
      n = int(input("input n: "))
      c = int(input("input c: "))
      
      # t = 123
      # private key = (103, 143)
      p_and_q_v = p_and_q(n)
      # print("[p_and_q]: ", p_and_q_v)
      euler_v = euler(p_and_q_v[0], p_and_q_v[1])
      
      # print("[euler]: ", euler_v)
      d = private_index(e, euler_v)
      plain = decipher(d, n, c)
      print("plain: ", plain)
if __name__ == "__main__":
   main()

Çıktı

Yukarıdaki kod aşağıdaki çıktıyı üretir -