xoodyak

xoodyak/Implementations/crypto_aead/xoodyakv1/XKCP-ARMv6/Cyclist.h

+/*
+The eXtended Keccak Code Package (XKCP)
+https://github.com/XKCP/XKCP
+
+Xoodyak, designed by Joan Daemen, Seth Hoffert, Michaël Peeters, Gilles Van Assche and Ronny Van Keer.
+
+Implementation by Ronny Van Keer, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to the Keccak Team website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _Cyclist_h_
+#define _Cyclist_h_
+
+#include <stdint.h>
+#include "align.h"
+
+#define Cyclist_ModeHash    1
+#define Cyclist_ModeKeyed   2
+
+#define Cyclist_PhaseDown   1
+#define Cyclist_PhaseUp     2
+
+#ifdef OUTPUT
+
+#include    <stdio.h>
+
+#define KCP_DeclareCyclistStructure(prefix, size, alignment)                    \
+            ALIGN(alignment) typedef struct prefix##_CyclistInstanceStruct {    \
+            uint8_t         state[size];                                        \
+            uint8_t         stateShadow[size];                                  \
+            FILE            *file;                                              \
+            unsigned int    phase;                                              \
+            unsigned int    mode;                                               \
+            unsigned int    Rabsorb;                                            \
+            unsigned int    Rsqueeze;                                           \
+        } prefix##_Instance;
+
+#else
+
+#define KCP_DeclareCyclistStructure(prefix, size, alignment)                    \
+            ALIGN(alignment) typedef struct prefix##_CyclistInstanceStruct {    \
+            uint8_t         state[size];                                        \
+            unsigned int    phase;                                              \
+            unsigned int    mode;                                               \
+            unsigned int    Rabsorb;                                            \
+            unsigned int    Rsqueeze;                                           \
+        } prefix##_Instance;
+
+#endif
+
+#define KCP_DeclareCyclistFunctions(prefix) \
+    void prefix##_Initialize(prefix##_Instance *instance, const uint8_t *K, size_t KLen, const uint8_t *ID, size_t IDLen, const uint8_t *counter, size_t counterLen); \
+    void prefix##_Absorb(prefix##_Instance *instance, const uint8_t *X, size_t XLen); \
+    void prefix##_Encrypt(prefix##_Instance *instance, const uint8_t *P, uint8_t *C, size_t PLen); \
+    void prefix##_Decrypt(prefix##_Instance *instance, const uint8_t *C, uint8_t *P, size_t CLen); \
+    void prefix##_Squeeze(prefix##_Instance *instance, uint8_t *Y, size_t YLen); \
+    void prefix##_SqueezeKey(prefix##_Instance *instance, uint8_t *K, size_t KLen); \
+    void prefix##_Ratchet(prefix##_Instance *instance);
+
+#endif

xoodyak/Implementations/crypto_aead/xoodyakv1/XKCP-ARMv6/Xoodoo-SnP.h

+/*
+The eXtended Keccak Code Package (XKCP)
+https://github.com/XKCP/XKCP
+
+The Xoodoo permutation, designed by Joan Daemen, Seth Hoffert, Gilles Van Assche and Ronny Van Keer.
+
+Implementation by Ronny Van Keer, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to the Keccak Team website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _Xoodoo_SnP_h_
+#define _Xoodoo_SnP_h_
+
+#include <stddef.h>
+#include <stdint.h>
+
+/** For the documentation, see SnP-documentation.h.
+ */
+
+#define Xoodoo_implementation      "32-bit optimized ARM assembler implementation"
+#define Xoodoo_stateSizeInBytes    (3*4*4)
+#define Xoodoo_stateAlignment      4
+
+#define Xoodoo_StaticInitialize()
+void Xoodoo_Initialize(void *state);
+#define Xoodoo_AddByte(argS, argData, argOffset)    ((uint8_t*)argS)[argOffset] ^= (argData)
+void Xoodoo_AddBytes(void *state, const uint8_t *data, unsigned int offset, unsigned int length);
+void Xoodoo_OverwriteBytes(void *state, const uint8_t *data, unsigned int offset, unsigned int length);
+void Xoodoo_OverwriteWithZeroes(void *state, unsigned int byteCount);
+//void Xoodoo_Permute_Nrounds(void *state, unsigned int nrounds);
+void Xoodoo_Permute_6rounds(void *state);
+void Xoodoo_Permute_12rounds(void *state);
+void Xoodoo_ExtractBytes(const void *state, uint8_t *data, unsigned int offset, unsigned int length);
+void Xoodoo_ExtractAndAddBytes(const void *state, const uint8_t *input, uint8_t *output, unsigned int offset, unsigned int length);
+
+#define Xoodoo_FastXoofff_supported
+void Xoofff_AddIs(uint8_t *output, const uint8_t *input, size_t bitLen);
+size_t Xoofff_CompressFastLoop(uint8_t *kRoll, uint8_t *xAccu, const uint8_t *input, size_t length);
+size_t Xoofff_ExpandFastLoop(uint8_t *yAccu, const uint8_t *kRoll, uint8_t *output, size_t length);
+
+#define CyclistFullBlocks_supported
+size_t Xoodyak_AbsorbKeyedFullBlocks(void *state, const uint8_t *X, size_t XLen);
+size_t Xoodyak_AbsorbHashFullBlocks(void *state, const uint8_t *X, size_t XLen);
+size_t Xoodyak_SqueezeHashFullBlocks(void *state, uint8_t *Y, size_t YLen);
+size_t Xoodyak_SqueezeKeyedFullBlocks(void *state, uint8_t *Y, size_t YLen);
+size_t Xoodyak_EncryptFullBlocks(void *state, const uint8_t *I, uint8_t *O, size_t IOLen);
+size_t Xoodyak_DecryptFullBlocks(void *state, const uint8_t *I, uint8_t *O, size_t IOLen);
+
+#endif

