Kriptografi dengan Python - Panduan Cepat

Kriptografi adalah seni komunikasi antara dua pengguna melalui pesan berkode. Ilmu kriptografi muncul dengan motif dasar memberikan keamanan pada pesan rahasia yang ditransfer dari satu pihak ke pihak lain.

Kriptografi didefinisikan sebagai seni dan ilmu menyembunyikan pesan untuk memperkenalkan privasi dan kerahasiaan sebagaimana diakui dalam keamanan informasi.

Istilah Kriptografi

Istilah yang sering digunakan dalam kriptografi dijelaskan di sini -

Teks Biasa

Pesan teks biasa adalah teks yang dapat dibaca dan dipahami oleh semua pengguna. Teks biasa adalah pesan yang menjalani kriptografi.

Teks Sandi

Teks sandi adalah pesan yang diperoleh setelah menerapkan kriptografi pada teks biasa.

Enkripsi

Proses mengubah teks biasa menjadi teks sandi disebut enkripsi. Ini juga disebut sebagai pengkodean.

Dekripsi

Proses mengubah teks sandi menjadi teks biasa disebut dekripsi. Ini juga disebut sebagai decoding.

Diagram yang diberikan di bawah ini menunjukkan ilustrasi dari proses lengkap kriptografi -

Karakteristik Kriptografi Modern

Karakteristik dasar kriptografi modern adalah sebagai berikut -

  • Ini beroperasi pada urutan bit.

  • Ia menggunakan algoritma matematika untuk mengamankan informasi.

  • Ini membutuhkan pihak yang berkepentingan dengan saluran komunikasi yang aman untuk mencapai privasi.

Enkripsi kekuatan ganda, disebut juga enkripsi ganda, adalah proses mengenkripsi teks yang sudah dienkripsi satu kali atau lebih, baik dengan algoritma / pola yang sama atau berbeda.

Nama lain untuk enkripsi kekuatan ganda termasuk enkripsi cascade atau cascade ciphering.

Tingkat Enkripsi Kekuatan Ganda

Enkripsi kekuatan ganda mencakup berbagai tingkat enkripsi yang dijelaskan di sini di bawah -

Enkripsi lapisan pertama

Teks sandi dihasilkan dari pesan asli yang dapat dibaca menggunakan algoritme hash dan kunci simetris. Kemudian kunci simetris dienkripsi dengan bantuan kunci asimetris. Ilustrasi terbaik untuk pola ini adalah menggabungkan intisari hash teks sandi ke dalam kapsul. Penerima akan menghitung intisari terlebih dahulu dan kemudian mendekripsi teks untuk memverifikasi bahwa teks tidak dirusak di antaranya.

Lapisan kedua dari enkripsi

Enkripsi lapisan kedua adalah proses menambahkan satu lapisan lagi ke teks sandi dengan algoritma yang sama atau berbeda. Biasanya, sandi simetris panjang karakter 32-bit digunakan untuk hal yang sama.

Lapisan ketiga dari enkripsi

Dalam proses ini, kapsul yang dienkripsi dikirim melalui koneksi SSL / TLS ke mitra komunikasi.

Diagram berikut menunjukkan proses enkripsi ganda secara bergambar -

Kriptografi Hibrid

Kriptografi hybrid adalah proses menggunakan beberapa cipher dari jenis yang berbeda bersama-sama dengan memasukkan manfaat dari masing-masing cipher. Ada satu pendekatan umum yang biasanya diikuti untuk menghasilkan kunci rahasia acak untuk sandi simetris dan kemudian mengenkripsi kunci ini melalui kriptografi kunci asimetris.

Karena pola ini, pesan asli itu sendiri dienkripsi menggunakan sandi simetris dan kemudian menggunakan kunci rahasia. Penerima setelah menerima pesan mendekripsi pesan menggunakan kunci rahasia terlebih dahulu, menggunakan kunci pribadinya sendiri dan kemudian menggunakan kunci yang ditentukan untuk mendekripsi pesan.

Python adalah bahasa skrip sumber terbuka yang tingkat tinggi, ditafsirkan, interaktif dan berorientasi objek. Ini dirancang agar sangat mudah dibaca. Sintaks bahasa Python mudah dipahami dan sering menggunakan kata kunci bahasa Inggris.

Fitur Bahasa Python

Python menyediakan fitur utama berikut -

Ditafsirkan

Python diproses saat runtime menggunakan interpreter. Tidak perlu mengkompilasi program sebelum dieksekusi. Ini mirip dengan PERL dan PHP.

Berorientasi pada objek

Python mengikuti gaya dan pola desain berorientasi objek. Ini termasuk definisi kelas dengan berbagai fitur seperti enkapsulasi dan polimorfisme.

Poin Utama Bahasa Python

Poin utama dari bahasa pemrograman Python adalah sebagai berikut -

  • Ini mencakup pemrograman dan metode fungsional dan terstruktur serta metode pemrograman berorientasi objek.

  • Ini dapat digunakan sebagai bahasa scripting atau sebagai bahasa pemrograman.

  • Ini termasuk pengumpulan sampah otomatis.

  • Ini mencakup tipe data dinamis tingkat tinggi dan mendukung berbagai pemeriksaan tipe dinamis.

  • Python menyertakan fitur integrasi dengan C, C ++ dan bahasa seperti Java.

