In cryptography, block cyphers are very important in the designing of many cryptographic algorithms and are widely used to encrypt the bulk of data in chunks. By chunks, it means that the cypher takes a fixed size of the plaintext in the encryption process and generates a fixed size ciphertext using a fixed-length key. An algorithm’s strength is determined by its key length.

The Simplified **International Data Encryption Algorithm (IDEA)** is a **symmetric key block cypher** that:

- uses a fixed-length plaintext of
**16 bits**and - encrypts them in
**4 chunks of 4 bits**each - to produce
**16 bits ciphertext**. - The length of the key used is
**32 bits**. - The key is also divided into 8 blocks of 4 bits each.

This algorithm involves a series of 4 identical complete rounds and 1 half-round. Each complete round involves a series of 14 steps that includes operations like:

- Bitwise XOR
- Addition modulo
- Multiplication modulo +1

After 4 complete rounds, the final “half-round” consists of only first 4 out of the 14 steps previously used in the full-rounds. To perform these rounds, each binary notation must be converted to its equivalent decimal notation, perform the operation and the result obtained should be converted back to the binary representation for the final result of that particular step.

**Key Schedule:** 6 subkeys of 4 bits out of the 8 subkeys are used in each complete round, while 4 are used in the half-round. So, 4.5 rounds require 28 subkeys. The given key, ‘K’, directly gives the first 8 subkeys. By rotating the main key left by 6 bits between each group of 8, further groups of 8 subkeys are created, implying less than one rotation per round for the key (3 rotations).

K1 | K2 | K3 | K4 | K5 | K6 | |
---|---|---|---|---|---|---|

Round 1 | 1101 | 1100 | 0110 | 1111 | 0011 | 1111 |

Round 2 | 0101 | 1001* |
0001 | 1011 | 1100 | 1111 |

Round 3 | 1101 | 0110 | 0111 | 0111* |
1111 | 0011 |

Round 4 | 1111 | 0101 | 1001 | 1101 | 1100 | 0110* |

Round 4.5 | 1111 | 1101 | 0110 | 0111 |

* denotes a shift of bits

Notations used in the 14 steps:

Symbol | Operation |
---|---|

* | Multiplication modulo +1 |

+ | Addition modulo |

^ | Bitwise XOR |

The 16-bit plaintext can be represented as **X1 || X2 || X3 || X4**, each of size 4 bits. The 32-bit key is broken into 8 subkeys denoted as K1 || K2 || K3 || K4 || K5 || K6 || K7 || K8, again of size 4 bits each. Each round of 14 steps uses the three algebraic operation-Addition modulo (2^4), Multiplication modulo (2^4)+1 and Bitwise XOR. The steps involved are as follows:

- X1 * K1
- X2 + K2
- X3 + K3
- X4 * K4
- Step 1 ^ Step 3
- Step 2 ^ Step 4
- Step 5 * K5
- Step 6 + Step 7
- Step 8 * K6
- Step 7 + Step 9
- Step 1 ^ Step 9
- Step 3 ^ Step 9
- Step 2 ^ Step 10
- Step 4 ^ Step 10

The input to the next round is Step 11 || Step 13 || Step 12 || Step 14, which becomes X1 || X2 || X3 || X4. This swap between 12 and 13 takes place after each complete round, except the last complete round (4th round), where the input to the final half round is Step 11 || Step 12 || Step 13 || Step 14.

After last complete round, the half-round is as follows:

- X1 * K1
- X2 + K2
- X3 + K3
- X4 * K4

The final output is obtained by concatenating the blocks.

**Example:**

Key:1101 1100 0110 1111 0011 1111 0101 1001Plaintext:1001 1100 1010 1100Ciphertext:1011 1011 0100 1011

**Explanation:**

The explanantion is only for 1st complete round (remaining can be implemented similarly) and the last half round.