xoodyak/Implementations/crypto_aead/xoodyakv1/XKCP-ARMv6/Xoodoo.h

+/*
+The eXtended Keccak Code Package (XKCP)
+https://github.com/XKCP/XKCP
+
+The Xoodoo permutation, designed by Joan Daemen, Seth Hoffert, Gilles Van Assche and Ronny Van Keer.
+
+Implementation by Ronny Van Keer, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to the Keccak Team website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _Xoodoo_h_
+#define _Xoodoo_h_
+
+#include <stdint.h>
+#include <stdlib.h>
+
+#define MAXROUNDS   12
+#define NROWS       3
+#define NCOLUMS     4
+#define NLANES      (NCOLUMS*NROWS)
+
+/*    Round constants    */
+#define _rc12   0x00000058
+#define _rc11   0x00000038
+#define _rc10   0x000003C0
+#define _rc9    0x000000D0
+#define _rc8    0x00000120
+#define _rc7    0x00000014
+#define _rc6    0x00000060
+#define _rc5    0x0000002C
+#define _rc4    0x00000380
+#define _rc3    0x000000F0
+#define _rc2    0x000001A0
+#define _rc1    0x00000012
+
+
+#if !defined(ROTL32)
+    #if defined (__arm__) && !defined(__GNUC__)
+        #define ROTL32(a, offset)                       __ror(a, (32-(offset))%32)
+    #elif defined(_MSC_VER)
+        #define ROTL32(a, offset)                       _rotl(a, (offset)%32)
+    #else
+        #define ROTL32(a, offset)                       ((((uint32_t)a) << ((offset)%32)) ^ (((uint32_t)a) >> ((32-(offset))%32)))
+    #endif
+#endif
+
+#if !defined(READ32_UNALIGNED)
+    #if defined (__arm__) && !defined(__GNUC__)
+        #define READ32_UNALIGNED(argAddress)            (*((const __packed uint32_t*)(argAddress)))
+    #elif defined(_MSC_VER)
+        #define READ32_UNALIGNED(argAddress)            (*((const uint32_t*)(argAddress)))
+    #else
+        #define READ32_UNALIGNED(argAddress)            (*((const uint32_t*)(argAddress)))
+    #endif
+#endif
+
+#if !defined(WRITE32_UNALIGNED)
+    #if defined (__arm__) && !defined(__GNUC__)
+        #define WRITE32_UNALIGNED(argAddress, argData)  (*((__packed uint32_t*)(argAddress)) = (argData))
+    #elif defined(_MSC_VER)
+        #define WRITE32_UNALIGNED(argAddress, argData)  (*((uint32_t*)(argAddress)) = (argData))
+    #else
+        #define WRITE32_UNALIGNED(argAddress, argData)  (*((uint32_t*)(argAddress)) = (argData))
+    #endif
+#endif
+
+#if !defined(index)
+    #define    index(__x,__y)    ((((__y) % NROWS) * NCOLUMS) + ((__x) % NCOLUMS))
+#endif
+
+typedef    uint32_t tXoodooLane;
+
+#endif