Tautan unduhan untuk bahasa Python adalah sebagai berikut - www.python.org/downloads Ini termasuk paket untuk berbagai sistem operasi seperti distribusi Windows, MacOS dan Linux.

String Python

Deklarasi dasar string ditunjukkan di bawah ini -

str = 'Hello World!'

Daftar Python

Daftar python dapat dideklarasikan sebagai tipe data gabungan, dipisahkan dengan koma dan diapit oleh tanda kurung siku ([]).

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

Python Tuple

Tuple adalah tipe data dinamis dari Python yang terdiri dari sejumlah nilai yang dipisahkan dengan koma. Tupel diapit dengan tanda kurung.

tinytuple = (123, 'john')

Kamus Python

Kamus Python adalah jenis tabel hash. Kunci kamus dapat berupa hampir semua tipe data Python, yang biasanya berupa angka atau string.

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

Paket Kriptografi

Python menyertakan paket yang disebut kriptografi yang menyediakan resep kriptografi dan primitif. Ini mendukung Python 2.7, Python 3.4+, dan PyPy 5.3+. Instalasi dasar paket kriptografi dicapai melalui perintah berikut -

pip install cryptography

Ada berbagai paket dengan resep tingkat tinggi dan antarmuka tingkat rendah untuk algoritme kriptografi umum seperti symmetric ciphers, message digests dan key derivation functions.

Sepanjang tutorial ini, kami akan menggunakan berbagai paket Python untuk implementasi algoritma kriptografi.

Bab sebelumnya memberi Anda gambaran umum tentang instalasi Python di komputer lokal Anda. Pada bab ini Anda akan mempelajari secara detail tentang reverse cipher dan pengkodeannya.

Algoritma Reverse Cipher

Algoritma cipher terbalik memiliki beberapa fitur berikut -

  • Reverse Cipher menggunakan pola pembalikan string teks biasa untuk diubah sebagai teks sandi.

  • Proses enkripsi dan dekripsi sama.

  • Untuk mendekripsi teks sandi, pengguna hanya perlu membalikkan teks sandi untuk mendapatkan teks biasa.

Kekurangan

Kelemahan utama dari reverse cipher adalah sangat lemah. Seorang peretas dapat dengan mudah memecahkan teks sandi untuk mendapatkan pesan asli. Oleh karena itu, reverse cipher tidak dianggap sebagai pilihan yang baik untuk menjaga saluran komunikasi yang aman.

Contoh

Perhatikan contoh dimana pernyataan tersebut This is program to explain reverse cipherakan diimplementasikan dengan algoritma cipher terbalik. Kode python berikut menggunakan algoritma untuk mendapatkan keluarannya.

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)

Keluaran

Anda dapat melihat teks yang dibalik, yaitu output seperti yang ditunjukkan pada gambar berikut -

Penjelasan

  • Teks biasa disimpan dalam pesan variabel dan variabel terjemahan digunakan untuk menyimpan teks sandi yang dibuat.

  • Panjang teks biasa dihitung menggunakan for loop dan dengan bantuan index number. Karakter disimpan dalam variabel teks sanditranslated yang dicetak di baris terakhir.

Pada bab terakhir, kita telah membahas sandi terbalik. Bab ini membahas sandi Caesar secara rinci.

Algoritma Caesar Cipher

Algoritma sandi Caesar memiliki fitur-fitur berikut -

  • Teknik Cipher Caesar adalah metode teknik enkripsi yang sederhana dan mudah.

  • Ini adalah jenis sandi substitusi sederhana.

  • Setiap huruf teks biasa diganti dengan sebuah huruf dengan beberapa posisi tetap di bawah alfabet.

Diagram berikut menggambarkan cara kerja implementasi algoritma cipher Caesar -

Implementasi program algoritma cipher Caesar adalah sebagai berikut -

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)

Keluaran

Anda dapat melihat cipher Caesar, yaitu output seperti yang ditunjukkan pada gambar berikut -

Penjelasan

Karakter teks biasa dilintasi satu per satu.

  • Untuk setiap karakter dalam teks biasa yang diberikan, ubah karakter yang diberikan sesuai aturan bergantung pada prosedur enkripsi dan dekripsi teks.

  • Setelah langkah-langkah tersebut diikuti, string baru dihasilkan yang disebut teks sandi.

Peretasan Algoritma Caesar Cipher

Teks sandi dapat diretas dengan berbagai kemungkinan. Salah satu kemungkinan tersebut adalahBrute Force Technique,yang melibatkan mencoba setiap kunci dekripsi yang mungkin. Teknik ini tidak membutuhkan banyak usaha dan relatif sederhana untuk seorang hacker.

Implementasi program untuk meretas algoritma cipher Caesar adalah sebagai berikut -

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))

Pertimbangkan teks sandi yang dienkripsi dalam contoh sebelumnya. Kemudian, output dengan kemungkinan metode peretasan dengan kunci dan teknik serangan brute force adalah sebagai berikut -

