Question

Vigenère Cipher

The Vigenère Cipher was more or less completely unbreakable from its introduction sometime in the 1500s until well into the 1800s.

The key in Vigenère is a key word that is used over and over again to give a different key to the Caesar cipher for each letter of the encryption (and decryption), with 'A', in good Python form, representing a rotation of 0. (We Pythonistas start at 0, not 1!)

So if the key is ABACUS, then we encrypt:

• the first letter of our message with a Caesar cipher with a key/rotation of 0, because A is the first letter of the alphabet,
• the second letter with a key/rotation of 1 (for the 'B'),
• the third letter with a rotation of 0 (for the second 'A' of ABACUS),
• the fourth letter with a key/rotation of 2 for the 'C',
• the fifth letter with a key/rotation of 20 for the 'U',
• the sixth letter with a key/rotation of 18 for the 'S',
• and wrap back to the start of our keyword ABACUS and encrypt the seventh letter with a key/rotation of 0 for the first 'A' in ABACUS

Back in the 1800s people wanting to use this system would make use of a Vigenère square, also known as the tabula recta, shown in the middle of the Wikipedia entry for the Vigenère cipher, but we can use Python.

Vigenère part of the homework: Write vig_encrypt() and vig_decrypt() functions. Each takes two strings as inputs, with the first being the plaintext/ciphertext, and the second being the key. Both should be calling functions you wrote earlier to help make the work easier.

The key will be a string consisting only of letters, but the letters might be in upper, lower, or mixed case. Important: If the plaintext to be encrypted has non-alphabetic characters (e.g., spaces or punctuation):

• Leave the non-alphabetic character unchanged just as you did for Caesar Cipher.
• Do not advance in use of the key for non-alphabetic characters in the plaintext. So for vig_encrypt('Hi Mom!', 'LEMON'), the H is encrypted according to the L from the key, the i (after conversion to I) is encrypted according to the E in the key, and the M in the plaintext is encrypted according to the M in the key (rather than according to the O in the key).

One check on your work: vig_encrypt('ATTACKATDAWN', 'LEMON') should return the string LXFOPVEFRNHR; another is that  vig_encrypt('Hi Mom!', 'LEMON') should return the string SM YCZ!

Answer 1

from itertools import starmap, cycle

def main():
  
    plain = 'ATTACKATDAWN'
    key = 'LEMON'

    cipher = vig_encrypt(plain, key)
    plain = vig_decrypt(cipher, key)

    print("Plain text : ",plain)
    print("Encrypted Text: ",cipher)
    print("Decrypted Text:",plain)
  
  
def vig_encrypt(pt, key):

    pt = filter(str.isalpha, pt.upper())

    def encr(c, k):
     
        return chr(((ord(k) + ord(c) - 2 * ord('A')) % 26) + ord('A'))

    return ''.join(starmap(encr, zip(pt, cycle(key))))


def vig_decrypt(pt, key):

    def decr(c, k):

        return chr(((ord(c) - ord(k) - 2 * ord('A')) % 26) + ord('A'))

    return ''.join(starmap(decr, zip(pt, cycle(key))))



if __name__ == '__main__':
    main()