Ecosyste.ms: Awesome

An open API service indexing awesome lists of open source software.

Awesome Lists | Featured Topics | Projects

https://github.com/denselance/hight-python

HIGHT block cipher implementation in Python3 based on original paper by Hong et al. Includes the encryption and decryption functions for HIGHT.
https://github.com/denselance/hight-python

cipher cryptography hight kisa python3

Last synced: 18 days ago
JSON representation

HIGHT block cipher implementation in Python3 based on original paper by Hong et al. Includes the encryption and decryption functions for HIGHT.

Host: GitHub
URL: https://github.com/denselance/hight-python
Owner: DenseLance
License: mit
Created: 2022-12-02T10:09:52.000Z (about 2 years ago)
Default Branch: main
Last Pushed: 2024-06-13T21:09:43.000Z (7 months ago)
Last Synced: 2024-06-13T23:51:40.601Z (7 months ago)
Topics: cipher, cryptography, hight, kisa, python3
Language: Python
Homepage:
Size: 12.7 KB
Stars: 0
Watchers: 1
Forks: 1
Open Issues: 0
Metadata Files:
- Readme: README.md
- License: LICENSE

Awesome Lists containing this project

README

# HIGHT
### Introduction

HIGHT is a lightweight block cipher that accepts a 64-bit plaintext and 128-bit master key. Through this Python3 implementation, we attempt to shed light on the complexities of this cipher (in ECB, CBC and CFB mode). Original paper with pseudocode and detailed explanation of the cipher can be found here. This work is inspired by ph1nx. The examples provided are cross-checked with another source, with the exception of CFB mode.

### ECB Mode

For simple encryption and decryption of 64-bit plaintext, use the base functions ```hight_encryption(P, MK)``` and ```hight_decryption(C, MK)``` respectively. All functions in *hight.py* are implemented as what the original paper details.

You would need to edit the values for the master key (MK) and plaintext (P) in the code. Here are some example values for MK, P and ciphertext (C) for ECB mode:

```python
MK = [0x88, 0xE3, 0x4F, 0x8F, 0x08, 0x17, 0x79, 0xF1, 0xE9, 0xF3, 0x94, 0x37, 0x0A, 0xD4, 0x05, 0x89]
P = [0xD7, 0x6D, 0x0D, 0x18, 0x32, 0x7E, 0xC5, 0x62]
expected_C = [0xE4, 0xBC, 0x2E, 0x31, 0x22, 0x77, 0xE4, 0xDD]
```

```python
MK = [0x29, 0x23, 0xBE, 0x84, 0xE1, 0x6C, 0xD6, 0xAE, 0x52, 0x90, 0x49, 0xF1, 0xF1, 0xBB, 0xE9, 0xEB]
P = [0xB3, 0xA6, 0xDB, 0x3C, 0x87, 0x0C, 0x3E, 0x99]
expected_C = [0x23, 0xCA, 0xD1, 0xA3, 0xCD, 0xDF, 0x7E, 0xAB]
```

```python
MK = [0x24, 0x5E, 0x0D, 0x1C, 0x06, 0xB7, 0x47, 0xDE, 0xB3, 0x12, 0x4D, 0xC8, 0x43, 0xBB, 0x8B, 0xA6]
P = [0x1F, 0x03, 0x5A, 0x7D, 0x09, 0x38, 0x25, 0x1F]
expected_C = [0x52, 0xBD, 0x91, 0xBB, 0x26, 0xF8, 0xED, 0x99]
```

```python
MK = [0x5D, 0xD4, 0xCB, 0xFC, 0x96, 0xF5, 0x45, 0x3B, 0x13, 0x0D, 0x89, 0x0A, 0x1C, 0xDB, 0xAE, 0x32]
P = [0x20, 0x9A, 0x50, 0xEE, 0x40, 0x78, 0x36, 0xFD]
expected_C = [0x95, 0x02, 0xB4, 0x6D, 0x87, 0xB4, 0x41, 0x67]
```

```python
MK = [0x12, 0x49, 0x32, 0xF6, 0x9E, 0x7D, 0x49, 0xDC, 0xAD, 0x4F, 0x14, 0xF2, 0x44, 0x40, 0x66, 0xD0]
P = [0x6B, 0xC4, 0x30, 0xB7, 0x32, 0x3B, 0xA1, 0x22]
expected_C = [0x20, 0xCB, 0xCF, 0x41, 0x65, 0x24, 0xE5, 0xA6]
```

```python
MK = [0xF6, 0x22, 0x91, 0x9D, 0xE1, 0x8B, 0x1F, 0xDA, 0xB0, 0xCA, 0x99, 0x02, 0xB9, 0x72, 0x9D, 0x49]
P = [0x2C, 0x80, 0x7E, 0xC5, 0x99, 0xD5, 0xE9, 0x80]
expected_C = [0xF3, 0x1C, 0x89, 0xE6, 0x6C, 0x4F, 0x5A, 0x6F]
```

