# Caesar Cipher in Python

The Caesar Cipher is a simple encryption technique where each letter in a message is replaced by a letter some fixed number of positions down the alphabet. Here’s an implementation of the Caesar Cipher in Python:

```def caesar_cipher(message, key):
"""Encrypts the given message using the Caesar Cipher technique"""
encrypted_message = ""
for letter in message:
if letter.isalpha():  # if the character is a letter
if letter.isupper():  # if the character is uppercase
encrypted_message += chr((ord(letter) + key - 65) % 26 + 65)
else:  # if the character is lowercase
encrypted_message += chr((ord(letter) + key - 97) % 26 + 97)
else:  # if the character is not a letter
encrypted_message += letter
return encrypted_message
```

In this implementation, `message` is the string to be encrypted and `key` is the number of positions down the alphabet each letter should be shifted. The function first initializes an empty string called `encrypted_message` to store the encrypted message.

The function then iterates over each character in the `message` string. If the character is a letter, it checks if it is uppercase or lowercase using the `isupper()` and `islower()` methods, respectively. It then uses the `ord()` function to convert the character to its ASCII code, adds the `key` value to the code, and then uses the `chr()` function to convert the new code back to a character. The `% 26` is used to wrap around the alphabet if the shifted value goes beyond “z” or “Z”.

If the character is not a letter, the function simply adds the character to the `encrypted_message` string as is.

Finally, the function returns the `encrypted_message` string.

### Feature of Caesar Cipher Algorithm:

The Caesar Cipher algorithm is a simple encryption technique that involves shifting each letter in a message by a fixed number of positions down the alphabet. Some features of the Caesar Cipher algorithm include:

1. Shift amount: The Caesar Cipher algorithm uses a fixed shift amount to encrypt the message. This shift amount is usually a small integer value between 1 and 25.
2. Encryption and Decryption: The Caesar Cipher algorithm can be used for both encryption and decryption. To decrypt a message encrypted with the Caesar Cipher, one simply needs to shift each letter in the encrypted message backwards by the same shift amount used during encryption.
3. Symmetric encryption: The Caesar Cipher algorithm is a symmetric encryption technique, meaning that the same key is used for both encryption and decryption.
4. Limited security: The Caesar Cipher algorithm is a very basic encryption technique and can be easily broken by a knowledgeable attacker. One simple way to break the Caesar Cipher is through brute-force attack, where the attacker tries all possible shift amounts until the correct one is found.
5. Letter substitution: The Caesar Cipher algorithm replaces each letter in the message with a letter a fixed number of positions down the alphabet. This means that the same letter in the message will always be replaced with the same letter in the encrypted message, making the encryption predictable and vulnerable to statistical analysis.
6. Speed and simplicity: The Caesar Cipher algorithm is a fast and simple encryption technique that requires minimal computation and is easy to implement in software. This makes it a popular choice for simple encryption tasks, especially in situations where security is not a major concern.

### How to decrypt?:

To decrypt a message that has been encrypted using the Caesar Cipher algorithm, you simply need to shift each letter in the encrypted message backwards by the same shift amount used during encryption. Here’s an implementation of the decryption function in Python:

```def caesar_decrypt(encrypted_message, key):
"""Decrypts the given message using the Caesar Cipher technique"""
decrypted_message = ""
for letter in encrypted_message:
if letter.isalpha():  # if the character is a letter
if letter.isupper():  # if the character is uppercase
decrypted_message += chr((ord(letter) - key - 65) % 26 + 65)
else:  # if the character is lowercase
decrypted_message += chr((ord(letter) - key - 97) % 26 + 97)
else:  # if the character is not a letter
decrypted_message += letter
return decrypted_message
```

In this implementation, `encrypted_message` is the string to be decrypted and `key` is the number of positions down the alphabet each letter was shifted during encryption. The function initializes an empty string called `decrypted_message` to store the decrypted message.

The function then iterates over each character in the `encrypted_message` string. If the character is a letter, it checks if it is uppercase or lowercase using the `isupper()` and `islower()` methods, respectively. It then uses the `ord()` function to convert the character to its ASCII code, subtracts the `key` value from the code, and then uses the `chr()` function to convert the new code back to a character. The `% 26` is used to wrap around the alphabet if the shifted value goes beyond “z” or “Z”.

If the character is not a letter, the function simply adds the character to the `decrypted_message` string as is.

Finally, the function returns the `decrypted_message` string, which should be the original message that was encrypted using the Caesar Cipher algorithm.

### Breach in Caesar Cipher Algorithm:

The Caesar Cipher algorithm is a very basic encryption technique and can be easily broken by a knowledgeable attacker. Some common attacks on the Caesar Cipher include:

1. Brute-force attack: The brute-force attack involves trying all possible shift amounts until the correct one is found. Since there are only 25 possible shift amounts in the Caesar Cipher, this attack is relatively simple to carry out. Once the attacker finds the correct shift amount, they can easily decrypt the message.
2. Frequency analysis: The Caesar Cipher replaces each letter in the message with a letter a fixed number of positions down the alphabet. This means that the same letter in the message will always be replaced with the same letter in the encrypted message, making the encryption vulnerable to statistical analysis. If the attacker has a large enough sample of the encrypted message, they can perform frequency analysis to identify common patterns and deduce the shift amount used in the encryption.
3. Known plaintext attack: The known plaintext attack involves using knowledge of the plaintext to deduce the key used in the encryption. If the attacker knows a portion of the plaintext and the corresponding encrypted text, they can calculate the shift amount used in the encryption and use it to decrypt the rest of the message.
4. Ciphertext-only attack: In a ciphertext-only attack, the attacker has access only to the encrypted message and no other information. While the Caesar Cipher can be vulnerable to frequency analysis, if the attacker has access to only a short ciphertext message, they may not have enough information to determine the shift amount used in the encryption.

Overall, the Caesar Cipher is not a very secure encryption technique and should not be used to protect sensitive information. More advanced encryption techniques, such as the Advanced Encryption Standard (AES), are designed to be more secure and resistant to attacks.

### Transposition Cipher:

A Transposition Cipher is a type of encryption algorithm that rearranges the characters in a message to create an encrypted message. In a Transposition Cipher, the characters themselves are not replaced or substituted, but rather their positions in the message are changed. The original order of the characters can only be restored by someone who knows the secret key used to encrypt the message.

There are many different types of Transposition Cipher algorithms, but one common approach is the columnar Transposition Cipher. In this algorithm, the message is written out in rows of a fixed length, and then the columns are transposed. For example, if the message is “HELLO WORLD” and the row length is 4, the message would be written as:

```HEL
LO
WOR
LD
```

The columns are then transposed to create the encrypted message:

```HLOWELDR
```

To decrypt the message, the columns are transposed back to their original order, and the rows are read out in order:

```HLO
WEL
LDR
O
```

which gives the original message: “HELLO WORLD”.

The security of a Transposition Cipher depends on the length of the message and the complexity of the key used to encrypt it. Longer messages and more complex keys are more difficult to decrypt through brute-force methods. However, Transposition Ciphers are generally not considered as secure as modern encryption algorithms like AES or RSA.