Sampai sekarang, Anda telah belajar tentang algoritma sandi terbalik dan sandi Caesar. Sekarang, mari kita bahas algoritma ROT13 dan implementasinya.

Penjelasan Algoritma ROT13

Sandi ROT13 mengacu pada bentuk singkatan Rotate by 13 places. Ini adalah kasus khusus Caesar Cipher di mana shift selalu 13. Setiap surat digeser 13 tempat untuk mengenkripsi atau mendekripsi pesan.

Contoh

Diagram berikut menjelaskan proses algoritma ROT13 secara bergambar -

Kode Program

Implementasi program dari algoritma ROT13 adalah sebagai berikut -

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()

Anda dapat melihat output ROT13 seperti yang ditunjukkan pada gambar berikut -

Kekurangan

Algoritma ROT13 menggunakan 13 shift. Oleh karena itu, sangat mudah untuk menggeser karakter secara terbalik untuk mendekripsi teks sandi.

Analisis Algoritma ROT13

Algoritma penyandian ROT13 dianggap sebagai kasus khusus dari Caesar Cipher. Ini bukan algoritme yang sangat aman dan dapat dipecahkan dengan mudah dengan analisis frekuensi atau hanya dengan mencoba kemungkinan 25 kunci sedangkan ROT13 dapat dipecahkan dengan menggeser 13 tempat. Oleh karena itu, ini tidak termasuk penggunaan praktis.

Transposition Cipher adalah algoritma kriptografi dimana urutan abjad dalam teks biasa disusun ulang untuk membentuk teks sandi. Dalam proses ini, huruf teks biasa yang sebenarnya tidak disertakan.

Contoh

Contoh sederhana untuk sandi transposisi adalah columnar transposition cipherdimana setiap karakter dalam teks biasa ditulis secara horizontal dengan lebar alfabet yang ditentukan. Sandi tersebut ditulis secara vertikal, yang menciptakan teks sandi yang sama sekali berbeda.

Pertimbangkan teks biasa hello world, dan mari kita terapkan teknik transposisi kolom sederhana seperti yang ditunjukkan di bawah ini

Karakter teks biasa ditempatkan secara horizontal dan teks sandi dibuat dengan format vertikal sebagai : holewdlo lr. Sekarang, penerima harus menggunakan tabel yang sama untuk mendekripsi teks sandi menjadi teks biasa.

Kode

Kode program berikut menunjukkan implementasi dasar teknik transposisi kolom -

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'))

Penjelasan

  • Menggunakan fungsi tersebut split_len(), kita dapat membagi karakter teks biasa, yang dapat ditempatkan dalam format kolom atau baris.

  • encode Metode membantu untuk membuat teks sandi dengan kunci yang menentukan jumlah kolom dan mencetak teks sandi dengan membaca karakter melalui setiap kolom.

Keluaran

Kode program untuk implementasi dasar teknik transposisi kolom memberikan keluaran sebagai berikut -

Note- Cryptanalysts mengamati peningkatan yang signifikan dalam keamanan kripto ketika teknik transposisi dilakukan. Mereka juga mencatat bahwa mengenkripsi ulang teks sandi menggunakan sandi transposisi yang sama menciptakan keamanan yang lebih baik.

Pada bab sebelumnya, kita telah mempelajari tentang Transposition Cipher. Dalam bab ini, mari kita bahas enkripsi nya.

Pyperclip

Penggunaan utama pyperclipPlugin dalam bahasa pemrograman Python adalah untuk melakukan modul lintas platform untuk menyalin dan menempel teks ke clipboard. Anda dapat menginstal pythonpyperclip modul menggunakan perintah seperti yang ditunjukkan

pip install pyperclip

Jika persyaratan sudah ada di sistem, Anda dapat melihat output berikut -

Kode

Kode python untuk mengenkripsi cipher transposisi di mana pyperclip adalah modul utama adalah seperti yang ditunjukkan di bawah ini -

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()

Keluaran

Kode program untuk mengenkripsi sandi transposisi di mana pyperclip adalah modul utama memberikan output berikut -

Penjelasan

  • Fungsinya main() memanggil encryptMessage() yang mencakup prosedur untuk memisahkan karakter menggunakan len berfungsi dan mengulanginya dalam format kolom.

  • Fungsi utama diinisialisasi di bagian akhir untuk mendapatkan keluaran yang sesuai.

Dalam bab ini, Anda akan mempelajari prosedur untuk mendekripsi sandi transposisi.

Kode

Perhatikan kode berikut untuk pemahaman yang lebih baik tentang mendekripsi sandi transposisi. Teks sandi untuk pesanTransposition Cipher dengan kunci sebagai 6 diambil sebagai 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()

Penjelasan

Teks sandi dan kunci yang disebutkan adalah dua nilai yang diambil sebagai parameter masukan untuk mendekode atau mendekripsi teks sandi secara terbalik dengan menempatkan karakter dalam format kolom dan membacanya secara horizontal.

