permutations.h

#ifndef PERMUTATIONS_H_
#define PERMUTATIONS_H_

#include <stdint.h>

#include "api.h"
#include "ascon.h"
#include "printstate.h"
#include "round.h"

#define ASCON_128_KEYBYTES 16
#define ASCON_128A_KEYBYTES 16
#define ASCON_80PQ_KEYBYTES 20

#define ASCON_128_RATE 8
#define ASCON_128A_RATE 16

#define ASCON_128_PA_ROUNDS 12
#define ASCON_128_PB_ROUNDS 6
#define ASCON_128A_PB_ROUNDS 8

#define ASCON_HASH_BYTES 32

#define ASCON_128_IV                                     \
  U64TOWORD(((uint64_t)(ASCON_128_KEYBYTES * 8) << 56) | \
            ((uint64_t)(ASCON_128_RATE * 8) << 48) |     \
            ((uint64_t)(ASCON_128_PA_ROUNDS) << 40) |    \
            ((uint64_t)(ASCON_128_PB_ROUNDS) << 32))

#define ASCON_128A_IV                                    \
  U64TOWORD(((uint64_t)(ASCON_128_KEYBYTES * 8) << 56) | \
            ((uint64_t)(ASCON_128A_RATE * 8) << 48) |    \
            ((uint64_t)(ASCON_128_PA_ROUNDS) << 40) |    \
            ((uint64_t)(ASCON_128A_PB_ROUNDS) << 32))

#define ASCON_80PQ_IV                                     \
  U64TOWORD(((uint64_t)(ASCON_80PQ_KEYBYTES * 8) << 56) | \
            ((uint64_t)(ASCON_128_RATE * 8) << 48) |      \
            ((uint64_t)(ASCON_128_PA_ROUNDS) << 40) |     \
            ((uint64_t)(ASCON_128_PB_ROUNDS) << 32))

#define ASCON_HASH_IV                                 \
  U64TOWORD(((uint64_t)(ASCON_128_RATE * 8) << 48) |  \
            ((uint64_t)(ASCON_128_PA_ROUNDS) << 40) | \
            ((uint64_t)(ASCON_HASH_BYTES * 8) << 0))

#define ASCON_XOF_IV                                 \
  U64TOWORD(((uint64_t)(ASCON_128_RATE * 8) << 48) | \
            ((uint64_t)(ASCON_128_PA_ROUNDS) << 40))

#define ASCON_HASH_IV0 U64TOWORD(0xee9398aadb67f03dull)
#define ASCON_HASH_IV1 U64TOWORD(0x8bb21831c60f1002ull)
#define ASCON_HASH_IV2 U64TOWORD(0xb48a92db98d5da62ull)
#define ASCON_HASH_IV3 U64TOWORD(0x43189921b8f8e3e8ull)
#define ASCON_HASH_IV4 U64TOWORD(0x348fa5c9d525e140ull)

#define ASCON_XOF_IV0 U64TOWORD(0xb57e273b814cd416ull)
#define ASCON_XOF_IV1 U64TOWORD(0x2b51042562ae2420ull)
#define ASCON_XOF_IV2 U64TOWORD(0x66a3a7768ddf2218ull)
#define ASCON_XOF_IV3 U64TOWORD(0x5aad0a7a8153650cull)
#define ASCON_XOF_IV4 U64TOWORD(0x4f3e0e32539493b6ull)

#if ASCON_RATE == 8 && CRYPTO_KEYBYTES == 16
#define IV ASCON_128_IV
#define PA_ROUNDS 12
#define PB_ROUNDS 6
#define PB P6
#endif

#if ASCON_RATE == 16
#define IV ASCON_128A_IV
#define PA_ROUNDS 12
#define PB_ROUNDS 8
#define PB P8
#endif

#if ASCON_RATE == 8 && CRYPTO_KEYBYTES == 20
#define IV ASCON_80PQ_IV
#define PA_ROUNDS 12
#define PB_ROUNDS 6
#define PB P6
#endif

#define START(n) (12 - n)

#if ASCON_UNROLL_LOOPS

__forceinline void P12ROUNDS(state_t* s) {
  ROUND(s, 0xc, 0xc);
  ROUND(s, 0x9, 0xc);
  ROUND(s, 0xc, 0x9);
  ROUND(s, 0x9, 0x9);
  ROUND(s, 0x6, 0xc);
  ROUND(s, 0x3, 0xc);
  ROUND(s, 0x6, 0x9);
  ROUND(s, 0x3, 0x9);
  ROUND(s, 0xc, 0x6);
  ROUND(s, 0x9, 0x6);
  ROUND(s, 0xc, 0x3);
  ROUND(s, 0x9, 0x3);
}

__forceinline void P8ROUNDS(state_t* s) {
  ROUND(s, 0x6, 0xc);
  ROUND(s, 0x3, 0xc);
  ROUND(s, 0x6, 0x9);
  ROUND(s, 0x3, 0x9);
  ROUND(s, 0xc, 0x6);
  ROUND(s, 0x9, 0x6);
  ROUND(s, 0xc, 0x3);
  ROUND(s, 0x9, 0x3);
}

__forceinline void P6ROUNDS(state_t* s) {
  ROUND(s, 0x6, 0x9);
  ROUND(s, 0x3, 0x9);
  ROUND(s, 0xc, 0x6);
  ROUND(s, 0x9, 0x6);
  ROUND(s, 0xc, 0x3);
  ROUND(s, 0x9, 0x3);
}

#else /* !ASCON_UNROLL_LOOPS */

extern const uint8_t constants[][2];

__forceinline void P12ROUNDS(state_t* s) {
  for (int i = START(12); i < 12; i++)
    ROUND(s, constants[i][0], constants[i][1]);
}

__forceinline void P8ROUNDS(state_t* s) {
  for (int i = START(8); i < 12; i++)
    ROUND(s, constants[i][0], constants[i][1]);
}

__forceinline void P6ROUNDS(state_t* s) {
  for (int i = START(6); i < 12; i++)
    ROUND(s, constants[i][0], constants[i][1]);
}

#endif

#if ASCON_INLINE_PERM

__forceinline void P12(state_t* s) {
  printstate(" permutation input", s);
  P12ROUNDS(s);
}

__forceinline void P8(state_t* s) {
  printstate(" permutation input", s);
  P8ROUNDS(s);
}

__forceinline void P6(state_t* s) {
  printstate(" permutation input", s);
  P6ROUNDS(s);
}

__forceinline void P(state_t* s, int i) {
  if (i == 12) P12(s);
  if (i == 8) P8(s);
  if (i == 6) P6(s);
}

#elif ASCON_SINGLE_PERM

#define P12(s) P(s, 12)
#define P8(s) P(s, 8)
#define P6(s) P(s, 6)

void P(state_t* s, uint8_t rounds);

#else /* !ASCON_INLINE_PERM && !ASCON_SINGLE_PERM */

void P12(state_t* s);
void P8(state_t* s);
void P6(state_t* s);

__forceinline void P(state_t* s, int i) {
  if (i == 12) P12(s);
  if (i == 8) P8(s);
  if (i == 6) P6(s);
}

#endif

#endif /* PERMUTATIONS_H_ */