I have implemented the diffie$-$hellman key exchange, Vigenere cipher, and the Playfair cipher algorithms in python and they all worked well. Now I need to combine them to make a three layer security program but I am having issues with that. Can someone help connocting the codes together?

Here is th diffie$-$hellman code:

#Following the steps of Diffie$-$Hellman Key Exchange Algorithm

#Step $1$: All users agree on glodabl $($prime$)$ parameters q and g

q $=$ int$($input$("$

Please enter first prime number $($q$)$: $"))$

g $=$ int$($input$("$

Please enter second prime number $($g$)$: $"))$

#Step $2$: Each user selects random secret key

sender$\_$key $=$ int$($input$("$

enter sender public key $($must be greater than $"+$ str$($g$)+")$: $"))$

receiver$\_$key $=$ int$($input$("$

enter receiver public key $($must be greater than $"+$ str$($g$)+")$: $"))$

#Step $3$: Each user computes respective public keys $($Ys $=$ g$^$Xs mod q$)$ and $($Yr $=$ g$^$Xr mod q$)$

senderPublic $=$ g$**$sender$\_$key $\%$ q

receiverPublic $=$ g$**$receiver$\_$key $\%$ q

#Step $4$: Compute shared session key $($Ksr $=$ g$^$XsXr mod q$)$

#$($Ys$^$Xr mod q$)$ which receiver can compute, and $($Yr$^$Xs mod q$)$ which sender can compute

senderShared $=$ receiverPublic$**$sender$\_$key $\%$ q

receiverShared $=$ senderPublic$**$receiver$\_$key $\%$ q

print$("$

The public key $($Sender$)$: $"+$ str$($senderPublic$))$

print$("$

The public key $($Receiver$)$: $"+$ str$($receiverPublic$))$

print$("$

The shared key $($Sender$)$: $"+$ str$($senderShared$))$

print$("$

The shared key $($Receiver$)$: $"+$ str$($receiverShared$))$

print$("$

$")$

Here is the vigenere code:

alphabet $=$ "abcdefghijklmnopqrstuvwxyz $"$

letter$\_$to$\_$index $=$ dict$($zip$($alphabet$,$ range$($len$($alphabet$))))$

index$\_$to$\_$letter $=$ dict$($zip$($range$($len$($alphabet$)),$ alphabet$))$

# For the decryption proccess $($add$)$ the key letter's index to the message letter's index

def encrypt$($message$,$ key$)$:

encrypted $=""$

split$\_$message $=[$

message$[$i : i $+$ len$($key$)]$ for i in range$(0,$ len$($message$),$ len$($key$))$

$]$

for each$\_$split in split$\_$message:

i $=0$

for letter in each$\_$split:

number $=($letter$\_$to$\_$index$[$letter$]+$ letter$\_$to$\_$index$[$key$[$i$]])\%$ len$($alphabet$)$

encrypted $+=$ index$\_$to$\_$letter$[$number$]$

i $+=1$

return encrypted

# For the decryption proccess $($subtract$)$ the key letter's index from the message letter's index

def decrypt$($encrypted$\_$message, key$)$:

decrypted $=""$

split$\_$message $=[$

encrypted$\_$message$[$i : i $+$ len$($key$)]$ for i in range$(0,$ len$($encrypted$\_$message$),$ len$($key$))$

$]$

for each$\_$split in split$\_$message:

i $=0$

for letter in each$\_$split:

number $=($letter$\_$to$\_$index$[$letter$]-$ letter$\_$to$\_$index$[$key$[$i$]])\%$ len$($alphabet$)$

decrypted $+=$ index$\_$to$\_$letter$[$number$]$

i $+=1$

return decrypted

def main$()$:

message $=$ "i love information security"

key $=$ "subject"

encrypted$\_$message $=$ encrypt$($message$,$ key$)$

decrypted$\_$message $=$ decrypt$($encrypted$\_$message, key$)$

print$("$

Original message: $"+$ message$)$

print$("$

Encrypted message: $"+$ encrypted$\_$message$)$

print$("$

Decrypted message: $"+$ decrypted$\_$message$)$

print$("$

$")$

main$()$

And here is the playfair code:

import string

import itertools

def chunker$($seq$,$ size$)$:

it $=$ iter$($seq$)$

while True:

chunk $=$ tuple$($itertools$.$islice$($it$,$ size$))$

if not chunk:

return

yield chunk

def prepare$\_$input$($dirty$)$:

dirty $="".$join$([$c$.$upper$()$ for c in dirty if c in string.ascii$\_$letters$])$

clean $=""$

if len$($dirty$)<2$:

return dirty

for i in range$($len$($dirty$)-1)$:

clean $+=$ dirty$[$i$]$

if dirty$[$i$]==$ dirty$[$i $+1]$:

clean $+="$X$"$

clean $+=$ dirty$[-1]$

if len$($clean$)$ & $1$:

clean $+="$X$"$

return clean

def generate$\_$table$($key$)$:

alphabet $=$ "ABCDEFGHIKLMNOPQRSTUVWXYZ"

table $=[]$

for char in key.upper$()$:

if char not in table and char in alphabet:

table.append$($char$)$

for char in alphabet:

if char not in table:

table.append$($char$)$

return table

def encode$($plaintext$,$ key$)$:

table $=$ generate$\_$table$($key$)$

plaintext $=$ prepare$\_$input$($plaintext$)$

ciphertext $=""$

for char$1,$ char$2$ in chunker$($plaintext$,2)$:

row$1,$ col$1=$ divmod$($table$.$index$($char$1),5)$

row$2,$ col$2=$ divmod$($table$.$index$($char$2),5)$

if row$1==$ row$2$:

ciphertext $+=$ table$[$row$1*5+($col$1+1)\%5]$

ciphertext $+=$ table$[$row$2*5+($col$2+1)\%5]$

elif col$1==$ col$2$:

ciphertext $+=$ table$[(($row$1+1)\%5)*5+$ col$1]$

ciphertext $+=$ table$[(($row$2+1)\%5)*5+$ col$2]$

else:

ciphertext $+=$ table$[$row$1*5+$ col$2]$

ciphertext $+=$ table$[$row$2*5+$ col$1]$

return ciphertext