xoodyak/Implementations/crypto_aead/xoodyakv1/XKCP-ARMv6/Xoodyak-parameters.h

+/*
+The eXtended Keccak Code Package (XKCP)
+https://github.com/XKCP/XKCP
+
+Xoodyak, designed by Joan Daemen, Seth Hoffert, Michaël Peeters, Gilles Van Assche and Ronny Van Keer.
+
+Implementation by Ronny Van Keer, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to the Keccak Team website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _Xoodyak_parameters_h_
+#define _Xoodyak_parameters_h_
+
+#define Xoodyak_f_bPrime    48
+#define Xoodyak_Rhash       16
+#define Xoodyak_Rkin        44
+#define Xoodyak_Rkout       24
+#define Xoodyak_lRatchet    16
+
+#endif

xoodyak/Implementations/crypto_aead/xoodyakv1/XKCP-ARMv6/Xoodyak.c

+/*
+The eXtended Keccak Code Package (XKCP)
+https://github.com/XKCP/XKCP
+
+Xoodyak, designed by Joan Daemen, Seth Hoffert, Michaël Peeters, Gilles Van Assche and Ronny Van Keer.
+
+Implementation by Ronny Van Keer, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to the Keccak Team website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifdef XoodooReference
+    #include "displayIntermediateValues.h"
+#endif
+
+#include <assert.h>
+#include <string.h>
+#include "Xoodyak.h"
+
+#ifdef OUTPUT
+#include <stdlib.h>
+#include <string.h>
+
+static void displayByteString(FILE *f, const char* synopsis, const uint8_t *data, unsigned int length);
+static void displayByteString(FILE *f, const char* synopsis, const uint8_t *data, unsigned int length)
+{
+    unsigned int i;
+
+    fprintf(f, "%s:", synopsis);
+    for(i=0; i<length; i++)
+        fprintf(f, " %02x", (unsigned int)data[i]);
+    fprintf(f, "\n");
+}
+#endif
+
+#define MyMin(a,b)  (((a) < (b)) ? (a) : (b))
+
+#ifdef XKCP_has_Xoodoo
+    #include "Xoodoo-SnP.h"
+
+    #define SnP                         Xoodoo
+    #define SnP_Permute                 Xoodoo_Permute_12rounds
+    #define prefix                      Xoodyak
+        #include "Cyclist.inc"
+    #undef  prefix
+    #undef  SnP
+    #undef  SnP_Permute
+#endif

xoodyak/Implementations/crypto_aead/xoodyakv1/XKCP-ARMv6/Xoodyak.h

+/*
+The eXtended Keccak Code Package (XKCP)
+https://github.com/XKCP/XKCP
+
+Xoodyak, designed by Joan Daemen, Seth Hoffert, Michaël Peeters, Gilles Van Assche and Ronny Van Keer.
+
+Implementation by Ronny Van Keer, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to the Keccak Team website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _Xoodyak_h_
+#define _Xoodyak_h_
+
+#include "config.h"
+#ifdef XKCP_has_Xoodoo
+
+#include <stddef.h>
+#include "Cyclist.h"
+#include "Xoodoo-SnP.h"
+#include "Xoodyak-parameters.h"
+
+KCP_DeclareCyclistStructure(Xoodyak, Xoodoo_stateSizeInBytes, Xoodoo_stateAlignment)
+KCP_DeclareCyclistFunctions(Xoodyak)
+
+#else
+#error This requires an implementation of Xoodoo
+#endif
+
+#endif

xoodyak/Implementations/crypto_aead/xoodyakv1/XKCP-ARMv6/align.h

+/*
+The eXtended Keccak Code Package (XKCP)
+https://github.com/XKCP/XKCP
+
+Implementation by Gilles Van Assche and Ronny Van Keer, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to the Keccak Team website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _align_h_
+#define _align_h_
+
+/* on Mac OS-X and possibly others, ALIGN(x) is defined in param.h, and -Werror chokes on the redef. */
+#ifdef ALIGN
+#undef ALIGN
+#endif
+
+#if defined(__GNUC__)
+#define ALIGN(x) __attribute__ ((aligned(x)))
+#elif defined(_MSC_VER)
+#define ALIGN(x) __declspec(align(x))
+#elif defined(__ARMCC_VERSION)
+#define ALIGN(x) __align(x)
+#else
+#define ALIGN(x)
+#endif
+
+#endif

