import sys

import numpy as np

from collections import Counter

from math import gcd

from BitVector import $*$

if len$($sys$.$argv$)!=3$:

sys$.$exit$(\text{'}\text{'}\text{'}$Needs two command$-$line arguments, one for the message file and the other for the encrypted output file'$\text{'}\text{'})$

def kasiski$\_$examination$($ciphertext$)$:

distances $=[]$

for i in range$($len$($ciphertext$)-3)$:

substring $=$ ciphertext$[$i:i$+3]$

occurrences $=[$pos for pos, char in enumerate$($ciphertext$)$ if ciphertext$[$pos:pos$+3]==$ substring$]$

if len$($occurrences$)>1$:

distances.extend$([$occurrences$[$j$]-$occurrences$[$j$-1]$ for j in range$(1,$ len$($occurrences$))])$

return distances

def find$\_$key$\_$length$($distances$)$:

distance$\_$counter $=$ Counter$($distances$)$

possible$\_$lengths $=[$length for length, count in distance$\_$counter.items$()$ if count $>1]$

if not possible$\_$lengths:

return None

key$\_$length $=$ gcd$(*$possible$\_$lengths$)$

return key$\_$length

def guess$\_$key$\_$part$($block$,$ most$\_$frequent$\_$char$)$:

xor$\_$value $=$ int$($most$\_$frequent$\_$char, $2)^$ int$(\text{'}00100000\text{'},2)$

temp$\_$key$\_$part $=$ bin$($xor$\_$value$)[2$:$].$zfill$($len$($most$\_$frequent$\_$char$))$

return temp$\_$key$\_$part

def find$\_$most$\_$frequent$($vigenere$\_$row$)$:

frequency$\_$dict $=\{\}$

for char in vigenere$\_$row:

frequency$\_$dict$[$char$]=$ frequency$\_$dict.get$($char$,0)+1$

return max$($frequency$\_$dict, key$=$frequency$\_$dict.get$)$

PassPhrase $=$ "I want to learn cryptograph and network security"

BLOCKSIZE $=64$

numbytes $=$ BLOCKSIZE $//8$

bv$\_$iv $=$ BitVector$($bitlist$=[0]*$ BLOCKSIZE$)$

for i in range$(0,$ len$($PassPhrase$)//$ numbytes$)$:

textstr $=$ PassPhrase$[$i $*$ numbytes:$($i $+1)*$ numbytes$]$

bv$\_$iv $^=$ BitVector$($textstring$=$textstr$)$

with open$($sys$.$argv$[1],\text{'}$r$\text{'})$ as inFile:

cipherbin $=$ BitVector$($hexstring$=$inFile.readline$().$rstrip$(\text{'}$

$\text{'}))$

# Determine key length using Kasiski examination

distances $=$ kasiski$\_$examination$($cipherbin$.$get$\_$bitvector$\_$in$\_$hex$())$

key$\_$length $=$ find$\_$key$\_$length$($distances$)$

# Print the correct key length

print$("$Determined Key Length:", key$\_$length$)$

# Frequency analysis to find key

cipherBlockList $=[]$

for i in range$(0,$ len$($cipherbin$),$ BLOCKSIZE$)$:

block $=$ BitVector$($bitstring$=$cipherbin$[$i: i $+$ BLOCKSIZE$])$

cipherBlockList.append$($block$)$

cipherBlockList.insert$(0,$ bv$\_$iv$)$

plainXorKey $=[]$

for i in range$(1,$ len$($cipherBlockList$))$:

xor$\_$result $=$ cipherBlockList$[$i$]^$ cipherBlockList$[$i $-1]$

plainXorKey.append$($xor$\_$result$)$

plainXorKey $=$ list$($reversed$($plainXorKey$))$

NUM$\_$ROWS $=$ BLOCKSIZE $//8$

table $=[[]$ for $\_$ in range$($NUM$\_$ROWS$)]$

for xor$\_$value in reversed$($plainXorKey$)$:

xor$\_$str $=$ str$($xor$\_$value$)$

for k in range$(0,$ len$($xor$\_$str$),$ numbytes$)$:

table$[$k $//8].$append$($xor$\_$str$[$k: k $+$ numbytes$])$

decryption$\_$key $=""$

for row in table:

most$\_$frequent$\_$char $=$ find$\_$most$\_$frequent$($row$)$

temp$\_$key$\_$part $=$ guess$\_$key$\_$part$($row$,$ most$\_$frequent$\_$char$)$

decryption$\_$key $+=$ temp$\_$key$\_$part

# Convert binary key to ASCII string

ascii$\_$key $=\text{'}\text{'}.$join$([$chr$($int$($decryption$\_$key$[$i:i$+8],2))$ for i in range$(0,$ len$($decryption$\_$key$),8)])$

# Write the key to the "key.txt$"$ file

with open$(\text{'}$key$.$txt$\text{'},\text{'}$w$\text{'})$ as key$\_$file:

key$\_$file.write$($ascii$\_$key$)$

# Decrypt using the found key

key$\_$bv $=$ BitVector$($bitstring$=$decryption$\_$key$)$

msg$\_$decrypted$\_$bv $=$ BitVector$($size$=0)$

previous$\_$decrypted$\_$block $=$ bv$\_$iv

for i in range$(0,$ len$($cipherbin$)//$ BLOCKSIZE$)$:

bv $=$ cipherbin$[$i $*$ BLOCKSIZE:$($i $+1)*$ BLOCKSIZE$]$

temp $=$ bv$.$deep$\_$copy$()$

bv $^=$ previous$\_$decrypted$\_$block

previous$\_$decrypted$\_$block $=$ temp

bv $^=$ key$\_$bv

msg$\_$decrypted$\_$bv $+=$ bv

outputtext $=$ msg$\_$decrypted$\_$bv$.$get$\_$text$\_$from$\_$bitvector$()$

with open$($sys$.$argv$[2],\text{'}$w$\text{'},$ encoding$=$'latin$-1\text{'},$ errors$=$'replace'$)$ as FILEOUT:

FILEOUT.write$($outputtext$)$

print$("$Key has been written to 'key.txt$\text{'}$ file."$)$ explain this code with proper example each line