ASCON Cipher with GolangASCON [2,7] was designed by Christoph Dobraunig, Maria Eichlseder, Florian Mendel and Martin Schläffer from Graz University of Technology, Infineon Technologies, and Radboud University. It is both a light-weight hashing and encryption method. ASCON uses a single lightweight permutation with a Sponge-based modes of operation and an SPN (substitution–permutation network) permutation. Overall it has an easy method of implementing within hardware (2.6 gate equivalents) and software. A 5-bit S-box (as used in Keccak’s S-box core) is used to enable a light weight approach and it has no known side-channel attacks. It can also achieve high throughputs such as throughputs of between 4.9 and 7.3 Gbps. It stores its current state with 320 bits. And, so, in Feb 2023, NIST annouced the ASCON was the winner, and would move to standardization. The three main methods are Ascon128, Ascon128a and Ascon80pq. Ascon128 and Ascon128a have a 128-bit encryption key, while Ascon80pq has a 160-bit key. |
Outline
Since 2016, NIST has been assessing light-weight encryption methods, and, in 2022, NIST published the final 10: ASCON, Elephant, GIFT-COFB, Grain128-AEAD, ISAP, Photon-Beetle, Romulus, Sparkle, TinyJambu, and Xoodyak (Table 1). A particular focus is on the security of the methods, along with their performance on low-cost FPGAs/embedded processes and their robustness against side-channel attacks.
Table 1: Specifications of the NIST LWC finalist algorithms [3]
Generally, ASCON does well in most tests and is a good all-rounder. Itwas designed by Christoph Dobraunig, Maria Eichlseder, Florian Mendel and Martin Schläffer from Graz University of Technology, Infineon Technologies, and Radboud University. It is both a lightweight hashing and encryption method.
ASCON uses a single lightweight permutation with Sponge-based modes of operation and an SPN (substitution–permutation network) permutation. Overall it has an easy method of implementing within hardware (2.6 gate equivalents) and software. A 5-bit S-box (as used in Keccak’s S-box core) is used to enable a light-weight approach and it has no known side-channel attacks. It can also achieve high throughputs such as throughputs of between 4.9 and 7.3 Gbps. It stores its current state with 320 bits.
Evaluation (Performance)
The current set of benchmarks includes running on an Arduino Uno R3 (AVR ARmega 328P — Figure 1), Arduino Nano Every (AVR ARmega 4809), Arduino MKR Zero (ARM Cortex M10+) and Arduino Nano 33 BLE (ARM Cortex M4F). These are just 8-bit processors and fit into an Arduino board. Along with their processing limitations, they are also limited in their memory footprint (to run code and also to store it). The lightweight cryptography method must thus overcome these limitations and still, be secure and provide a good performance level. Running AES in block modes on these devices is often not possible, as there are insufficient resources. Overall we use a benchmark for encryption — with AEAD (Authenticated Encryption with Additional Data) and for hashing. With AEAD we add extra information — such as the session ID — into the encryption process. This type of method can bind the encryption to a specific stream.
ARM Cortex M3
In Table 2 [5], we see a sample run using an Arduino Due with an ARM Cortex M3 running at 84MHz. The tests are taken in comparison with the ChaCha20 stream cipher and defined for AEAD, and where the higher the value, the better the performance. We can see that Sparkle, Xoodyak and ASCON are the fastest of all. Sparkle has a 100% improvement, and Xoodyak gives a 60% increase in speed over ChaCha20. Elephant, ISAP and PHOTON-Beetle have the worst performance for encryption (with around 1/20th of the speed of ChaCha20).
Table 2: Arduino Due with an ARM Cortex M3 running at 84MHz for encryption against ChaCha20 [5]
Not all of the finalists can do hash functions. Table 3 outlines these.
Table 3: Arduino Due with an ARM Cortex M3 running at 84MHz for hashing against BLAKE2s [5]
Again, we see Sparkle and Xoodyak in the lead, with Sparkle actually faster in the test than BLAKE2s, and Xoodyak just a little bit slower. ASCON has a weaker performance, and PHOTON-Beetle is relatively slow. For all the tests, the ranking for authenticated encryption is (and where the higher the rank, the better):
and for hashing Sparkle and Xoodyak are ranked the same:
Uno Nano performance
For AEAD on Uno Nano Every [6], the benchmark is against AES GCM. We can see in Table 4, that Sparkle is 4.7 times faster than AES GCM for 128-bit data sizes, and Xoodyak comes in second with a 3.3 times improvement over AES GCM. When it comes to 8-bit data sizes, TinyJambu is actually the fastest, but where Sparkle and Xoodyak still perform well. PHOTON-Beetle, Grain128 and ISAP do not do well and only slightly improves on AES GCM. In fact, Grain128 and ISAP are actually slower than AES GCM.
Table 4: Uno Nano for AEAD against AES GCM and showing cycles [6] (showing fastest of the method)
And so for AEAD (performance):
1. Sparkle. 2. Xoodyak. 3. ASCON. 4. GIFT-COFB. 5. Elephant. 6. Romulus. 7. Tiny Jambu. 8. PHOTON-Beetle. 9. Grain128. 10. ISAP.
For hashing on an Uno Nano Every [6], Table 5 shows a similar performance level as the ARM Cortex M3 assessment. In this case, the benchmark hash is SHA-256, and we can see that it takes Sparkle twice as many cycles for a 128-bit hash and 2.9 times for Xoodyak. PHOTON-Beetle is way behind with a 128-bit hash and which is 17.4 times slower than SHA-256. That said, though, PHOTON-Beetle could be more focused on reducing power consumption rather than speed. GIMLI and SKINNY are included to show a comparison with well-designed methods in lightweight hashing. It can be seen that every method beats SKINNY, but only Sparkle and Xoodyak beat GIMLI.
Table 5: Uno Nano for hashing against SHA-256 and showing cycles [6] (showing fastest of the method for hashing)
And so for hashing (performance):
1. Sparkle. 2. Xoodyak. 3. ASCON. 4. PHOTON-Beetle.
Evaluation (Energy)
The key evaluators for the best method include their overall security; the their general performance (as measured with the number of cycles taken to conduct an operation); the gate count; the chip size; and energy consumption. When it comes to energy consumption and hardware requirements, Elsadek et al [4] performed a review of the 10 contenders.
In terms of the size of each implementation, we see that TinyJambu and Grain128 have the smallest footprint, while Sparkle has by far the largest footprint. In terms of gate equivalent (GE), TinyJambu requires 3,600 GEs, while Sparkle needs 39,500:
The energy efficiency is then defined as:
\(Energy efficiency (bit/J) = \frac{Throughput (bits/sec)}{Power (J/sec)}\)
and where we measure the bits per Joule. Figure 2 outlines the average energy efficiency, and where TinyJambu, Xoodyak and ASCON do well for energy, while ISAP, Elephant and Grain128-AEAD were poorest.
Figure 2: Average energy efficiency [1]
Coding
An outline of the Python code is [1]:
package main import ( "crypto/cipher" "crypto/rand" "encoding/hex" "fmt" "os" "github.com/cloudflare/circl/cipher/ascon" ) func main() { m := "Hello" mode := "Ascon128" keySize := 16 argCount := len(os.Args[1:]) if argCount > 0 { m = string(os.Args[1]) } if argCount > 1 { mode = string(os.Args[2]) } message := []byte(m) //for _, mode := range []ascon.Mode{ascon.Ascon128, ascon.Ascon128a, ascon.Ascon80pq} { // key, _ := hex.DecodeString("000102030405060708090A0B0C0D0E0F") // nonce, _ := hex.DecodeString("000102030405060708090A0B0C0D0E0F") ad, _ := hex.DecodeString("") asconMode := ascon.Ascon128 if mode == "Ascon128" { asconMode = ascon.Ascon128 keySize = 16 } if mode == "Ascon128" { asconMode = ascon.Ascon128a keySize = 16 } if mode == "Ascon80pq" { asconMode = ascon.Ascon80pq keySize = 20 } key := make([]byte, keySize) _, _ = rand.Read(key) nonce := make([]byte, 16) _, _ = rand.Read(nonce) a, _ := ascon.New(key, asconMode) var aead cipher.AEAD = a ct := aead.Seal(nil, nonce, message, ad) got, _ := aead.Open(nil, nonce, ct, ad) fmt.Printf("Message:\t%s\n", m) fmt.Printf("Key:\t\t%x\n", key) fmt.Printf("Nonce:\t\t%x\n\n", nonce) fmt.Printf("Mode:\t\t%x\n\n", mode) fmt.Printf("Cipher:\t\t%x\n", ct) fmt.Printf("Decrypted:\t%s", string(got)) }
A sample run is:
Message: abc Key: 5f78db2844da73493bafe19c5017332853fd9721 Nonce: c2e82156e1d9b3ce59fffb2be79f1f60 Mode: Ascon80pq Cipher: 061b657b53eb67b68e780cd026045ed6fa0012 Decrypted: abc
References
[1] CIRCL GitHub [here].
[2] Dobraunig, C., Eichlseder, M., Mendel, F., & Schläffer, M. (2016). Ascon v1. 2. Submission to the CAESAR Competition.
[3] Madushan, H., Salam, I., & Alawatugoda, J. (2022). A Review of the NIST Lightweight Cryptography Finalists and Their Fault Analyses. Electronics, 11(24), 4199.
[4] Elsadek, I., Aftabjahani, S., Gardner, D., MacLean, E., Wallrabenstein, J. R., & Tawfik, E. Y. (2022, May). Hardware and Energy Efficiency Evaluation of NIST Lightweight Cryptography Standardization Finalists. In 2022 IEEE International Symposium on Circuits and Systems (ISCAS) (pp. 133–137). IEEE.
[5] https://rweather.github.io/lightweight-crypto/performance.html
[6] https://github.com/usnistgov/Lightweight-Cryptography-Benchmarking/blob/main/benchmarks/results_nano_every_hash_all.csv
[7] Dobraunig, C., Eichlseder, M., Mendel, F., & Schläffer, M. (2021). Ascon v1. 2: Lightweight authenticated encryption and hashing. Journal of Cryptology, 34, 1-42.