Anda dapat menempatkan huruf dalam format kolom dan kemudian menggabungkan atau menggabungkannya bersama-sama menggunakan bagian kode berikut -

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)

Keluaran

Kode program untuk mendekripsi cipher transposisi memberikan output berikut -

Dengan Python, dimungkinkan untuk mengenkripsi dan mendekripsi file sebelum dikirim ke saluran komunikasi. Untuk ini, Anda harus menggunakan pluginPyCrypto. Anda dapat menginstal plugin ini menggunakan perintah yang diberikan di bawah ini.

pip install pycrypto

Kode

Kode program untuk mengenkripsi file dengan pelindung kata sandi disebutkan di bawah ini -

# =================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()

Anda dapat menggunakan perintah berikut untuk menjalankan proses enkripsi bersama dengan kata sandi -

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

Keluaran

Anda dapat mengamati keluaran berikut ketika Anda menjalankan kode yang diberikan di atas -

Penjelasan

Kata sandi dibuat menggunakan algoritma hash MD5 dan nilainya disimpan dalam file cadangan yang aman di sistem Windows, yang mencakup nilai seperti yang ditampilkan di bawah ini -

Pada bab ini, mari kita bahas dekripsi file dalam kriptografi menggunakan Python. Perhatikan bahwa untuk proses dekripsi, kami akan mengikuti prosedur yang sama, tetapi alih-alih menentukan jalur keluaran, kami akan fokus pada jalur input atau file yang diperlukan yang dienkripsi.

Kode

Berikut ini adalah contoh kode untuk mendekripsi file dalam kriptografi menggunakan Python -

#!/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()

Anda dapat menggunakan perintah berikut untuk menjalankan kode di atas -

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

Keluaran

Anda dapat mengamati kode berikut ketika Anda menjalankan perintah yang ditunjukkan di atas -

Note - Output menentukan nilai hash sebelum enkripsi dan setelah dekripsi, yang menyimpan catatan bahwa file yang sama dienkripsi dan prosesnya berhasil.

Pengkodean Base64 mengubah data biner menjadi format teks, yang diteruskan melalui saluran komunikasi tempat pengguna dapat menangani teks dengan aman. Base64 juga disebut sebagaiPrivacy enhanced Electronic mail (PEM) dan terutama digunakan dalam proses enkripsi email.

Python menyertakan modul bernama BASE64 yang mencakup dua fungsi utama seperti yang diberikan di bawah ini -

  • base64.decode(input, output) - Ini menerjemahkan parameter nilai input yang ditentukan dan menyimpan output yang didekodekan sebagai objek.

  • Base64.encode(input, output) - Ini mengkodekan parameter nilai input yang ditentukan dan menyimpan output yang diterjemahkan sebagai objek.

Program untuk Pengkodean

Anda dapat menggunakan potongan kode berikut untuk melakukan pengkodean base64 -

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

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

Keluaran

Kode untuk pengkodean base64 memberi Anda keluaran berikut -

Program untuk Decoding

Anda dapat menggunakan potongan kode berikut untuk melakukan decoding base64 -

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

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

Keluaran

Kode untuk decoding base64 memberi Anda output berikut -

Perbedaan antara ASCII dan base64

Anda dapat mengamati perbedaan berikut saat Anda mengerjakan ASCII dan base64 untuk encoding data -

  • Saat Anda menyandikan teks dalam ASCII, Anda mulai dengan string teks dan mengubahnya menjadi urutan byte.

  • Saat Anda menyandikan data di Base64, Anda mulai dengan urutan byte dan mengubahnya menjadi string teks.

Kekurangan

Algoritma Base64 biasanya digunakan untuk menyimpan kata sandi dalam database. Kelemahan utama adalah bahwa setiap kata yang diterjemahkan dapat dikodekan dengan mudah melalui alat online apa pun dan penyusup dapat dengan mudah mendapatkan informasinya.

Dalam bab ini, mari kita pahami proses XOR beserta pengkodeannya dengan Python.

Algoritma

Algoritma XOR enkripsi dan dekripsi mengubah teks biasa dalam format byte ASCII dan menggunakan prosedur XOR untuk mengubahnya menjadi byte tertentu. Ini menawarkan keuntungan berikut untuk penggunanya -

  • Perhitungan cepat
  • Tidak ada perbedaan yang ditandai di sisi kiri dan kanan
  • Mudah dipahami dan dianalisis

Kode

Anda dapat menggunakan potongan kode berikut untuk melakukan proses XOR -

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)

Keluaran

Kode untuk proses XOR memberi Anda keluaran berikut -

Penjelasan

  • Fungsinya xor_crypt_string() termasuk parameter untuk menentukan mode encode dan decode dan juga nilai string.

  • Fungsi dasar diambil dengan modul base64 yang mengikuti prosedur / operasi XOR untuk mengenkripsi atau mendekripsi teks biasa / teks sandi.

Note - Enkripsi XOR digunakan untuk mengenkripsi data dan sulit dipecahkan dengan metode brute force, yaitu dengan menghasilkan kunci enkripsi acak agar sesuai dengan teks sandi yang benar.