```python
MK = [0xB2, 0xEA, 0xC9, 0xCC, 0x53, 0xBF, 0x67, 0xD6, 0xBF, 0x14, 0xD6, 0x7E, 0x2D, 0xDC, 0x8E, 0x66]
P = [0x83, 0xEF, 0x57, 0x49, 0x61, 0xFF, 0x69, 0x8F]
expected_C = [0x39, 0x21, 0xC8, 0x3B, 0xFE, 0x5E, 0x59, 0x6E]
```

```python
MK = [0x61, 0xCD, 0xD1, 0x1E, 0x9D, 0x9C, 0x16, 0x72, 0x72, 0xE6, 0x1D, 0xF0, 0x84, 0x4F, 0x4A, 0x77]
P = [0x02, 0xD7, 0xE8, 0x39, 0x2C, 0x53, 0xCB, 0xC9]
expected_C = [0x98, 0x2F, 0xD7, 0x56, 0x17, 0x44, 0x97, 0xBF]
```

```python
MK = 0x12, 0x1E, 0x33, 0x74, 0x9E, 0x0C, 0xF4, 0xD5, 0xD4, 0x9F, 0xD4, 0xA4, 0x59, 0x7E, 0x35, 0xCF
P = [0x32, 0x22, 0xF4, 0xCC, 0xCF, 0xD3, 0x90, 0x2D]
expected_C = [0xBB, 0x80, 0xF5, 0x0B, 0x35, 0x11, 0x5B, 0xA8]
```

```python
MK = [0x12, 0x1E, 0x33, 0x74, 0x9E, 0x0C, 0xF4, 0xD5, 0xD4, 0x9F, 0xD4, 0xA4, 0x59, 0x7E, 0x35, 0xCF]
P = [0x32, 0x22, 0xF4, 0xCC, 0xCF, 0xD3, 0x90, 0x2D]
expected_C = [0xBB, 0x80, 0xF5, 0x0B, 0x35, 0x11, 0x5B, 0xA8]
```

### CBC Mode

You would need to also edit the initialization vector (IV) for CBC mode. Here are some example values for MK, IV, P, C for CBC mode:

```python
MK = [0x88, 0xE3, 0x4F, 0x8F, 0x08, 0x17, 0x79, 0xF1, 0xE9, 0xF3, 0x94, 0x37, 0x0A, 0xD4, 0x05, 0x89]
IV = [0x26, 0x8D, 0x66, 0xA7, 0x35, 0xA8, 0x1A, 0x81]
P = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F]
expected_C = [0xCE, 0x15, 0x95, 0x08, 0x5A, 0x18, 0x8C, 0x28, 0xC1, 0x8D, 0x77, 0x08, 0xD9, 0xC1, 0x25, 0x86, 0x4B, 0x3D, 0xAF, 0x2B, 0xF2, 0x0D, 0x52, 0x47, 0x63, 0x4A, 0x00, 0x01, 0x2F, 0xA0, 0xE9, 0xF0, 0x44, 0x9D, 0xE2, 0xBC, 0xC1, 0x68, 0x51, 0x6C, 0x0E, 0x27, 0x45, 0xAC, 0x37, 0xC1, 0xA6, 0x74]
```

```python
MK = [0x88, 0xE3, 0x4F, 0x8F, 0x08, 0x17, 0x79, 0xF1, 0xE9, 0xF3, 0x94, 0x37, 0x0A, 0xD4, 0x05, 0x89]
IV = [0x26, 0x8D, 0x66, 0xA7, 0x35, 0xA8, 0x1A, 0x81]
P = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07]
expected_C = [0xCE, 0x15, 0x95, 0x08, 0x5A, 0x18, 0x8C, 0x28, 0xC1, 0x8D, 0x77, 0x08, 0xD9, 0xC1, 0x25, 0x86, 0x4B, 0x3D, 0xAF, 0x2B, 0xF2, 0x0D, 0x52, 0x47, 0x63, 0x4A, 0x00, 0x01, 0x2F, 0xA0, 0xE9, 0xF0, 0x44, 0x9D, 0xE2, 0xBC, 0xC1, 0x68, 0x51, 0x6C, 0x0E, 0x27, 0x45, 0xAC, 0x37, 0xC1, 0xA6, 0x74, 0x3A, 0x1E, 0xA5, 0x1E, 0xB4, 0x07, 0xD1, 0x4E]
```

```python
MK = [0x88, 0xE3, 0x4F, 0x8F, 0x08, 0x17, 0x79, 0xF1, 0xE9, 0xF3, 0x94, 0x37, 0x0A, 0xD4, 0x05, 0x89]
IV = [0x26, 0x8D, 0x66, 0xA7, 0x35, 0xA8, 0x1A, 0x81]
P = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F]
expected_C = [0xCE, 0x15, 0x95, 0x08, 0x5A, 0x18, 0x8C, 0x28, 0xC1, 0x8D, 0x77, 0x08, 0xD9, 0xC1, 0x25, 0x86, 0x4B, 0x3D, 0xAF, 0x2B, 0xF2, 0x0D, 0x52, 0x47, 0x63, 0x4A, 0x00, 0x01, 0x2F, 0xA0, 0xE9, 0xF0, 0x44, 0x9D, 0xE2, 0xBC, 0xC1, 0x68, 0x51, 0x6C, 0x0E, 0x27, 0x45, 0xAC, 0x37, 0xC1, 0xA6, 0x74, 0x3A, 0x1E, 0xA5, 0x1E, 0xB4, 0x07, 0xD1, 0x4E, 0xC8, 0xC4, 0xB4, 0x35, 0xCA, 0x05, 0xCC, 0x62]
```

