195 LEA-128
195 : LEA-128
- Author: awayzer JCT
- Description: iterative approach implementation of the LEA128 block cipher
- GitHub repository
- Open in 3D viewer
- Clock: 1000000 Hz
About
The design was implemented as part of an undergraduate academic project.
This design implements the LEA-128 cryptographic algorithm according to the specifications presented in the original paper by its developers [1] and is based on the ideas and architectures proposed in [2] and [3] for an area-efficient implementation.
The design supports both encryption and decryption operations using a very simple handshake-based byte-oriented interface.
How it works
The module receives:
- a 128-bit master key (16 bytes)
- a 128-bit data block (16 bytes)
The bytes are loaded serially through ui_in using an input handshake protocol.
After all bytes are loaded:
uio_in[3]starts encryptionuio_in[4]starts decryption
The processed output block is then transmitted byte-by-byte through uo_out using an output handshake protocol.
Pin usage
| Pin | Function |
|---|---|
ui_in[7:0] |
Input byte bus |
uo_out[7:0] |
Output byte bus |
uio_in[0] |
request (input handshake) |
uio_in[1] |
request (output handshake) |
uio_in[2] |
acknowledge (output handshake) |
uio_in[3] |
Start encryption |
uio_in[4] |
Start decryption |
uio_out[6] |
valid (output handshake) |
uio_out[7] |
acknowledge (input handshake) |
The remaining bidirectional pins are unused.
Input protocol
To send a byte into the design:
- Place the byte on
ui_in. - Set
uio_in[0]high. - Wait until
uio_out[7]becomes high. - Clear
uio_in[0]. - Wait until
uio_out[7]returns low.
The first 16 transmitted bytes are interpreted as the encryption key. The next 16 transmitted bytes are interpreted as the input data block.
Output protocol
To receive the plaintext/ciphertext from the design:
- Set
uio_in[1]high. - Wait until
uio_out[6]becomes high. - Read the byte from
uo_out. - Pulse
uio_in[2]high . - after repeating for all 16 bytes, Clear
uio_in[1].
The output block is transmitted one byte at a time.
How to test
The test vector was sourced from Wikipedia. [4]
Encryption test
- Reset the design by setting
rst_nlow. - Send the following 16-byte key:
0f 1e 2d 3c 4b 5a 69 78
87 96 a5 b4 c3 d2 e1 f0
- Send the following plaintext block:
10 11 12 13 14 15 16 17
18 19 1a 1b 1c 1d 1e 1f
- Pulse
uio_in[3]high to start encryption. - Wait for the operation to complete.
- Read 16 output bytes using the output handshake.
Expected ciphertext:
9f c8 4e 35 28 c6 c6 18
55 32 c7 a7 04 64 8b fd
Decryption test
- Reset the design.
- Send the same 16-byte key.
- Send the ciphertext block shown above.
- Pulse
uio_in[4]high to start decryption. - Read 16 output bytes.
Expected plaintext:
10 11 12 13 14 15 16 17
18 19 1a 1b 1c 1d 1e 1f
References
[1] D. Hong, J.-K. Lee, D.-C. Kim, D. Kwon, K. H. Ryu, and D.-G. Lee, “LEA: A 128-Bit Block Cipher for Fast Encryption on Common Processors,” in Information Security and Cryptology – ICISC 2013, Springer, 2014.
[2] D. Lee, D.-C. Kim, D. Kwon, and H. Kim, “Efficient hardware implementation of the lightweight block encryption algorithm LEA,” Sensors, vol. 14, no. 1, pp. 975–994, Jan. 2014. doi: 10.3390/s140100975.
[3] M.-J. Sung, G.-C. Bae, and K.-W. Shin, “Implementation of Lightweight Encryption Algorithm LEA,” IDEC Journal of Integrated Circuits and Systems, vol. 2, no. 2, Jul. 2016.
[4] Wikipedia contributors, “LEA (cipher),” Wikipedia, The Free Encyclopedia. Available: https://en.wikipedia.org/wiki/LEA_(cipher). Licensed under CC BY-SA 4.0.
IO
| # | Input | Output | Bidirectional |
|---|---|---|---|
| 0 | data_in[0] | data_out[0] | req_rx |
| 1 | data_in[1] | data_out[1] | req_tx |
| 2 | data_in[2] | data_out[2] | ack_tx |
| 3 | data_in[3] | data_out[3] | enable_encryption |
| 4 | data_in[4] | data_out[4] | enable_decryption |
| 5 | data_in[5] | data_out[5] | |
| 6 | data_in[6] | data_out[6] | valid_tx |
| 7 | data_in[7] | data_out[7] | ack_rx |