Saat menggunakan teknik sandi Caesar, mengenkripsi dan mendekripsi simbol melibatkan pengubahan nilai menjadi angka dengan prosedur dasar sederhana penambahan atau pengurangan.

Jika perkalian digunakan untuk mengubah teks sandi, itu disebut a wrap-aroundsituasi. Pertimbangkan huruf dan angka terkait yang akan digunakan seperti yang ditunjukkan di bawah ini -

Angka-angka yang akan digunakan untuk prosedur perkalian dan kunci yang terkait adalah 7. Rumus dasar yang akan digunakan dalam skenario seperti itu untuk menghasilkan sandi perkalian adalah sebagai berikut -

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

Nomor yang diambil melalui keluaran dipetakan dalam tabel yang disebutkan di atas dan surat yang sesuai diambil sebagai surat terenkripsi.

Fungsi modulasi dasar dari perkalian cipher dengan Python adalah sebagai berikut -

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

Note- Keuntungan dengan multiplicative cipher adalah dapat bekerja dengan kunci yang sangat besar seperti 8.953.851. Butuh waktu yang cukup lama bagi sebuah komputer untuk memaksa melalui mayoritas sembilan juta kunci.

Affine Cipher adalah gabungan dari algoritma Multiplicative Cipher dan Caesar Cipher. Implementasi dasar dari affine cipher adalah seperti yang ditunjukkan pada gambar di bawah ini -

Pada bab ini, kita akan mengimplementasikan affine cipher dengan membuat kelas terkait yang mencakup dua fungsi dasar untuk enkripsi dan dekripsi.

Kode

Anda dapat menggunakan kode berikut untuk mengimplementasikan cipher affine -

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')

Keluaran

Anda dapat mengamati keluaran berikut saat mengimplementasikan cipher affine -

Outputnya menampilkan pesan terenkripsi untuk pesan teks biasa Affine Cipher dan pesan yang didekripsi untuk pesan yang dikirim sebagai input abcdefg.

Pada bab ini, Anda akan belajar tentang sandi monoalphabetic dan peretasannya menggunakan Python.

Sandi Monoalphabetic

Sebuah sandi monoalphabetic menggunakan substitusi tetap untuk mengenkripsi seluruh pesan. Sandi monoalphabetic yang menggunakan kamus Python dengan objek JSON ditampilkan di sini -

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',
	' ': ' ',
}

Dengan bantuan kamus ini, kita dapat mengenkripsi huruf dengan huruf terkait sebagai nilai dalam objek JSON. Program berikut membuat program monoalphabetic sebagai representasi kelas yang mencakup semua fungsi enkripsi dan dekripsi.

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)
   )

File ini dipanggil kemudian untuk mengimplementasikan proses enkripsi dan dekripsi dari sandi Monoalphabetic yang disebutkan di bawah ini -

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)

Keluaran

Anda dapat mengamati keluaran berikut ketika Anda menerapkan kode yang diberikan di atas -

Dengan demikian, Anda dapat meretas sandi monoalphabetic dengan pasangan nilai kunci tertentu yang memecahkan teks sandi menjadi teks biasa yang sebenarnya.

Sandi substitusi sederhana adalah sandi yang paling umum digunakan dan menyertakan algoritme yang menggantikan setiap karakter teks biasa untuk setiap karakter teks sandi. Dalam proses ini, alfabet campur aduk dibandingkan dengan algoritma cipher Caesar.

Contoh

Kunci untuk sandi substitusi sederhana biasanya terdiri dari 26 huruf. Contoh kunci adalah -

plain alphabet : abcdefghijklmnopqrstuvwxyz
cipher alphabet: phqgiumeaylnofdxjkrcvstzwb

Contoh enkripsi menggunakan kunci di atas adalah−

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

Kode berikut menunjukkan program untuk mengimplementasikan sandi substitusi sederhana -

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()

Keluaran

Anda dapat mengamati keluaran berikut ketika Anda menerapkan kode yang diberikan di atas -

Pada bab ini, kita akan fokus pada pengujian substitusi cipher menggunakan berbagai metode, yang membantu menghasilkan string acak seperti yang diberikan di bawah ini -

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()

Keluaran

Anda dapat mengamati hasilnya sebagai string yang dibuat secara acak yang membantu menghasilkan pesan teks biasa secara acak, seperti yang ditunjukkan di bawah ini -

Setelah tes berhasil diselesaikan, kita dapat mengamati pesan keluaran Substitution test passed!.

Dengan demikian, Anda dapat meretas sandi substitusi dengan cara yang sistematis.

Dalam bab ini, Anda dapat mempelajari tentang implementasi sederhana dari cipher substitusi yang menampilkan pesan terenkripsi dan didekripsi sesuai logika yang digunakan dalam teknik sandi substitusi sederhana. Ini dapat dianggap sebagai pendekatan alternatif pengkodean.

Kode

Anda dapat menggunakan kode berikut untuk melakukan dekripsi menggunakan sandi substitusi sederhana -

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')

Keluaran

Kode di atas memberi Anda output seperti yang ditunjukkan di sini -