**Round 1:**- From the plaintext:
**X1 – 1001, X2 – 1100, X3 – 1010, X4 – 1100** - From the table above:
**K1 – 1101, K2 – 1100, K3 – 0110, K4 – 1111, K5 – 0011, K6 – 1111** -
(1001(9) * 1101(13))(mod 17) = 1111(15) (1100(12) + 1100(12))(mod 16) = 1000(8) (1010(10) + 0110(6))(mod 16) = 0000(0) (1100(12) * 1111(15))(mod 17) = 1010(10) (1111(15) ^ 0000(0)) = 1111(15) (1000(8) ^ 1010(10)) = 0010(2) (1111(15) * 0011(3))(mod 17) = 1011(11) (0010(2) + 1011(11))(mod 16) = 1101(13) (1101(13) * 1111(15))(mod 17) = 1000(8) (1011(11) + 1000(8))(mod 16) = 0011(3) (1000(8) ^ 1111(15)) = 0111(7) (1000(8) ^ 0000(0)) = 1000(8) (0011(3) ^ 1000(8)) = 1011(11) (0011(3) ^ 1010(10)) = 1001(9)

**Round 1 Output**: 0111 1011 1000 1001 (Step 12 and Step 13 results are interchanged)

- From the plaintext:
**Round 2:**- From Round 1 output:
**X1 – 0111, X2 – 1011, X3 – 1000, X4 – 1001** - From the table above:
**K1 – 0101, K2 – 1001, K3 – 0001, K4 – 1011, K5 – 1100, K6 – 1111** **Round 2 Output**: 0110 0110 1110 1100

- From Round 1 output:
**Round 3:**- From Round 2 Output:
**X1 – 0110, X2 – 0110, X3 – 1110, X4 – 1100** - From the table above:
**K1 – 1101, K2 – 0110, K3 – 0111, K4 – 0111, K5 – 1111, K6 – 0011** **Round 3 Output**: 0100 1110 1011 0010

- From Round 2 Output:
**Round 4:**- From Round 3 Output:
**X1 – 0100, X2 – 1110, X3 – 1011, X4 – 0010** - From the table above:
**K1 – 1111, K2 – 0101, K3 – 1001, K4 – 1101, K5 – 1100, K6 – 0110** **Round 4 Output**: 0011 1110 1110 0100 (Step 12 and Step 13 results are not interchanged)

- From Round 3 Output:
**Round 4.5:**- From Round 4 Output:
**X1 – 0011, X2 – 1110, X3 – 1110, X4 – 0100** - From the table above:
**K1 – 1111, K2 – 1101, K3 – 0110, K4 – 0111** -
(0011(3) * 1111(15))(mod 17) = 1011(11) (1110(14) + 1101(13))(mod 16) = 1011(11) (1110(14) + 0110(6))(mod 16) = 0100(4) (0100(4) * 0111(7))(mod 17) = 1011(11)

- From Round 4 Output:
**Final Ciphertext**is**1011 1011 0100 1011**.

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.

## Recommended Posts:

- ElGamal Encryption Algorithm
- Knapsack Encryption Algorithm in Cryptography
- Data encryption standard (DES) | Set 1
- Strength of Data encryption standard (DES)
- Rail Fence Cipher - Encryption and Decryption
- XOR Encryption by Shifting Plaintext
- Image encryption using cellular automata
- Evolution of Malwares from Encryption to Metamorphism
- Encryption, Its Algorithms And Its Future
- Difference Between Symmetric and Asymmetric Key Encryption
- What is RC4 Encryption?
- Symmetric Encryption Cryptography in Java
- Asymmetric Encryption Cryptography in Java
- Fernet (symmetric encryption) using Cryptography module in Python
- Difference between Data Scientist, Data Engineer, Data Analyst
- Why import star in Python is a bad idea
- Step by Step guide to install Intellij Idea
- Move To Front Data Transform Algorithm
- Shannon-Fano Algorithm for Data Compression
- Difference between Data Warehousing and Data Mining

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.