Python for Cryptography: Building a Caesar Cipher

Table of Contents

  1. Introduction
  2. Prerequisites
  3. Setup
  4. Overview of Caesar Cipher
  5. Implementation
  6. Encryption
  7. Decryption
  8. Conclusion

Introduction

In this tutorial, we will learn how to implement a Caesar cipher in Python. The Caesar cipher is a simple substitution cipher that replaces each letter in the plaintext with a letter a fixed number of positions down the alphabet. By the end of this tutorial, you will be able to encrypt and decrypt messages using the Caesar cipher.

Prerequisites

To follow along with this tutorial, you should have a basic understanding of the Python programming language. Knowledge of basic string manipulation and loops will be helpful.

Setup

Before we begin, make sure you have Python installed on your machine. You can download the latest version of Python from the official Python website (https://www.python.org/downloads/). Install Python following the instructions for your operating system.

Overview of Caesar Cipher

The Caesar cipher is a type of substitution cipher where each letter in the plaintext is shifted a certain number of places down or up the alphabet. For example, with a shift of 3, A would be replaced by D, B would become E, and so on. The shift value is often referred to as the “key”.

The Caesar cipher can be easily implemented in Python using the ASCII values of the characters. The ASCII value of ‘A’ is 65, ‘B’ is 66, and so on, up to ‘Z’ which is 90. Similarly, ‘a’ is 97, ‘b’ is 98, and so on, up to ‘z’ which is 122.

Implementation

Let’s implement a Caesar cipher encryption and decryption program in Python step by step. We will start by defining a function for encryption and decryption.

Encryption

  1. Start by defining a function named caesar_encrypt that takes two parameters: message and key. The message parameter represents the plaintext message to be encrypted, and the key parameter represents the number of positions to shift each character in the message.

  2. Create an empty string named encrypted_message to store the encrypted message.

  3. Iterate over each character in the message using a loop.

  4. Inside the loop, check if the current character is a lowercase letter.

    a. If it is, calculate the new ASCII value by adding the key to the current ASCII value.

    b. If the new ASCII value exceeds the ASCII value of ‘z’, wrap around to the beginning of the lowercase letters range (‘a’).

    c. Append the character with the new ASCII value to the encrypted_message string.

  5. Repeat steps 4a-4c for uppercase letters.

  6. If the current character is not a letter, simply append it to the encrypted_message string without modification.

  7. Finally, return the encrypted_message string.

Here’s the code for the caesar_encrypt function: python def caesar_encrypt(message, key): encrypted_message = "" for char in message: if char.islower(): new_ascii = (ord(char) - 97 + key) % 26 + 97 encrypted_message += chr(new_ascii) elif char.isupper(): new_ascii = (ord(char) - 65 + key) % 26 + 65 encrypted_message += chr(new_ascii) else: encrypted_message += char return encrypted_message Now, let’s test our encryption function with an example. python plaintext = "Hello, World!" key = 3 encrypted_text = caesar_encrypt(plaintext, key) print("Encrypted message:", encrypted_text) Output: Encrypted message: Khoor, Zruog! The plaintext message “Hello, World!” has been encrypted using a shift of 3, resulting in the encrypted message “Khoor, Zruog!”.

Decryption

  1. Next, let’s define a function named caesar_decrypt that takes two parameters: message and key. The message parameter represents the ciphertext to be decrypted, and the key parameter represents the number of positions the characters were shifted during encryption.

  2. Create an empty string named decrypted_message to store the decrypted message.

  3. Iterate over each character in the message using a loop.

  4. Inside the loop, check if the current character is a lowercase letter.

    a. If it is, calculate the new ASCII value by subtracting the key from the current ASCII value.

    b. If the new ASCII value is less than the ASCII value of ‘a’, wrap around to the end of the lowercase letters range (‘z’).

    c. Append the character with the new ASCII value to the decrypted_message string.

  5. Repeat steps 4a-4c for uppercase letters.

  6. If the current character is not a letter, simply append it to the decrypted_message string without modification.

  7. Finally, return the decrypted_message string.

Here’s the code for the caesar_decrypt function: python def caesar_decrypt(message, key): decrypted_message = "" for char in message: if char.islower(): new_ascii = (ord(char) - 97 - key) % 26 + 97 decrypted_message += chr(new_ascii) elif char.isupper(): new_ascii = (ord(char) - 65 - key) % 26 + 65 decrypted_message += chr(new_ascii) else: decrypted_message += char return decrypted_message Let’s test the decryption function using the previously encrypted message. python decrypted_text = caesar_decrypt(encrypted_text, key) print("Decrypted message:", decrypted_text) Output: Decrypted message: Hello, World! The encrypted message “Khoor, Zruog!” has been successfully decrypted back to the original plaintext message “Hello, World!”.

Conclusion

In this tutorial, we learned how to implement a Caesar cipher encryption and decryption program in Python. We covered the basic concepts of the Caesar cipher, how to encrypt and decrypt messages using the cipher, and implemented the encryption and decryption functions step by step. You can now use this knowledge to build your own encryption tools or explore more advanced encryption algorithms. Keep in mind that the Caesar cipher is a relatively weak encryption method and should not be used for sensitive data.

Published:

Related Articles