Pada bab ini, Anda akan belajar secara detail tentang berbagai modul kriptografi dengan Python.

Modul Kriptografi

Ini mencakup semua resep dan primitif, dan menyediakan antarmuka pengkodean tingkat tinggi dengan Python. Anda dapat menginstal modul kriptografi menggunakan perintah berikut -

pip install cryptography

Kode

Anda dapat menggunakan kode berikut untuk mengimplementasikan modul kriptografi -

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)

Keluaran

Kode yang diberikan di atas menghasilkan keluaran sebagai berikut -

Kode yang diberikan di sini digunakan untuk memverifikasi kata sandi dan membuat hashnya. Ini juga mencakup logika untuk memverifikasi kata sandi untuk tujuan otentikasi.

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')

Keluaran

Scenario 1 - Jika Anda telah memasukkan kata sandi yang benar, Anda dapat menemukan output berikut -

Scenario 2 - Jika kami memasukkan kata sandi yang salah, Anda dapat menemukan output berikut -

Penjelasan

Hashlibpaket digunakan untuk menyimpan kata sandi dalam database. Dalam program ini,salt digunakan yang menambahkan urutan acak ke string kata sandi sebelum menerapkan fungsi hash.

Vignere Cipher menyertakan twist dengan algoritma Caesar Cipher yang digunakan untuk enkripsi dan dekripsi. Vignere Cipher bekerja mirip dengan algoritma Caesar Cipher dengan hanya satu perbedaan utama: Caesar Cipher menyertakan algoritma untuk satu karakter pergeseran, sedangkan Vignere Cipher menyertakan kunci dengan beberapa huruf bergeser.

Persamaan Matematika

Untuk enkripsi persamaan matematisnya adalah sebagai berikut -

$$ E_ {k} \ kiri (M {_ {i {}}} \ kanan) = \ kiri (M_ {i} + K_ {i} \ kanan) \; \; \; mod \; \; 26 $$

Untuk dekripsi persamaan matematika adalah sebagai berikut -

$$ D_ {k} \ kiri (C {_ {i {}}} \ kanan) = \ kiri (C_ {i} -K_ {i} \ kanan) \; \; \; mod \; \; 26 $$

Vignere cipher menggunakan lebih dari satu set substitusi, dan karenanya disebut juga polyalphabetic cipher. Vignere Cipher akan menggunakan kunci huruf sebagai pengganti representasi kunci numerik: Huruf A akan digunakan untuk kunci 0, huruf B untuk kunci 1 dan seterusnya. Jumlah huruf sebelum dan sesudah proses enkripsi ditunjukkan di bawah ini -

Kombinasi yang mungkin dari jumlah kemungkinan kunci berdasarkan panjang kunci Vignere diberikan sebagai berikut, yang memberikan hasil seberapa aman Algoritma Sandi Vignere -

Vignere Tableau

Tablo yang digunakan untuk sandi Vignere adalah seperti yang ditunjukkan di bawah ini -

Dalam bab ini, mari kita pahami bagaimana mengimplementasikan sandi Vignere. Pertimbangkan teksnyaThis is basic implementation of Vignere Cipher akan disandikan dan kunci yang digunakan adalah PIZZA.

Kode

Anda dapat menggunakan kode berikut untuk mengimplementasikan sandi Vignere dengan Python -

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()

Keluaran

Anda dapat mengamati keluaran berikut ketika Anda menerapkan kode yang diberikan di atas -

Kombinasi yang mungkin dari peretasan sandi Vignere hampir mustahil. Oleh karena itu, ini dianggap sebagai mode enkripsi aman.

Sandi pad satu kali adalah jenis sandi Vignere yang mencakup fitur-fitur berikut -

  • Ini adalah sandi yang tidak bisa dipecahkan.

  • Kuncinya persis sama dengan panjang pesan yang dienkripsi.

  • Kuncinya terdiri dari simbol acak.

  • Seperti namanya, kunci hanya digunakan satu kali dan tidak pernah digunakan lagi untuk pesan lain yang akan dienkripsi.

Karena itu, pesan terenkripsi akan rentan diserang oleh seorang kriptanalis. Kunci yang digunakan untuk sandi pad satu kali disebutpad, seperti yang tercetak di atas bantalan kertas.

Mengapa tidak bisa dipecahkan?

Kuncinya tidak bisa dipecahkan karena fitur-fitur berikut -

  • Kuncinya adalah selama pesan yang diberikan.

  • Kuncinya benar-benar acak dan dibuat secara otomatis.

  • Teks utama dan teks biasa dihitung sebagai modulo 10/26/2.

  • Setiap kunci harus digunakan satu kali dan dihancurkan oleh pengirim dan penerima.

  • Harus ada dua salinan kunci: satu dengan pengirim dan lainnya dengan penerima.

Enkripsi

Untuk mengenkripsi surat, pengguna perlu menulis kunci di bawah teks biasa. Huruf biasa ditempatkan di atas dan huruf kunci di sebelah kiri. Penampang yang dicapai antara dua huruf adalah teks biasa. Ini dijelaskan dalam contoh di bawah -

Dekripsi

