ASCON MAC and PRF
[ASCON Home][Home]
ASCON [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. In this case we will implement a Message Authentication Code (MAC) and PRF (Pseudo-Random Function). With this, we create a shared secret key, and can sign and verify messages with it.
|
Theory
HMAC is a message authentication code (MAC) that can be used to verify the integrity and authentication of a message. It involves hashing the message with a secret key and thus differs from standard hashing, which is purely a one-way function. As with any MAC, it can be used with a standard hash function, such as MD5 or SHA-1, which results in methods such as HMAC-MD5 or HMAC-SHA-1. Also, as with any hashing function, the strength depends on the quality of the hashing function, and the resulting number of hash code bits. Along with this, the number of bits in the secret key is a factor in the strength of the hash. The figure below outlines the operation, where the message to be sent is converted with a secret key, and the hashing function, to an HMAC code. This is then sent with the message. On receipt, the receiver recalculates the HMAC code from the same secret key, and the message, and checks it against the received version. If they match, it validates both the sender and the message.
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]:
#!/usr/bin/env python3 import sys # Code from: https://github.com/meichlseder/pyascon/blob/master/ascon.py """ Implementation of Ascon v1.2, an authenticated cipher and hash function http://ascon.iaik.tugraz.at/ """ debug = False debugpermutation = False # === Ascon MAC/PRF === def ascon_mac(key, message, variant="Ascon-Mac", taglength=16): """ Ascon message authentication code (MAC) and pseudorandom function (PRF). key: a bytes object of size 16 message: a bytes object of arbitrary length (<= 16 for "Ascon-PrfShort") variant: "Ascon-Mac", "Ascon-Maca" (both 128-bit output, arbitrarily long input), "Ascon-Prf", "Ascon-Prfa" (both arbitrarily long input and output), or "Ascon-PrfShort" (t-bit output for t<=128, m-bit input for m<=128) taglength: the requested output bytelength l/8 (must be <=16 for variants "Ascon-Mac", "Ascon-Maca", and "Ascon-PrfShort", arbitrary for "Ascon-Prf", "Ascon-Prfa"; should be >= 16 for 128-bit security) returns a bytes object containing the authentication tag """ assert variant in ["Ascon-Mac", "Ascon-Prf", "Ascon-Maca", "Ascon-Prfa", "Ascon-PrfShort"] if variant in ["Ascon-Mac", "Ascon-Maca"]: assert(len(key) == 16 and taglength <= 16) if variant in ["Ascon-Prf", "Ascon-Prfa"]: assert(len(key) == 16) if variant == "Ascon-PrfShort": assert(len(key) == 16 and taglength <= 16 and len(message) <= 16) a = 12 # rounds b = 8 if variant in ["Ascon-Prfa", "Ascon-Maca"] else 12 # rounds msgblocksize = 40 if variant in ["Ascon-Prfa", "Ascon-Maca"] else 32 # bytes (input rate for Mac, Prf) rate = 16 # bytes (output rate) if variant == "Ascon-PrfShort": # Initialization + Message Processing (Absorbing) IV = to_bytes([len(key) * 8, len(message)*8, a + 64, taglength * 8]) + zero_bytes(4) S = bytes_to_state(IV + key + message + zero_bytes(16 - len(message))) if debug: printstate(S, "initial value:") ascon_permutation(S, a) if debug: printstate(S, "process message:") # Finalization (Squeezing) T = int_to_bytes(S[3] ^ bytes_to_int(key[0:8]), 8) + int_to_bytes(S[4] ^ bytes_to_int(key[8:16]), 8) return T[:taglength] else: # Ascon-Prf, Ascon-Prfa, Ascon-Mac, Ascon-Maca # Initialization if variant in ["Ascon-Mac", "Ascon-Maca"]: tagspec = int_to_bytes(16*8, 4) if variant in ["Ascon-Prf", "Ascon-Prfa"]: tagspec = int_to_bytes(0*8, 4) S = bytes_to_state(to_bytes([len(key) * 8, rate * 8, a + 128, a-b]) + tagspec + key + zero_bytes(16)) if debug: printstate(S, "initial value:") ascon_permutation(S, a) if debug: printstate(S, "initialization:") # Message Processing (Absorbing) m_padding = to_bytes([0x80]) + zero_bytes(msgblocksize - (len(message) % msgblocksize) - 1) m_padded = message + m_padding # first s-1 blocks for block in range(0, len(m_padded) - msgblocksize, msgblocksize): S[0] ^= bytes_to_int(m_padded[block:block+8]) # msgblocksize=32 bytes S[1] ^= bytes_to_int(m_padded[block+8:block+16]) S[2] ^= bytes_to_int(m_padded[block+16:block+24]) S[3] ^= bytes_to_int(m_padded[block+24:block+32]) if variant in ["Ascon-Prfa", "Ascon-Maca"]: S[4] ^= bytes_to_int(m_padded[block+32:block+40]) ascon_permutation(S, b) # last block block = len(m_padded) - msgblocksize S[0] ^= bytes_to_int(m_padded[block:block+8]) # msgblocksize=32 bytes S[1] ^= bytes_to_int(m_padded[block+8:block+16]) S[2] ^= bytes_to_int(m_padded[block+16:block+24]) S[3] ^= bytes_to_int(m_padded[block+24:block+32]) if variant in ["Ascon-Prfa", "Ascon-Maca"]: S[4] ^= bytes_to_int(m_padded[block+32:block+40]) S[4] ^= 1 if debug: printstate(S, "process message:") # Finalization (Squeezing) T = b"" ascon_permutation(S, a) while len(T) < taglength: T += int_to_bytes(S[0], 8) # rate=16 T += int_to_bytes(S[1], 8) ascon_permutation(S, b) if debug: printstate(S, "finalization:") return T[:taglength] # === Ascon permutation === def ascon_permutation(S, rounds=1): """ Ascon core permutation for the sponge construction - internal helper function. S: Ascon state, a list of 5 64-bit integers rounds: number of rounds to perform returns nothing, updates S """ assert(rounds <= 12) if debugpermutation: printwords(S, "permutation input:") for r in range(12-rounds, 12): # --- add round constants --- S[2] ^= (0xf0 - r*0x10 + r*0x1) if debugpermutation: printwords(S, "round constant addition:") # --- substitution layer --- S[0] ^= S[4] S[4] ^= S[3] S[2] ^= S[1] T = [(S[i] ^ 0xFFFFFFFFFFFFFFFF) & S[(i+1)%5] for i in range(5)] for i in range(5): S[i] ^= T[(i+1)%5] S[1] ^= S[0] S[0] ^= S[4] S[3] ^= S[2] S[2] ^= 0XFFFFFFFFFFFFFFFF if debugpermutation: printwords(S, "substitution layer:") # --- linear diffusion layer --- S[0] ^= rotr(S[0], 19) ^ rotr(S[0], 28) S[1] ^= rotr(S[1], 61) ^ rotr(S[1], 39) S[2] ^= rotr(S[2], 1) ^ rotr(S[2], 6) S[3] ^= rotr(S[3], 10) ^ rotr(S[3], 17) S[4] ^= rotr(S[4], 7) ^ rotr(S[4], 41) if debugpermutation: printwords(S, "linear diffusion layer:") # === helper functions === def get_random_bytes(num): import os return to_bytes(os.urandom(num)) def zero_bytes(n): return n * b"\x00" def to_bytes(l): # where l is a list or bytearray or bytes return bytes(bytearray(l)) def bytes_to_int(bytes): return sum([bi << ((len(bytes) - 1 - i)*8) for i, bi in enumerate(to_bytes(bytes))]) def bytes_to_state(bytes): return [bytes_to_int(bytes[8*w:8*(w+1)]) for w in range(5)] def int_to_bytes(integer, nbytes): return to_bytes([(integer >> ((nbytes - 1 - i) * 8)) % 256 for i in range(nbytes)]) def rotr(val, r): return (val >> r) | ((val & (1<1): message=sys.argv[1].encode() if (len(sys.argv)>2): variant=sys.argv[2] if (len(sys.argv)>3): taglength=int(sys.argv[3]) key = get_random_bytes(keysize) if (variant=="Ascon-Mac" or variant=="Ascon-Maca" or variant=="Ascon-PrfShort"): taglength = 16 tag = ascon_mac(key, message, variant,taglength) print ("== ASCON MAC/PRF ==") print ("Plaintext: ",message.decode()) print ("\nKey: ",bytes(key).hex()) print ("Type: ",variant) print ("\nMAC: ",bytes(tag).hex())
Ans a sample run is:
== ASCON MAC/PRF == Plaintext: abc Key: c323ab5e12662594f172e136bd183f0d Type: Ascon-Mac MAC: 8d5cdf6c434c357199e77c105620f818
References
[1] ASCON 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.