### CFB Mode

```python
MK = [0x88, 0xE3, 0x4F, 0x8F, 0x08, 0x17, 0x79, 0xF1, 0xE9, 0xF3, 0x94, 0x37, 0x0A, 0xD4, 0x05, 0x89]
IV = [0x26, 0x8D, 0x66, 0xA7, 0x35, 0xA8, 0x1A, 0x81]
P = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F]
expected_C = [0x10, 0x63, 0x42, 0xC7, 0x1E, 0x80, 0xAC, 0x0C, 0xAE, 0x75, 0x86, 0x4F, 0x85, 0xDD, 0x97, 0x37, 0x20, 0xF8, 0x12, 0x3F, 0x55, 0xD1, 0x86, 0xF9, 0xFC, 0x97, 0xF4, 0xFB, 0x22, 0xB4, 0xA0, 0x60, 0x0A, 0x0C, 0xCF, 0x5B, 0xDC, 0x3E, 0xEB, 0x2B, 0x97, 0xDD, 0x79, 0x0F, 0xE4, 0x45, 0x86, 0x93]
```

```python
MK = [0x88, 0xE3, 0x4F, 0x8F, 0x08, 0x17, 0x79, 0xF1, 0xE9, 0xF3, 0x94, 0x37, 0x0A, 0xD4, 0x05, 0x89]
IV = [0x26, 0x8D, 0x66, 0xA7, 0x35, 0xA8, 0x1A, 0x81]
P = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07]
expected_C = [0x10, 0x63, 0x42, 0xC7, 0x1E, 0x80, 0xAC, 0x0C, 0xAE, 0x75, 0x86, 0x4F, 0x85, 0xDD, 0x97, 0x37, 0x20, 0xF8, 0x12, 0x3F, 0x55, 0xD1, 0x86, 0xF9, 0xFC, 0x97, 0xF4, 0xFB, 0x22, 0xB4, 0xA0, 0x60, 0x0A, 0x0C, 0xCF, 0x5B, 0xDC, 0x3E, 0xEB, 0x2B, 0x97, 0xDD, 0x79, 0x0F, 0xE4, 0x45, 0x86, 0x93, 0x19, 0x1B, 0x71, 0xF5, 0xE4, 0x10, 0xCA, 0xC8]
```

```python
MK = [0x88, 0xE3, 0x4F, 0x8F, 0x08, 0x17, 0x79, 0xF1, 0xE9, 0xF3, 0x94, 0x37, 0x0A, 0xD4, 0x05, 0x89]
IV = [0x26, 0x8D, 0x66, 0xA7, 0x35, 0xA8, 0x1A, 0x81]
P = [0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F]
expected_C = [0x10, 0x63, 0x42, 0xC7, 0x1E, 0x80, 0xAC, 0x0C, 0xAE, 0x75, 0x86, 0x4F, 0x85, 0xDD, 0x97, 0x37, 0x20, 0xF8, 0x12, 0x3F, 0x55, 0xD1, 0x86, 0xF9, 0xFC, 0x97, 0xF4, 0xFB, 0x22, 0xB4, 0xA0, 0x60, 0x0A, 0x0C, 0xCF, 0x5B, 0xDC, 0x3E, 0xEB, 0x2B, 0x97, 0xDD, 0x79, 0x0F, 0xE4, 0x45, 0x86, 0x93, 0x19, 0x1B, 0x71, 0xF5, 0xE4, 0x10, 0xCA, 0xC8, 0x71, 0x53, 0xDD, 0x78, 0xB5, 0x9A, 0x8C, 0x30]
```

### Citations

```tex
@InProceedings{10.1007/11894063_4,
author="Hong, Deukjo
and Sung, Jaechul
and Hong, Seokhie
and Lim, Jongin
and Lee, Sangjin
and Koo, Bon-Seok
and Lee, Changhoon
and Chang, Donghoon
and Lee, Jesang
and Jeong, Kitae
and Kim, Hyun
and Kim, Jongsung
and Chee, Seongtaek",
editor="Goubin, Louis
and Matsui, Mitsuru",
title="HIGHT: A New Block Cipher Suitable for Low-Resource Device",
booktitle="Cryptographic Hardware and Embedded Systems - CHES 2006",
year="2006",
publisher="Springer Berlin Heidelberg",
address="Berlin, Heidelberg",
pages="46--59",
abstract="In this paper, we propose a new block cipher HIGHT with 64-bit block length and 128-bit key length. It provides low-resource hardware implementation, which is proper to ubiquitous computing device such as a sensor in USN or a RFID tag. HIGHT does not only consist of simple operations to be ultra-light but also has enough security as a good encryption algorithm. Our hardware implementation of HIGHT requires 3048 gates on 0.25 μm technology.",
isbn="978-3-540-46561-4"
}
```