Untuk mendekripsi sebuah surat, pengguna mengambil huruf kunci di sebelah kiri dan menemukan huruf teks sandi di baris tersebut. Huruf teks biasa ditempatkan di bagian atas kolom di mana pengguna dapat menemukan huruf teks sandi.

Python menyertakan modul implementasi hacky untuk one-time-padimplementasi sandi. Nama paket ini disebut One-Time-Pad yang mencakup alat enkripsi baris perintah yang menggunakan mekanisme enkripsi yang mirip dengan algoritma sandi pad satu kali.

Instalasi

Anda dapat menggunakan perintah berikut untuk menginstal modul ini -

pip install onetimepad

Jika Anda ingin menggunakannya dari baris perintah, jalankan perintah berikut -

onetimepad

Kode

Kode berikut membantu menghasilkan sandi pad satu kali -

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)

Keluaran

Anda dapat mengamati output berikut ketika Anda menjalankan kode yang diberikan di atas -

Note - Pesan terenkripsi sangat mudah dipecahkan jika panjang kuncinya kurang dari panjang pesan (teks biasa).

Bagaimanapun, kuncinya tidak harus acak, yang menjadikan sandi pad satu kali sebagai alat yang berharga.

Pada bab ini, mari kita bahas secara detail tentang kriptografi simetris dan asimetris.

Kriptografi Simetris

Pada tipe ini, proses enkripsi dan dekripsi menggunakan kunci yang sama. Itu juga disebut sebagaisecret key cryptography. Fitur utama dari kriptografi simetris adalah sebagai berikut -

  • Ini lebih sederhana dan lebih cepat.
  • Kedua pihak bertukar kunci dengan cara yang aman.

Kekurangan

Kelemahan utama dari kriptografi simetris adalah jika kunci bocor ke penyusup, pesan dapat dengan mudah diubah dan ini dianggap sebagai faktor risiko.

Standar Enkripsi Data (DES)

Algoritme kunci simetris paling populer adalah Data Encryption Standard (DES) dan Python menyertakan paket yang menyertakan logika di balik algoritme DES.

Instalasi

Perintah untuk instalasi paket DES pyDES dengan Python adalah -

pip install pyDES

Implementasi program sederhana dari algoritma DES adalah sebagai berikut -

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

Itu memanggil variabel padmode yang mengambil semua paket sesuai implementasi algoritma DES dan mengikuti enkripsi dan dekripsi dengan cara yang ditentukan.

Keluaran

Anda dapat melihat output berikut sebagai hasil dari kode yang diberikan di atas -

Kriptografi Asimetris

Itu juga disebut sebagai public key cryptography.Ia bekerja dengan cara kebalikan dari kriptografi simetris. Ini menyiratkan bahwa itu membutuhkan dua kunci: satu untuk enkripsi dan lainnya untuk dekripsi. Kunci publik digunakan untuk mengenkripsi dan kunci privat digunakan untuk mendekripsi.

Kekurangan

  • Karena panjang kuncinya, ini berkontribusi pada kecepatan enkripsi yang lebih rendah.
  • Manajemen kunci sangat penting.

Kode program berikut dengan Python menggambarkan cara kerja kriptografi asimetris menggunakan algoritma RSA dan implementasinya -

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))

Keluaran

Anda dapat menemukan output berikut ketika Anda menjalankan kode yang diberikan di atas -

Algoritma RSA adalah teknik enkripsi kunci publik dan dianggap sebagai cara enkripsi yang paling aman. Itu ditemukan oleh Rivest, Shamir dan Adleman pada tahun 1978 dan karenanya dinamaiRSA algoritma.

Algoritma

Algoritma RSA memiliki beberapa fitur berikut -

  • Algoritma RSA adalah eksponen populer dalam bidang berhingga di atas bilangan bulat termasuk bilangan prima.

  • Bilangan bulat yang digunakan metode ini cukup besar sehingga sulit untuk dipecahkan.

  • Ada dua set kunci dalam algoritma ini: kunci pribadi dan kunci publik.

Anda harus melalui langkah-langkah berikut untuk mengerjakan algoritma RSA -

Langkah 1: Buat modulus RSA

Prosedur awal dimulai dengan pemilihan dua bilangan prima yaitu p dan q, kemudian menghitung hasil kali N, seperti pada gambar -

N=p*q

Di sini, misalkan N menjadi angka besar yang ditentukan.

Langkah 2: Nomor Turunan (e)

Pertimbangkan bilangan e sebagai bilangan turunan yang harus lebih besar dari 1 dan kurang dari (p-1) dan (q-1). Kondisi utama adalah tidak boleh ada faktor persekutuan dari (p-1) dan (q-1) kecuali 1

Langkah 3: Kunci publik

Pasangan angka yang ditentukan n dan e membentuk kunci publik RSA dan dibuat untuk publik.

Langkah 4: Kunci Pribadi

Kunci Pribadi ddihitung dari angka p, q dan e. Hubungan matematis antara angka-angka adalah sebagai berikut -

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

Rumus di atas merupakan rumus dasar untuk Extended Euclidean Algorithm yang mengambil parameter input p dan q.