xoodyak/Implementations/crypto_aead/xoodyakv1/XKCP-ARMv6/api.h

+#define CRYPTO_KEYBYTES     16
+#define CRYPTO_NSECBYTES    0
+#define CRYPTO_NPUBBYTES    16
+#define CRYPTO_ABYTES       16
+#define CRYPTO_NOOVERLAP    1

xoodyak/Implementations/crypto_aead/xoodyakv1/XKCP-ARMv6/brg_endian.h

+/*
+ ---------------------------------------------------------------------------
+ Copyright (c) 1998-2008, Brian Gladman, Worcester, UK. All rights reserved.
+
+ LICENSE TERMS
+
+ The redistribution and use of this software (with or without changes)
+ is allowed without the payment of fees or royalties provided that:
+
+  1. source code distributions include the above copyright notice, this
+     list of conditions and the following disclaimer;
+
+  2. binary distributions include the above copyright notice, this list
+     of conditions and the following disclaimer in their documentation;
+
+  3. the name of the copyright holder is not used to endorse products
+     built using this software without specific written permission.
+
+ DISCLAIMER
+
+ This software is provided 'as is' with no explicit or implied warranties
+ in respect of its properties, including, but not limited to, correctness
+ and/or fitness for purpose.
+ ---------------------------------------------------------------------------
+ Issue Date: 20/12/2007
+ Changes for ARM 9/9/2010
+*/
+
+#ifndef _BRG_ENDIAN_H
+#define _BRG_ENDIAN_H
+
+#define IS_BIG_ENDIAN      4321 /* byte 0 is most significant (mc68k) */
+#define IS_LITTLE_ENDIAN   1234 /* byte 0 is least significant (i386) */
+
+#if 0
+/* Include files where endian defines and byteswap functions may reside */
+#if defined( __sun )
+#  include <sys/isa_defs.h>
+#elif defined( __FreeBSD__ ) || defined( __OpenBSD__ ) || defined( __NetBSD__ )
+#  include <sys/endian.h>
+#elif defined( BSD ) && ( BSD >= 199103 ) || defined( __APPLE__ ) || \
+      defined( __CYGWIN32__ ) || defined( __DJGPP__ ) || defined( __osf__ )
+#  include <machine/endian.h>
+#elif defined( __linux__ ) || defined( __GNUC__ ) || defined( __GNU_LIBRARY__ )
+#  if !defined( __MINGW32__ ) && !defined( _AIX )
+#    include <endian.h>
+#    if !defined( __BEOS__ )
+#      include <byteswap.h>
+#    endif
+#  endif
+#endif
+#endif
+
+/* Now attempt to set the define for platform byte order using any  */
+/* of the four forms SYMBOL, _SYMBOL, __SYMBOL & __SYMBOL__, which  */
+/* seem to encompass most endian symbol definitions                 */
+
+#if defined( BIG_ENDIAN ) && defined( LITTLE_ENDIAN )
+#  if defined( BYTE_ORDER ) && BYTE_ORDER == BIG_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( BYTE_ORDER ) && BYTE_ORDER == LITTLE_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( BIG_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( LITTLE_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( _BIG_ENDIAN ) && defined( _LITTLE_ENDIAN )
+#  if defined( _BYTE_ORDER ) && _BYTE_ORDER == _BIG_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( _BYTE_ORDER ) && _BYTE_ORDER == _LITTLE_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( _BIG_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( _LITTLE_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( __BIG_ENDIAN ) && defined( __LITTLE_ENDIAN )
+#  if defined( __BYTE_ORDER ) && __BYTE_ORDER == __BIG_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( __BYTE_ORDER ) && __BYTE_ORDER == __LITTLE_ENDIAN
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( __BIG_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( __LITTLE_ENDIAN )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+#if defined( __BIG_ENDIAN__ ) && defined( __LITTLE_ENDIAN__ )
+#  if defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __BIG_ENDIAN__
+#    define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#  elif defined( __BYTE_ORDER__ ) && __BYTE_ORDER__ == __LITTLE_ENDIAN__
+#    define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#  endif
+#elif defined( __BIG_ENDIAN__ )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#elif defined( __LITTLE_ENDIAN__ )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#endif
+
+/*  if the platform byte order could not be determined, then try to */
+/*  set this define using common machine defines                    */
+#if !defined(PLATFORM_BYTE_ORDER)
+
+#if   defined( __alpha__ ) || defined( __alpha ) || defined( i386 )       || \
+      defined( __i386__ )  || defined( _M_I86 )  || defined( _M_IX86 )    || \
+      defined( __OS2__ )   || defined( sun386 )  || defined( __TURBOC__ ) || \
+      defined( vax )       || defined( vms )     || defined( VMS )        || \
+      defined( __VMS )     || defined( _M_X64 )
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+
+#elif defined( AMIGA )    || defined( applec )    || defined( __AS400__ )  || \
+      defined( _CRAY )    || defined( __hppa )    || defined( __hp9000 )   || \
+      defined( ibm370 )   || defined( mc68000 )   || defined( m68k )       || \
+      defined( __MRC__ )  || defined( __MVS__ )   || defined( __MWERKS__ ) || \
+      defined( sparc )    || defined( __sparc)    || defined( SYMANTEC_C ) || \
+      defined( __VOS__ )  || defined( __TIGCC__ ) || defined( __TANDEM )   || \
+      defined( THINK_C )  || defined( __VMCMS__ ) || defined( _AIX )       || \
+      defined( __s390__ ) || defined( __s390x__ ) || defined( __zarch__ )
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+
+#elif defined(__arm__)
+# ifdef __BIG_ENDIAN
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+# else
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+# endif
+#elif 1     /* **** EDIT HERE IF NECESSARY **** */
+#  define PLATFORM_BYTE_ORDER IS_LITTLE_ENDIAN
+#elif 0     /* **** EDIT HERE IF NECESSARY **** */
+#  define PLATFORM_BYTE_ORDER IS_BIG_ENDIAN
+#else
+#  error Please edit lines 132 or 134 in brg_endian.h to set the platform byte order
+#endif
+
+#endif
+
+#endif

xoodyak/Implementations/crypto_aead/xoodyakv1/XKCP-ARMv6/config.h

+/* File generated by ToTargetConfigFile.xsl */
+
+#define XKCP_has_Xoodyak
+#define XKCP_has_Xoodoo

xoodyak/Implementations/crypto_aead/xoodyakv1/XKCP-ARMv6/encrypt.c

+/*
+The eXtended Keccak Code Package (XKCP)
+https://github.com/XKCP/XKCP
+
+Xoodyak, designed by Joan Daemen, Seth Hoffert, Michaël Peeters, Gilles Van Assche and Ronny Van Keer.
+
+Implementation by Ronny Van Keer, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to the Keccak Team website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#include "crypto_aead.h"
+#include "api.h"
+#include "Xoodyak.h"
+#include <string.h>
+
+#if !defined(CRYPTO_KEYBYTES)
+    #define CRYPTO_KEYBYTES     16
+#endif
+#if !defined(CRYPTO_NPUBBYTES)
+    #define CRYPTO_NPUBBYTES    16
+#endif
+
+#define TAGLEN  16
+
+int crypto_aead_encrypt(
+    unsigned char *c, unsigned long long *clen,
+    const unsigned char *m, unsigned long long mlen,
+    const unsigned char *ad, unsigned long long adlen,
+    const unsigned char *nsec,
+    const unsigned char *npub,
+    const unsigned char *k)
+{
+    Xoodyak_Instance    instance;
+
+    (void)nsec;
+
+    Xoodyak_Initialize(&instance, k, CRYPTO_KEYBYTES, NULL, 0, NULL, 0);
+    Xoodyak_Absorb(&instance, npub, CRYPTO_NPUBBYTES);
+    Xoodyak_Absorb(&instance, ad, (size_t)adlen);
+    Xoodyak_Encrypt(&instance, m, c, (size_t)mlen);
+    Xoodyak_Squeeze(&instance, c + mlen, TAGLEN);
+    *clen = mlen + TAGLEN;
+    #if 0
+    {
+        unsigned int i;
+        for (i = 0; i < *clen; ++i )
+        {
+            printf("\\x%02x", c[i] );
+        }
+        printf("\n");
+    }
+    #endif
+    return 0;
+}
+
+int crypto_aead_decrypt(
+    unsigned char *m, unsigned long long *mlen,
+    unsigned char *nsec,
+    const unsigned char *c, unsigned long long clen,
+    const unsigned char *ad, unsigned long long adlen,
+    const unsigned char *npub,
+    const unsigned char *k)
+{
+    Xoodyak_Instance    instance;
+    unsigned char        tag[TAGLEN];
+    unsigned long long    mlen_;
+
+    (void)nsec;
+
+    *mlen = 0;
+    if (clen < TAGLEN) {
+        return -1;
+    }
+    mlen_ = clen - TAGLEN;
+    Xoodyak_Initialize(&instance, k, CRYPTO_KEYBYTES, NULL, 0, NULL, 0);
+    Xoodyak_Absorb(&instance, npub, CRYPTO_NPUBBYTES);
+    Xoodyak_Absorb(&instance, ad, (size_t)adlen);
+    Xoodyak_Decrypt(&instance, c, m, (size_t)mlen_);
+    Xoodyak_Squeeze(&instance, tag, TAGLEN);
+    if (memcmp(tag, c + mlen_, TAGLEN) != 0) {
+        memset(m, 0, (size_t)mlen_);
+        return -1;
+    }
+    *mlen = mlen_;
+    return 0;
+}

xoodyak/Implementations/crypto_aead/xoodyakv1/XKCP-ARMv6M/Cyclist.h

+/*
+The eXtended Keccak Code Package (XKCP)
+https://github.com/XKCP/XKCP
+
+Xoodyak, designed by Joan Daemen, Seth Hoffert, Michaël Peeters, Gilles Van Assche and Ronny Van Keer.
+
+Implementation by Ronny Van Keer, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to the Keccak Team website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _Cyclist_h_
+#define _Cyclist_h_
+
+#include <stdint.h>
+#include "align.h"
+
+#define Cyclist_ModeHash    1
+#define Cyclist_ModeKeyed   2
+
+#define Cyclist_PhaseDown   1
+#define Cyclist_PhaseUp     2
+
+#ifdef OUTPUT
+
+#include    <stdio.h>
+
+#define KCP_DeclareCyclistStructure(prefix, size, alignment)                    \
+            ALIGN(alignment) typedef struct prefix##_CyclistInstanceStruct {    \
+            uint8_t         state[size];                                        \
+            uint8_t         stateShadow[size];                                  \
+            FILE            *file;                                              \
+            unsigned int    phase;                                              \
+            unsigned int    mode;                                               \
+            unsigned int    Rabsorb;                                            \
+            unsigned int    Rsqueeze;                                           \
+        } prefix##_Instance;
+
+#else
+
+#define KCP_DeclareCyclistStructure(prefix, size, alignment)                    \
+            ALIGN(alignment) typedef struct prefix##_CyclistInstanceStruct {    \
+            uint8_t         state[size];                                        \
+            unsigned int    phase;                                              \
+            unsigned int    mode;                                               \
+            unsigned int    Rabsorb;                                            \
+            unsigned int    Rsqueeze;                                           \
+        } prefix##_Instance;
+
+#endif
+
+#define KCP_DeclareCyclistFunctions(prefix) \
+    void prefix##_Initialize(prefix##_Instance *instance, const uint8_t *K, size_t KLen, const uint8_t *ID, size_t IDLen, const uint8_t *counter, size_t counterLen); \
+    void prefix##_Absorb(prefix##_Instance *instance, const uint8_t *X, size_t XLen); \
+    void prefix##_Encrypt(prefix##_Instance *instance, const uint8_t *P, uint8_t *C, size_t PLen); \
+    void prefix##_Decrypt(prefix##_Instance *instance, const uint8_t *C, uint8_t *P, size_t CLen); \
+    void prefix##_Squeeze(prefix##_Instance *instance, uint8_t *Y, size_t YLen); \
+    void prefix##_SqueezeKey(prefix##_Instance *instance, uint8_t *K, size_t KLen); \
+    void prefix##_Ratchet(prefix##_Instance *instance);
+
+#endif

xoodyak/Implementations/crypto_aead/xoodyakv1/XKCP-ARMv6M/Xoodoo-SnP.h

+/*
+The eXtended Keccak Code Package (XKCP)
+https://github.com/XKCP/XKCP
+
+The Xoodoo permutation, designed by Joan Daemen, Seth Hoffert, Gilles Van Assche and Ronny Van Keer.
+
+Implementation by Ronny Van Keer, hereby denoted as "the implementer".
+
+For more information, feedback or questions, please refer to the Keccak Team website:
+https://keccak.team/
+
+To the extent possible under law, the implementer has waived all copyright
+and related or neighboring rights to the source code in this file.
+http://creativecommons.org/publicdomain/zero/1.0/
+*/
+
+#ifndef _Xoodoo_SnP_h_
+