Rumus Enkripsi

Pertimbangkan pengirim yang mengirimkan pesan teks biasa kepada seseorang yang kunci publiknya adalah (n,e). Untuk mengenkripsi pesan teks biasa dalam skenario yang diberikan, gunakan sintaks berikut -

C = Pe mod n

Rumus Dekripsi

Proses dekripsi sangat mudah dan mencakup analitik untuk kalkulasi dalam pendekatan sistematis. Mempertimbangkan penerima C memiliki kunci pribadi d, modulus hasil akan dihitung sebagai -

Plaintext = Cd mod n

Pada bab ini, kita akan fokus pada langkah implementasi yang bijaksana dari algoritma RSA menggunakan Python.

Menghasilkan kunci RSA

Langkah-langkah berikut terlibat dalam menghasilkan kunci RSA -

  • Buat dua bilangan prima besar yaitu p dan q. Produk dari angka-angka ini akan dipanggiln, dimana n= p*q

  • Hasilkan bilangan acak yang relatif prima (p-1) dan (q-1). Biarkan nomor itu disebut sebagai e.

  • Hitung invers modular dari e. Pembalikan yang dihitung akan disebut sebagaid.

Algoritme untuk menghasilkan kunci RSA

Kami membutuhkan dua algoritma utama untuk menghasilkan kunci RSA menggunakan Python - Cryptomath module dan Rabin Miller module.

Modul Cryptomath

Kode sumber modul cryptomath yang mengikuti semua implementasi dasar algoritma RSA adalah sebagai berikut -

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

Modul RabinMiller

Kode sumber modul RabinMiller yang mengikuti semua implementasi dasar algoritma RSA adalah sebagai berikut -

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

Kode lengkap untuk menghasilkan kunci RSA adalah sebagai berikut -

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()

Keluaran

Kunci publik dan kunci privat dibuat dan disimpan di file masing-masing seperti yang ditunjukkan pada output berikut.

Dalam bab ini, kita akan fokus pada implementasi yang berbeda dari enkripsi cipher RSA dan fungsi yang terlibat untuk hal yang sama. Anda dapat merujuk atau menyertakan file python ini untuk mengimplementasikan implementasi algoritma cipher RSA.

Modul yang disertakan untuk algoritma enkripsi adalah sebagai berikut -

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"

Kami telah menginisialisasi nilai hash sebagai SHA-256 untuk tujuan keamanan yang lebih baik. Kami akan menggunakan fungsi untuk menghasilkan kunci baru atau sepasang kunci publik dan pribadi menggunakan kode berikut.

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)

Untuk enkripsi, fungsi berikut digunakan yang mengikuti algoritma RSA -

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

Dua parameter wajib diisi: message dan pub_keyyang mengacu pada kunci publik. Kunci publik digunakan untuk enkripsi dan kunci pribadi digunakan untuk dekripsi.

Program lengkap untuk prosedur enkripsi disebutkan di bawah -

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)

Bab ini merupakan kelanjutan dari bab sebelumnya dimana kami mengikuti langkah implementasi bijak dari enkripsi menggunakan algoritma RSA dan membahasnya secara detail.

Fungsi yang digunakan untuk mendekripsi teks sandi adalah sebagai berikut -

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

Untuk kriptografi kunci publik atau kriptografi kunci asimetris, penting untuk memelihara dua fitur penting yaitu Authentication dan Authorization.

Otorisasi

Otorisasi adalah proses untuk mengonfirmasi bahwa pengirim adalah satu-satunya orang yang telah mengirimkan pesan. Kode berikut menjelaskan ini -

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)

Autentikasi

Otentikasi dimungkinkan dengan metode verifikasi yang dijelaskan seperti di bawah ini -

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)

Tanda tangan digital diverifikasi bersama dengan detail pengirim dan penerima. Ini menambah bobot lebih untuk tujuan keamanan.

Dekripsi Cipher RSA

Anda dapat menggunakan kode berikut untuk dekripsi cipher RSA -

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)

Meretas cipher RSA dimungkinkan dengan bilangan prima kecil, tetapi dianggap tidak mungkin jika digunakan dengan bilangan besar. Alasan yang menentukan mengapa sulit untuk meretas cipher RSA adalah sebagai berikut -

  • Serangan brute force tidak akan bekerja karena ada terlalu banyak kemungkinan kunci untuk dikerjakan. Juga, ini menghabiskan banyak waktu.

  • Serangan kamus tidak akan bekerja dalam algoritma RSA karena kuncinya adalah numerik dan tidak menyertakan karakter apa pun di dalamnya.

  • Analisis frekuensi karakter sangat sulit diikuti karena satu blok terenkripsi mewakili berbagai karakter.

  • Tidak ada trik matematika khusus untuk meretas cipher RSA.

Persamaan dekripsi RSA adalah -

M = C^d mod n

Dengan bantuan bilangan prima kecil, kita dapat mencoba meretas cipher RSA dan kode sampelnya disebutkan di bawah ini -

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()

Keluaran

Kode di atas menghasilkan keluaran sebagai berikut -

ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved