From 2e4a168be5fbd915bce0469dbec6ab15eb97ce65 Mon Sep 17 00:00:00 2001 From: KNOT team Date: Thu, 2 Jul 2020 00:51:25 +0000 Subject: [PATCH] knot armcortexm_3 --- knot/Implementations/crypto_aead/knot128v1/armcortexm_3/api.h | 9 +++++++++ knot/Implementations/crypto_aead/knot128v1/armcortexm_3/auxFormat.h | 68 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ knot/Implementations/crypto_aead/knot128v1/armcortexm_3/crypto_aead.h | 18 ++++++++++++++++++ knot/Implementations/crypto_aead/knot128v1/armcortexm_3/encrypt.c | 246 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ knot/Implementations/crypto_aead/knot128v2/armcortexm_3/api.h | 8 ++++++++ knot/Implementations/crypto_aead/knot128v2/armcortexm_3/auxFormat.h | 142 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ knot/Implementations/crypto_aead/knot128v2/armcortexm_3/crypto_aead.h | 17 +++++++++++++++++ knot/Implementations/crypto_aead/knot128v2/armcortexm_3/encrypt.c | 263 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ knot/Implementations/crypto_aead/knot192/armcortexm_3/api.h | 6 ++++++ knot/Implementations/crypto_aead/knot192/armcortexm_3/auxFormat.h | 128 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ knot/Implementations/crypto_aead/knot192/armcortexm_3/crypto_aead.h | 18 ++++++++++++++++++ knot/Implementations/crypto_aead/knot192/armcortexm_3/encrypt.c | 214 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ knot/Implementations/crypto_aead/knot256/armcortexm_3/api.h | 8 ++++++++ knot/Implementations/crypto_aead/knot256/armcortexm_3/auxFormat.h | 114 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ knot/Implementations/crypto_aead/knot256/armcortexm_3/crypto_aead.h | 17 +++++++++++++++++ knot/Implementations/crypto_aead/knot256/armcortexm_3/encrypt.c | 330 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 16 files changed, 1606 insertions(+) create mode 100644 knot/Implementations/crypto_aead/knot128v1/armcortexm_3/api.h create mode 100644 knot/Implementations/crypto_aead/knot128v1/armcortexm_3/auxFormat.h create mode 100644 knot/Implementations/crypto_aead/knot128v1/armcortexm_3/crypto_aead.h create mode 100644 knot/Implementations/crypto_aead/knot128v1/armcortexm_3/encrypt.c create mode 100644 knot/Implementations/crypto_aead/knot128v2/armcortexm_3/api.h create mode 100644 knot/Implementations/crypto_aead/knot128v2/armcortexm_3/auxFormat.h create mode 100644 knot/Implementations/crypto_aead/knot128v2/armcortexm_3/crypto_aead.h create mode 100644 knot/Implementations/crypto_aead/knot128v2/armcortexm_3/encrypt.c create mode 100644 knot/Implementations/crypto_aead/knot192/armcortexm_3/api.h create mode 100644 knot/Implementations/crypto_aead/knot192/armcortexm_3/auxFormat.h create mode 100644 knot/Implementations/crypto_aead/knot192/armcortexm_3/crypto_aead.h create mode 100644 knot/Implementations/crypto_aead/knot192/armcortexm_3/encrypt.c create mode 100644 knot/Implementations/crypto_aead/knot256/armcortexm_3/api.h create mode 100644 knot/Implementations/crypto_aead/knot256/armcortexm_3/auxFormat.h create mode 100644 knot/Implementations/crypto_aead/knot256/armcortexm_3/crypto_aead.h create mode 100644 knot/Implementations/crypto_aead/knot256/armcortexm_3/encrypt.c diff --git a/knot/Implementations/crypto_aead/knot128v1/armcortexm_3/api.h b/knot/Implementations/crypto_aead/knot128v1/armcortexm_3/api.h new file mode 100644 index 0000000..6e591c3 --- /dev/null +++ b/knot/Implementations/crypto_aead/knot128v1/armcortexm_3/api.h @@ -0,0 +1,9 @@ + +#define CRYPTO_KEYBYTES 16 // +#define CRYPTO_NSECBYTES 0 +#define CRYPTO_NPUBBYTES 16 +#define CRYPTO_ABYTES 16 +#define CRYPTO_NOOVERLAP 1 + + + diff --git a/knot/Implementations/crypto_aead/knot128v1/armcortexm_3/auxFormat.h b/knot/Implementations/crypto_aead/knot128v1/armcortexm_3/auxFormat.h new file mode 100644 index 0000000..50bc7a8 --- /dev/null +++ b/knot/Implementations/crypto_aead/knot128v1/armcortexm_3/auxFormat.h @@ -0,0 +1,68 @@ +#include"crypto_aead.h" +#include"api.h" +#include +#define U32BIG(x) (x) + + +#define ARR_SIZE(a) (sizeof((a))/sizeof((a[0]))) +#define LOTR32(x,n) (((x)<<(n))|((x)>>(32-(n)))) + + +#define sbox(a, b, c, d, e, f, g, h) \ +{ \ + t1 = ~a; t2 = b & t1;t3 = c ^ t2; h = d ^ t3; t5 = b | c; t6 = d ^ t1; g = t5 ^ t6; t8 = b ^ d; t9 = t3 & t6; e = t8 ^ t9; t11 = g & t8; f = t3 ^ t11; \ +} + +typedef unsigned char u8; +typedef unsigned int u32; +typedef unsigned long long u64; +#define packFormat(out,in) {\ +t1 = U32BIG(((u32*)in)[0]); \ +t2 = U32BIG(((u32*)in)[1]); \ +t3 = (t1 ^ (t1 >> 1)) & 0x22222222, t1 ^= t3 ^ (t3 << 1); \ +t3 = (t1 ^ (t1 >> 2)) & 0x0C0C0C0C, t1 ^= t3 ^ (t3 << 2); \ +t3 = (t1 ^ (t1 >> 4)) & 0x00F000F0, t1 ^= t3 ^ (t3 << 4); \ +t3 = (t1 ^ (t1 >> 8)) & 0x0000FF00, t1 ^= t3 ^ (t3 << 8); \ +t5 = (t2 ^ (t2 >> 1)) & 0x22222222, t2 ^= t5 ^ (t5 << 1); \ +t5 = (t2 ^ (t2 >> 2)) & 0x0C0C0C0C, t2 ^= t5 ^ (t5 << 2); \ +t5 = (t2 ^ (t2 >> 4)) & 0x00F000F0, t2 ^= t5 ^ (t5 << 4); \ +t5 = (t2 ^ (t2 >> 8)) & 0x0000FF00, t2 ^= t5 ^ (t5 << 8); \ +out[0] = (t2 & 0xFFFF0000) | (t1 >> 16); \ +out[1] = (t2 << 16) | (t1 & 0x0000FFFF); \ +} +#define unpackFormat(out, in) {\ + t2 = (in[0] & 0xFFFF0000) | (in[1] >> 16); \ + t1 = (in[1] & 0x0000FFFF) | (in[0] << 16); \ + t3 = (t1 ^ (t1 >> 8)) & 0x0000FF00, t1 ^= t3 ^ (t3 << 8); \ + t3 = (t1 ^ (t1 >> 4)) & 0x00F000F0, t1 ^= t3 ^ (t3 << 4); \ + t3 = (t1 ^ (t1 >> 2)) & 0x0C0C0C0C, t1 ^= t3 ^ (t3 << 2); \ + t3 = (t1 ^ (t1 >> 1)) & 0x22222222, t1 ^= t3 ^ (t3 << 1); \ + t5 = (t2 ^ (t2 >> 8)) & 0x0000FF00, t2 ^= t5 ^ (t5 << 8); \ + t5 = (t2 ^ (t2 >> 4)) & 0x00F000F0, t2 ^= t5 ^ (t5 << 4); \ + t5 = (t2 ^ (t2 >> 2)) & 0x0C0C0C0C, t2 ^= t5 ^ (t5 << 2); \ + t5 = (t2 ^ (t2 >> 1)) & 0x22222222, t2 ^= t5 ^ (t5 << 1); \ + *((u64*)out) = ((u64)t2 << 32 | t1); \ +} +#define getU32Format(out, in) {\ + t1, t2 = U32BIG(((u32*)in)[0]); \ + t1 = (t2 ^ (t2 >> 1)) & 0x22222222, t2 ^= t1 ^ (t1 << 1); \ + t1 = (t2 ^ (t2 >> 2)) & 0x0C0C0C0C, t2 ^= t1 ^ (t1 << 2); \ + t1 = (t2 ^ (t2 >> 4)) & 0x00F000F0, t2 ^= t1 ^ (t1 << 4); \ + t1 = (t2 ^ (t2 >> 8)) & 0x0000FF00, t2 ^= t1 ^ (t1 << 8); \ + *out = t2; \ +} +#define ROUND256( constant6Format,lunNum) {\ + s[0] ^= constant6Format[lunNum]>> 4;\ + s[1] ^= constant6Format[lunNum]& 0x0f;\ + sbox(s[0], s[2], s[4], s[6], s_temp[0], s_temp[2], s_temp[4], s_temp[6]);\ + sbox(s[1], s[3], s[5], s[7], s_temp[1], s_temp[3], s_temp[5], s_temp[7]);\ + s[0] = s_temp[0];\ + s[1] = s_temp[1];\ + s[2] = s_temp[3];\ + s[3] = LOTR32(s_temp[2], 1);\ + s[4] = LOTR32(s_temp[4], 4);\ + s[5] = LOTR32(s_temp[5], 4);\ + s[6] = LOTR32(s_temp[7], 12);\ + s[7] = LOTR32(s_temp[6], 13);\ +} + diff --git a/knot/Implementations/crypto_aead/knot128v1/armcortexm_3/crypto_aead.h b/knot/Implementations/crypto_aead/knot128v1/armcortexm_3/crypto_aead.h new file mode 100644 index 0000000..862d176 --- /dev/null +++ b/knot/Implementations/crypto_aead/knot128v1/armcortexm_3/crypto_aead.h @@ -0,0 +1,18 @@ + +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 +); + +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 +); diff --git a/knot/Implementations/crypto_aead/knot128v1/armcortexm_3/encrypt.c b/knot/Implementations/crypto_aead/knot128v1/armcortexm_3/encrypt.c new file mode 100644 index 0000000..91f9f42 --- /dev/null +++ b/knot/Implementations/crypto_aead/knot128v1/armcortexm_3/encrypt.c @@ -0,0 +1,246 @@ + +#include"auxFormat.h" + +#define RATE (64 / 8) + +#define PR0_ROUNDS 52 +#define PR_ROUNDS 28 +#define PRF_ROUNDS 32 +unsigned char constant6Format[63] = { + /*constant6_aead_128v1:*/ +0x1, +0x10, +0x2, +0x20, +0x4, +0x41, +0x11, +0x12, +0x22, +0x24, +0x45, +0x50, +0x3, +0x30, +0x6, +0x61, +0x15, +0x53, +0x33, +0x36, +0x67, +0x74, +0x46, +0x60, +0x5, +0x51, +0x13, +0x32, +0x26, +0x65, +0x54, +0x42, +0x21, +0x14, +0x43, +0x31, +0x16, +0x63, +0x35, +0x57, +0x72, +0x27, +0x75, +0x56, +0x62, +0x25, +0x55, +0x52, +0x23, +0x34, +0x47, +0x70, +0x7, +0x71, +0x17, +0x73, +0x37, +0x77, +0x76, +0x66, +0x64, +0x44, +0x40, + +}; + + + +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) { + unsigned int i, j; + u32 s[8] = { 0 }; + u32 dataFormat[2] = { 0 }; + u8 tempData[8]; + u32 s_temp[8] = { 0 }; + u32 t1, t2, t3, t5, t6, t8, t9, t11; + *clen = mlen + CRYPTO_ABYTES; + //initialization + packFormat(s, npub); + packFormat((s + 2), (npub + 8)); + packFormat((s + 4), k); + packFormat((s + 6), (k + 8)); + for (i = 0; i < PR0_ROUNDS; i++) { + ROUND256(constant6Format,i); + } + // process associated data + if (adlen) { + //rlen = adlen; + while (adlen >= RATE) { + packFormat(dataFormat, ad); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND256(constant6Format, i); + } + adlen -= RATE; + ad += RATE; + } + memset(tempData, 0, sizeof(tempData)); +memcpy(tempData, ad, adlen * sizeof(unsigned char)); +tempData[adlen] = 0x01; + packFormat(dataFormat, tempData); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND256(constant6Format, i); + } + } + s[6] ^= 0x80000000; + if (mlen) { + while (mlen >= RATE) { + packFormat(dataFormat, m); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + unpackFormat(c, s); + for (i = 0; i < PR_ROUNDS; i++) { + ROUND256(constant6Format, i); + } + mlen -= RATE; + m += RATE; + c += RATE; + } + memset(tempData, 0, sizeof(tempData)); +memcpy(tempData, m, mlen * sizeof(unsigned char)); + +tempData[mlen]= 0x01; + packFormat(dataFormat, tempData); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + unpackFormat(tempData, s); + memcpy(c, tempData, mlen * sizeof(unsigned char)); + c +=mlen; + } + // finalization + for (i = 0; i < PRF_ROUNDS; i++) { + ROUND256(constant6Format, i); + } + // return tag + unpackFormat(tempData, s); + memcpy(c, tempData, sizeof(tempData)); + unpackFormat(tempData,(s + 2)); + memcpy(c+8, tempData, sizeof(tempData)); +// unpackFormat((c), s); +// unpackFormat((c+8),(s + 2)); + 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) { + u8 i, j; + // initialization + //256/32=8 + u32 s[8] = { 0 }; + u32 dataFormat[4] = { 0 }; + u32 dataFormat_1[2] = { 0 }; + u8 tempU8[32] = { 0 }; + u8 tempData[8]; + u32 s_temp[8] = { 0 }; + u32 t1, t2, t3, t5, t6, t8, t9, t11; + *mlen = clen - CRYPTO_ABYTES; + if (clen < CRYPTO_ABYTES) + return -1; + //initialization + packFormat(s, npub); + packFormat((s + 2), (npub + 8)); + packFormat((s + 4), k); + packFormat((s + 6), (k + 8)); + for (i = 0; i < PR0_ROUNDS; i++) { + ROUND256(constant6Format, i); + } + // process associated data + if (adlen) { + while (adlen >= RATE) { + packFormat(dataFormat, ad); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND256(constant6Format, i); + } + adlen -= RATE; + ad += RATE; + } + memset(tempData, 0, sizeof(tempData)); + memcpy(tempData, ad, adlen * sizeof(unsigned char)); + tempData[adlen] = 0x01; + packFormat(dataFormat, tempData); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND256(constant6Format, i); + } + } + s[6] ^= 0x80000000; + // process c + clen = clen - CRYPTO_KEYBYTES; + if (clen) { + while (clen >= RATE) { + packFormat(dataFormat, c); + dataFormat_1[0] = s[0] ^ dataFormat[0]; + dataFormat_1[1] = s[1] ^ dataFormat[1]; + unpackFormat(m, dataFormat_1); + s[0] = dataFormat[0]; + s[1] = dataFormat[1]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND256(constant6Format, i); + } + clen -= RATE; + m += RATE; + c += RATE; + } + unpackFormat(tempU8, s); + for (i = 0; i < clen; ++i, ++m, ++c) + { + *m = tempU8[i]^ *c; + tempU8[i] = *c; + } + tempU8[i] ^= 0x01; + packFormat(s, tempU8); + } + // finalization + for (i = 0; i < PRF_ROUNDS; i++) { + ROUND256(constant6Format, i); + } + // return tag + packFormat(dataFormat, c); + packFormat((dataFormat + 2), (c +8)); + if (dataFormat[0] != s[0] || dataFormat[1] != s[1] || dataFormat[2] != s[2] || dataFormat[3] != s[3]) { + return -1; + } + return 0; +} diff --git a/knot/Implementations/crypto_aead/knot128v2/armcortexm_3/api.h b/knot/Implementations/crypto_aead/knot128v2/armcortexm_3/api.h new file mode 100644 index 0000000..084356b --- /dev/null +++ b/knot/Implementations/crypto_aead/knot128v2/armcortexm_3/api.h @@ -0,0 +1,8 @@ +#define CRYPTO_KEYBYTES 16 +#define CRYPTO_NSECBYTES 0 +#define CRYPTO_NPUBBYTES 16 +#define CRYPTO_ABYTES 16 +#define CRYPTO_NOOVERLAP 1 + + + diff --git a/knot/Implementations/crypto_aead/knot128v2/armcortexm_3/auxFormat.h b/knot/Implementations/crypto_aead/knot128v2/armcortexm_3/auxFormat.h new file mode 100644 index 0000000..45ad28d --- /dev/null +++ b/knot/Implementations/crypto_aead/knot128v2/armcortexm_3/auxFormat.h @@ -0,0 +1,142 @@ +//#include +#include"crypto_aead.h" +#include"api.h" +#include +#include +#include +#define U32BIG(x) (x) + +typedef unsigned char u8; +typedef unsigned int u32; +typedef unsigned long long u64; + +#define ARR_SIZE(a) (sizeof((a))/sizeof((a[0]))) +#define LOTR32(x,n) (((x)<<(n))|((x)>>(32-(n)))) + + +#define puckU32ToThree(x){\ +x &= 0x92492492;\ +x = (x | (x << 2)) & 0xc30c30c3;\ +x = (x | (x << 4)) & 0xf00f00f0;\ +x = (x | (x << 8)) & 0xff0000ff;\ +x = (x | (x << 16)) & 0xfff00000;\ +} +#define unpuckU32ToThree(x){\ +x &= 0xfff00000;\ +x = (x | (x >> 16)) & 0xff0000ff;\ +x = (x | (x >> 8)) & 0xf00f00f0;\ +x = (x | (x >> 4)) & 0xc30c30c3;\ +x = (x | (x >> 2)) & 0x92492492;\ +} + +#define packU32FormatToThreePacket( out, in) {\ +t2 = U32BIG(((u32*)in)[0]); \ +t2_64 = (in[3] & 0x80) >> 7, t2_65 = (in[3] & 0x40) >> 6; \ +t2 = t2 << 2; \ +temp2[0] = t2; temp2[1] = t2 << 1; temp2[2] = t2 << 2; \ +puckU32ToThree(temp2[0]); \ +puckU32ToThree(temp2[1]); \ +puckU32ToThree(temp2[2]); \ +out[0] = (temp2[0] >> 22); \ +out[1] = (((u32)t2_64) << 10) | (temp2[1] >> 22); \ +out[2] =(((u32)t2_65) << 10) | (temp2[2] >> 22); \ +} + +#define packU96FormatToThreePacket(out, in) {\ +t9 = U32BIG(((u32*)in)[2]); \ +t1 = U32BIG(((u32*)in)[1]); \ +t2 = U32BIG(((u32*)in)[0]); \ +t1_32 = (in[7] & 0x80) >> 7, t2_64 = (in[3] & 0x80) >> 7, t2_65 = (in[3] & 0x40) >> 6; \ +t1 = t1 << 1; \ +t2 = t2 << 2; \ +temp0[0] = t9; temp0[1] = t9 << 1; temp0[2] = t9 << 2; \ +puckU32ToThree(temp0[0]); \ +puckU32ToThree(temp0[1]); \ +puckU32ToThree(temp0[2]); \ +temp1[0] = t1; temp1[1] = t1 << 1; temp1[2] = t1 << 2; \ +puckU32ToThree(temp1[0]); \ +puckU32ToThree(temp1[1]); \ +puckU32ToThree(temp1[2]); \ +temp2[0] = t2; temp2[1] = t2 << 1; temp2[2] = t2 << 2; \ +puckU32ToThree(temp2[0]); \ +puckU32ToThree(temp2[1]); \ +puckU32ToThree(temp2[2]); \ +out[0] = (temp0[0]) | (temp1[0] >> 11) | (temp2[0] >> 22); \ +out[1] = (temp0[1]) | (temp1[1] >> 11) | (((u32)t2_64) << 10) | (temp2[1] >> 22); \ +out[2] = (temp0[2]) | (((u32)t1_32) << 21) | (temp1[2] >> 11) | (((u32)t2_65) << 10) | (temp2[2] >> 22); \ +} + +#define unpackU32FormatToThreePacket(out, in) {\ +temp2[0] = (in[0] & 0x000003ff) << 22; \ +t2_64 = ((in[1] & 0x00000400) << 21); \ +temp2[1] = (in[1] & 0x000003ff) << 22; \ +t2_65 = ((in[2] & 0x00000400) << 20); \ +temp2[2] = (in[2] & 0x000003ff) << 22; \ +unpuckU32ToThree(temp2[0]); \ +unpuckU32ToThree(temp2[1]); \ +unpuckU32ToThree(temp2[2]); \ +t2 = t2_65 | t2_64 | ((temp2[0] | temp2[1] >> 1 | temp2[2] >> 2) >> 2); \ +*(u32*)(out) = U32BIG(t2); \ +} + +#define unpackU96FormatToThreePacket( out, in) {\ +temp0[0] = in[0] & 0xffe00000; \ +temp1[0] = (in[0] & 0x001ffc00) << 11; \ +temp2[0] = (in[0] & 0x000003ff) << 22; \ +temp0[1] = in[1] & 0xffe00000; \ +temp1[1] = (in[1] & 0x001ff800) << 11; \ +t2_64 = ((in[1] & 0x00000400) << 21); \ +temp2[1] = (in[1] & 0x000003ff) << 22; \ +temp0[2] = in[2] & 0xffc00000; \ +t1_32 = ((in[2] & 0x00200000) << 10); \ +temp1[2] = (in[2] & 0x001ff800) << 11; \ +t2_65 = ((in[2] & 0x00000400) << 20); \ +temp2[2] = (in[2] & 0x000003ff) << 22; \ +unpuckU32ToThree(temp0[0]); \ +unpuckU32ToThree(temp0[1]); \ +unpuckU32ToThree(temp0[2]); \ +t9 = temp0[0] | temp0[1] >> 1 | temp0[2] >> 2; \ +unpuckU32ToThree(temp1[0]); \ +unpuckU32ToThree(temp1[1]); \ +unpuckU32ToThree(temp1[2]); \ +t1 = t1_32 | ((temp1[0] | temp1[1] >> 1 | temp1[2] >> 2) >> 1); \ +unpuckU32ToThree(temp2[0]); \ +unpuckU32ToThree(temp2[1]); \ +unpuckU32ToThree(temp2[2]); \ +t2 = t2_65 | t2_64 | ((temp2[0] | temp2[1] >> 1 | temp2[2] >> 2) >> 2); \ +*(u32*)(out) = U32BIG(t2); \ +*(u32*)(out + 4) = U32BIG(t1); \ +*(u32*)(out + 8) = U32BIG(t9); \ +} + +#define ARR_SIZE(a) (sizeof((a))/sizeof((a[0]))) +#define sbox(a, b, c, d, e, f, g, h) \ +{ \ + t1 = ~a; t2 = b & t1;t3 = c ^ t2; h = d ^ t3; t5 = b | c; t6 = d ^ t1; g = t5 ^ t6; t8 = b ^ d; t9 = t3 & t6; e = t8 ^ t9; t11 = g & t8; f = t3 ^ t11; \ +} + + +#define U96_BIT_LOTR32_1(t0,t1,t2,t3,t4,t5){\ +t3= t1;\ +t4 = t2;\ +t5 = LOTR32(t0, 1); \ +} +#define U96_BIT_LOTR32_8(t0,t1,t2,t3,t4,t5){\ +t3= LOTR32(t2, 2);\ +t4 =LOTR32(t0, 3);\ +t5 = LOTR32(t1, 3); \ +} + +#define U96_BIT_LOTR32_55(t0,t1,t2,t3,t4,t5){\ +t3= LOTR32(t1, 18); \ +t4 = LOTR32(t2, 18);\ +t5 = LOTR32(t0, 19); \ +} +/* +s0 s1 s2 +s3 s4 s5 +s6 s7 s8 +s9 s10 s11 +*/ + + diff --git a/knot/Implementations/crypto_aead/knot128v2/armcortexm_3/crypto_aead.h b/knot/Implementations/crypto_aead/knot128v2/armcortexm_3/crypto_aead.h new file mode 100644 index 0000000..cdfdf19 --- /dev/null +++ b/knot/Implementations/crypto_aead/knot128v2/armcortexm_3/crypto_aead.h @@ -0,0 +1,17 @@ +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 +); + +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 +); diff --git a/knot/Implementations/crypto_aead/knot128v2/armcortexm_3/encrypt.c b/knot/Implementations/crypto_aead/knot128v2/armcortexm_3/encrypt.c new file mode 100644 index 0000000..1245313 --- /dev/null +++ b/knot/Implementations/crypto_aead/knot128v2/armcortexm_3/encrypt.c @@ -0,0 +1,263 @@ + +#include"auxFormat.h" + + + +#define aead_RATE (192 / 8) +#define PR0_ROUNDS 76 +#define PR_ROUNDS 28 +#define PRF_ROUNDS 32 + +unsigned char constant7Format[127] = { + /*constant7Format[127]:*/ + 0x01,0x08,0x40,0x02,0x10,0x80,0x05,0x09,0x48,0x42,0x12,0x90, + 0x85,0x0c,0x41,0x0a,0x50,0x82,0x15,0x89,0x4d,0x4b,0x5a,0xd2, + 0x97,0x9c,0xc4,0x06,0x11,0x88,0x45,0x0b,0x58,0xc2,0x17,0x99, + 0xcd,0x4e,0x53,0x9a,0xd5,0x8e,0x54,0x83,0x1d,0xc9,0x4f,0x5b, + 0xda,0xd7,0x9e,0xd4,0x86,0x14,0x81,0x0d,0x49,0x4a,0x52,0x92, + 0x95,0x8c,0x44,0x03,0x18,0xc0,0x07,0x19,0xc8,0x47,0x1b,0xd8, + 0xc7,0x1e,0xd1,0x8f,0x5c,0xc3,0x1f,0xd9,0xcf,0x5e,0xd3,0x9f, + 0xdc,0xc6,0x16,0x91,0x8d,0x4c,0x43,0x1a,0xd0,0x87,0x1c,0xc1, + 0x0f,0x59,0xca,0x57,0x9b,0xdd,0xce,0x56,0x93,0x9d,0xcc,0x46, + 0x13,0x98,0xc5,0x0e,0x51,0x8a,0x55,0x8b,0x5d,0xcb,0x5f,0xdb, + 0xdf,0xde,0xd6,0x96,0x94,0x84,0x04, }; +#define ROUND384(lunNum) {\ +s[0] ^= (constant7Format[lunNum] >> 6) & 0x3;\ +s[1] ^= (constant7Format[lunNum] >> 3) & 0x7;\ +s[2] ^= constant7Format[lunNum] & 0x7;\ +sbox(s[0], s[3], s[6], s[9] , s_temp[0], s_temp[3], s_temp[6], s_temp[9]);\ +sbox(s[1], s[4], s[7], s[10], s_temp[1], s_temp[4], s_temp[7], s_temp[10]);\ +sbox(s[2], s[5], s[8], s[11], s_temp[2], s_temp[5], s_temp[8], s_temp[11]);\ +s[0] = s_temp[0], s[1] = s_temp[1], s[2] = s_temp[2];\ +U96_BIT_LOTR32_1(s_temp[3], s_temp [4], s_temp[ 5], s[3], s[4], s[5]);\ +U96_BIT_LOTR32_8(s_temp[6], s_temp [7], s_temp[ 8], s[6], s[7], s[8]);\ +U96_BIT_LOTR32_55(s_temp[9], s_temp[10], s_temp[11], s[9], s[10], s[11]);\ +} +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) { + u8 i; + u32 s[12] = { 0 }; + u8 tempData[24] = { 0 }; + u32 dataFormat[6] = { 0 }; + u32 s_temp[12] = { 0 }; + u32 t1, t2, t3, t5, t6, t8, t9, t11; + u32 t1_32, t2_64, t2_65; + u32 temp0[3] = { 0 }; + u32 temp1[3] = { 0 }; + u32 temp2[3] = { 0 }; + + *clen = mlen + CRYPTO_ABYTES; + // initialization + packU96FormatToThreePacket(s, npub); + memcpy(tempData, npub+12, sizeof(unsigned char)*4); + memcpy(tempData+4, k, sizeof(unsigned char) * 16); + packU96FormatToThreePacket((s + 3), tempData); + packU96FormatToThreePacket((s + 6), (tempData+12)); + + s[9] = 0x80000000; + for (i = 0; i < PR0_ROUNDS; i++) { + ROUND384(i); + } + // process associated data + if (adlen) { + // rlen = adlen; + while (adlen >= aead_RATE) { + packU96FormatToThreePacket(dataFormat, ad); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + packU96FormatToThreePacket((dataFormat+3), (ad+12)); + s[3] ^= dataFormat[3]; + s[4] ^= dataFormat[4]; + s[5] ^= dataFormat[5]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND384(i); + } + adlen -= aead_RATE; + ad += aead_RATE; + } + memset(tempData, 0, sizeof(tempData)); + memcpy(tempData, ad, adlen * sizeof(unsigned char)); + tempData[adlen] = 0x01; + packU96FormatToThreePacket(dataFormat, tempData); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + packU96FormatToThreePacket((dataFormat + 3), (tempData + 12)); + s[3] ^= dataFormat[3]; + s[4] ^= dataFormat[4]; + s[5] ^= dataFormat[5]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND384(i); + } + } + s[9] ^= 0x80000000; + if (mlen) { + //rlen = mlen; + while (mlen >= aead_RATE) { + packU96FormatToThreePacket(dataFormat, m); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + packU96FormatToThreePacket((dataFormat + 3), (m + 12)); + s[3] ^= dataFormat[3]; + s[4] ^= dataFormat[4]; + s[5] ^= dataFormat[5]; + unpackU96FormatToThreePacket(c, s); + unpackU96FormatToThreePacket((c+12), (s+3)); + for (i = 0; i < PR_ROUNDS; i++) { + ROUND384(i); + } + mlen -= aead_RATE; + m += aead_RATE; + c += aead_RATE; + } + memset(tempData, 0, sizeof(tempData)); + memcpy(tempData, m, mlen * sizeof(unsigned char)); + tempData[mlen]= 0x01; + packU96FormatToThreePacket(dataFormat, tempData); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + packU96FormatToThreePacket((dataFormat + 3), (tempData + 12)); + s[3] ^= dataFormat[3]; + s[4] ^= dataFormat[4]; + s[5] ^= dataFormat[5]; + unpackU96FormatToThreePacket(tempData, s); + unpackU96FormatToThreePacket((tempData+12), (s+3)); + memcpy(c, tempData, mlen * sizeof(unsigned char)); + c += mlen; + } + // finalization + for (i = 0; i < PRF_ROUNDS; i++) { + ROUND384(i); + } + // return tag + unpackU96FormatToThreePacket(c, s); + unpackU96FormatToThreePacket(tempData, (s + 3)); + + memcpy(c+12, tempData, sizeof(unsigned char) * 4); + 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) { + + u8 i, j; + u32 s[12] = { 0 }; + u32 s_temp[12] = { 0 }; + u32 dataFormat[12] = { 0 }; + u32 dataFormat_1[12] = { 0 }; + u8 tempData[24] = { 0 }; + u8 tempU8[24] = { 0 }; + u32 t1, t2, t3, t5, t6, t8, t9, t11; + u32 t1_32, t2_64, t2_65; + u32 temp0[3] = { 0 }; + u32 temp1[3] = { 0 }; + u32 temp2[3] = { 0 }; *mlen = clen - CRYPTO_ABYTES; + if (clen < CRYPTO_ABYTES) + return -1; + // initialization + packU96FormatToThreePacket(s, npub); + memcpy(tempData, npub + 12, sizeof(unsigned char) * 4); + memcpy(tempData + 4, k, sizeof(unsigned char) * 16); + packU96FormatToThreePacket((s + 3), tempData); + packU96FormatToThreePacket((s + 6), (tempData + 12)); + + s[9] = 0x80000000; + for (i = 0; i < PR0_ROUNDS; i++) { + ROUND384(i); + } + // process associated data + if (adlen) { + // rlen = adlen; + while (adlen >= aead_RATE) { + packU96FormatToThreePacket(dataFormat, ad); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + packU96FormatToThreePacket((dataFormat + 3), (ad + 12)); + s[3] ^= dataFormat[3]; + s[4] ^= dataFormat[4]; + s[5] ^= dataFormat[5]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND384(i); + } + adlen -= aead_RATE; + ad += aead_RATE; + } + memset(tempData, 0, sizeof(tempData)); + memcpy(tempData, ad, adlen * sizeof(unsigned char)); + tempData[adlen] = 0x01; + packU96FormatToThreePacket(dataFormat, tempData); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + packU96FormatToThreePacket((dataFormat + 3), (tempData + 12)); + s[3] ^= dataFormat[3]; + s[4] ^= dataFormat[4]; + s[5] ^= dataFormat[5]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND384(i); + } + } + s[9] ^= 0x80000000; + /////////// + clen -= CRYPTO_ABYTES; + if (clen) { + while (clen >= aead_RATE) { + packU96FormatToThreePacket(dataFormat, c); + dataFormat_1[0] = s[0] ^ dataFormat[0]; + dataFormat_1[1] = s[1] ^ dataFormat[1]; + dataFormat_1[2] = s[2] ^ dataFormat[2]; + packU96FormatToThreePacket((dataFormat+3), (c+12)); + dataFormat_1[3] = s[3] ^ dataFormat[3]; + dataFormat_1[4] = s[4] ^ dataFormat[4]; + dataFormat_1[5] = s[5] ^ dataFormat[5]; + unpackU96FormatToThreePacket(m, dataFormat_1); + unpackU96FormatToThreePacket((m + 12), (dataFormat_1 + 3)); + s[0] = dataFormat[0]; + s[1] = dataFormat[1]; + s[2] = dataFormat[2]; + s[3] = dataFormat[3]; + s[4] = dataFormat[4]; + s[5] = dataFormat[5]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND384(i); + } + clen -= aead_RATE; + m += aead_RATE; + c += aead_RATE; + } + unpackU96FormatToThreePacket(tempU8, s); + unpackU96FormatToThreePacket((tempU8+12), (s+3)); + for (i = 0; i < clen; ++i, ++m, ++c) + { + *m = tempU8[i] ^ *c; + tempU8[i] = *c; + } + tempU8[i] ^= 0x01; + packU96FormatToThreePacket(s, tempU8); + packU96FormatToThreePacket((s + 3), (tempU8 + 12)); + } + // finalization + for (i = 0; i < PRF_ROUNDS; i++) { + ROUND384(i); + } + // return tag + + unpackU96FormatToThreePacket(tempU8, s); + unpackU96FormatToThreePacket((tempU8+12), (s+3)); + if (U32BIG(((u32*)tempU8)[0]) != U32BIG(((u32*)c)[0]) || + U32BIG(((u32*)tempU8)[1]) != U32BIG(((u32*)c)[1]) || + U32BIG(((u32*)tempU8)[2]) != U32BIG(((u32*)c)[2]) || + U32BIG(((u32*)tempU8)[3]) != U32BIG(((u32*)c)[3]) ){ + return -1; + } + return 0; +} diff --git a/knot/Implementations/crypto_aead/knot192/armcortexm_3/api.h b/knot/Implementations/crypto_aead/knot192/armcortexm_3/api.h new file mode 100644 index 0000000..c3cb1d9 --- /dev/null +++ b/knot/Implementations/crypto_aead/knot192/armcortexm_3/api.h @@ -0,0 +1,6 @@ +#define CRYPTO_KEYBYTES 24 +#define CRYPTO_NSECBYTES 0 +#define CRYPTO_NPUBBYTES 24 +#define CRYPTO_ABYTES 24 +#define CRYPTO_NOOVERLAP 1 + diff --git a/knot/Implementations/crypto_aead/knot192/armcortexm_3/auxFormat.h b/knot/Implementations/crypto_aead/knot192/armcortexm_3/auxFormat.h new file mode 100644 index 0000000..a617f8e --- /dev/null +++ b/knot/Implementations/crypto_aead/knot192/armcortexm_3/auxFormat.h @@ -0,0 +1,128 @@ + +#include"crypto_aead.h" +#include"api.h" +#include +#include +#include +#define U32BIG(x) (x) +#define U16BIG(x) (x) + +typedef unsigned char u8; +typedef unsigned short u16; +typedef unsigned int u32; +typedef unsigned long long u64; + +#define ARR_SIZE(a) (sizeof((a))/sizeof((a[0]))) +#define LOTR32(x,n) (((x)<<(n))|((x)>>(32-(n)))) + + +#define ARR_SIZE(a) (sizeof((a))/sizeof((a[0]))) +#define sbox(a, b, c, d, e, f, g, h) \ +{ \ + t1 = ~a; t2 = b & t1;t3 = c ^ t2; h = d ^ t3; t5 = b | c; t6 = d ^ t1; g = t5 ^ t6; t8 = b ^ d; t9 = t3 & t6; e = t8 ^ t9; t11 = g & t8; f = t3 ^ t11; \ +} + +#define puckU32ToThree(x){\ +x &= 0x92492492;\ +x = (x | (x << 2)) & 0xc30c30c3;\ +x = (x | (x << 4)) & 0xf00f00f0;\ +x = (x | (x << 8)) & 0xff0000ff;\ +x = (x | (x << 16)) & 0xfff00000;\ +} +#define unpuckU32ToThree(x){\ +x &= 0xfff00000;\ +x = (x | (x >> 16)) & 0xff0000ff;\ +x = (x | (x >> 8)) & 0xf00f00f0;\ +x = (x | (x >> 4)) & 0xc30c30c3;\ +x = (x | (x >> 2)) & 0x92492492;\ +} +#define packU48FormatToThreePacket( out, in) {\ +t1 = (u32)U16BIG(*(u16*)(in + 4)); \ +t2 = U32BIG(*(u32*)(in)); \ +t2_64 = (in[3] & 0x80) >> 7, t2_65 = (in[3] & 0x40) >> 6; \ +t1 = t1 << 1; \ +t2 = t2 << 2; \ +temp1[0] = t1; temp1[1] = t1 << 1; temp1[2] = t1 << 2; \ +puckU32ToThree(temp1[0]); \ +puckU32ToThree(temp1[1]); \ +puckU32ToThree(temp1[2]); \ +temp2[0] = t2; temp2[1] = t2 << 1; temp2[2] = t2 << 2; \ +puckU32ToThree(temp2[0]); \ +puckU32ToThree(temp2[1]); \ +puckU32ToThree(temp2[2]); \ +out[0] = (temp1[0] >> 11) | (temp2[0] >> 22); \ +out[1] = (temp1[1] >> 11) | (((u32)t2_64) << 10) | (temp2[1] >> 22); \ +out[2] = (temp1[2] >> 11) | (((u32)t2_65) << 10) | (temp2[2] >> 22); \ +} + + +#define packU96FormatToThreePacket(out, in) {\ +t9 = U32BIG(((u32*)in)[2]); \ +t1 = U32BIG(((u32*)in)[1]); \ +t2 = U32BIG(((u32*)in)[0]); \ +t1_32 = (in[7] & 0x80) >> 7, t2_64 = (in[3] & 0x80) >> 7, t2_65 = (in[3] & 0x40) >> 6; \ +t1 = t1 << 1; \ +t2 = t2 << 2; \ +temp0[0] = t9; temp0[1] = t9 << 1; temp0[2] = t9 << 2; \ +puckU32ToThree(temp0[0]); \ +puckU32ToThree(temp0[1]); \ +puckU32ToThree(temp0[2]); \ +temp1[0] = t1; temp1[1] = t1 << 1; temp1[2] = t1 << 2; \ +puckU32ToThree(temp1[0]); \ +puckU32ToThree(temp1[1]); \ +puckU32ToThree(temp1[2]); \ +temp2[0] = t2; temp2[1] = t2 << 1; temp2[2] = t2 << 2; \ +puckU32ToThree(temp2[0]); \ +puckU32ToThree(temp2[1]); \ +puckU32ToThree(temp2[2]); \ +out[0] = (temp0[0]) | (temp1[0] >> 11) | (temp2[0] >> 22); \ +out[1] = (temp0[1]) | (temp1[1] >> 11) | (((u32)t2_64) << 10) | (temp2[1] >> 22); \ +out[2] = (temp0[2]) | (((u32)t1_32) << 21) | (temp1[2] >> 11) | (((u32)t2_65) << 10) | (temp2[2] >> 22); \ +} + #define unpackU96FormatToThreePacket( out, in) {\ +temp0[0] = in[0] & 0xffe00000; \ +temp1[0] = (in[0] & 0x001ffc00) << 11; \ +temp2[0] = (in[0] & 0x000003ff) << 22; \ +temp0[1] = in[1] & 0xffe00000; \ +temp1[1] = (in[1] & 0x001ff800) << 11; \ +t2_64 = ((in[1] & 0x00000400) << 21); \ +temp2[1] = (in[1] & 0x000003ff) << 22; \ +temp0[2] = in[2] & 0xffc00000; \ +t1_32 = ((in[2] & 0x00200000) << 10); \ +temp1[2] = (in[2] & 0x001ff800) << 11; \ +t2_65 = ((in[2] & 0x00000400) << 20); \ +temp2[2] = (in[2] & 0x000003ff) << 22; \ +unpuckU32ToThree(temp0[0]); \ +unpuckU32ToThree(temp0[1]); \ +unpuckU32ToThree(temp0[2]); \ +t9 = temp0[0] | temp0[1] >> 1 | temp0[2] >> 2; \ +unpuckU32ToThree(temp1[0]); \ +unpuckU32ToThree(temp1[1]); \ +unpuckU32ToThree(temp1[2]); \ +t1 = t1_32 | ((temp1[0] | temp1[1] >> 1 | temp1[2] >> 2) >> 1); \ +unpuckU32ToThree(temp2[0]); \ +unpuckU32ToThree(temp2[1]); \ +unpuckU32ToThree(temp2[2]); \ +t2 = t2_65 | t2_64 | ((temp2[0] | temp2[1] >> 1 | temp2[2] >> 2) >> 2); \ +*(u32*)(out) = U32BIG(t2); \ +*(u32*)(out + 4) = U32BIG(t1); \ +*(u32*)(out + 8) = U32BIG(t9); \ +} + +#define U96_BIT_LOTR32_1(t0,t1,t2,t3,t4,t5){\ +t3= t1;\ +t4 = t2;\ +t5 = LOTR32(t0, 1); \ +} +#define U96_BIT_LOTR32_8(t0,t1,t2,t3,t4,t5){\ +t3= LOTR32(t2, 2);\ +t4 =LOTR32(t0, 3);\ +t5 = LOTR32(t1, 3); \ +} + +#define U96_BIT_LOTR32_55(t0,t1,t2,t3,t4,t5){\ +t3= LOTR32(t1, 18); \ +t4 = LOTR32(t2, 18);\ +t5 = LOTR32(t0, 19); \ +} + diff --git a/knot/Implementations/crypto_aead/knot192/armcortexm_3/crypto_aead.h b/knot/Implementations/crypto_aead/knot192/armcortexm_3/crypto_aead.h new file mode 100644 index 0000000..862d176 --- /dev/null +++ b/knot/Implementations/crypto_aead/knot192/armcortexm_3/crypto_aead.h @@ -0,0 +1,18 @@ + +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 +); + +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 +); diff --git a/knot/Implementations/crypto_aead/knot192/armcortexm_3/encrypt.c b/knot/Implementations/crypto_aead/knot192/armcortexm_3/encrypt.c new file mode 100644 index 0000000..51c7c12 --- /dev/null +++ b/knot/Implementations/crypto_aead/knot192/armcortexm_3/encrypt.c @@ -0,0 +1,214 @@ + +#include"auxFormat.h" + +#define aead_RATE (96 / 8) +#define PR0_ROUNDS 76 +#define PR_ROUNDS 40 +#define PRF_ROUNDS 44 +unsigned char constant7Format[127] = { + /*constant7Format[127]:*/ +0x01,0x08,0x40,0x02,0x10,0x80,0x05,0x09,0x48,0x42,0x12,0x90, +0x85,0x0c,0x41,0x0a,0x50,0x82,0x15,0x89,0x4d,0x4b,0x5a,0xd2, +0x97,0x9c,0xc4,0x06,0x11,0x88,0x45,0x0b,0x58,0xc2,0x17,0x99, +0xcd,0x4e,0x53,0x9a,0xd5,0x8e,0x54,0x83,0x1d,0xc9,0x4f,0x5b, +0xda,0xd7,0x9e,0xd4,0x86,0x14,0x81,0x0d,0x49,0x4a,0x52,0x92, +0x95,0x8c,0x44,0x03,0x18,0xc0,0x07,0x19,0xc8,0x47,0x1b,0xd8, +0xc7,0x1e,0xd1,0x8f,0x5c,0xc3,0x1f,0xd9,0xcf,0x5e,0xd3,0x9f, +0xdc,0xc6,0x16,0x91,0x8d,0x4c,0x43,0x1a,0xd0,0x87,0x1c,0xc1, +0x0f,0x59,0xca,0x57,0x9b,0xdd,0xce,0x56,0x93,0x9d,0xcc,0x46, +0x13,0x98,0xc5,0x0e,0x51,0x8a,0x55,0x8b,0x5d,0xcb,0x5f,0xdb, +0xdf,0xde,0xd6,0x96,0x94,0x84,0x04, }; +#define ROUND384(lunNum) {\ +s[0] ^= (constant7Format[lunNum] >> 6) & 0x3;\ +s[1] ^= (constant7Format[lunNum] >> 3) & 0x7;\ +s[2] ^= constant7Format[lunNum] & 0x7;\ +sbox(s[0], s[3], s[6], s[9] , s_temp[0], s_temp[3], s_temp[6], s_temp[9]);\ +sbox(s[1], s[4], s[7], s[10], s_temp[1], s_temp[4], s_temp[7], s_temp[10]);\ +sbox(s[2], s[5], s[8], s[11], s_temp[2], s_temp[5], s_temp[8], s_temp[11]);\ +s[0] = s_temp[0], s[1] = s_temp[1], s[2] = s_temp[2];\ +U96_BIT_LOTR32_1(s_temp[3], s_temp [4], s_temp[ 5], s[3], s[4], s[5]);\ +U96_BIT_LOTR32_8(s_temp[6], s_temp [7], s_temp[ 8], s[6], s[7], s[8]);\ +U96_BIT_LOTR32_55(s_temp[9], s_temp[10], s_temp[11], s[9], s[10], s[11]);\ +} +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) { + + u8 i; + u32 s[12] = { 0 }; + u32 dataFormat[3] = { 0 }; + u8 tempData[12] = { 0 }; + u32 s_temp[12] = { 0 }; + u32 t1, t2, t3, t5, t6, t8, t9, t11; + u32 t1_32, t2_64, t2_65; + u32 temp0[3] = { 0 }; + u32 temp1[3] = { 0 }; + u32 temp2[3] = { 0 }; + *clen = mlen + CRYPTO_ABYTES; + // initialization + packU96FormatToThreePacket(s, npub); + packU96FormatToThreePacket((s + 3), (npub + 12)); + packU96FormatToThreePacket((s + 6), k); + packU96FormatToThreePacket((s + 9), (k + 12)); + for (i = 0; i < PR0_ROUNDS; i++) { + ROUND384(i); + } + // process associated data + if (adlen) { + // rlen = adlen; + while (adlen >= aead_RATE) { + packU96FormatToThreePacket(dataFormat, ad); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND384(i); + } + adlen -= aead_RATE; + ad += aead_RATE; + } + memset(tempData, 0, sizeof(tempData)); + memcpy(tempData, ad, adlen); + tempData[adlen] = 0x01; + packU96FormatToThreePacket(dataFormat, tempData); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND384(i); + } + } + s[9] ^= 0x80000000; + if (mlen) { + //rlen = mlen; + while (mlen >= aead_RATE) { + packU96FormatToThreePacket(dataFormat, m); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + unpackU96FormatToThreePacket(c, s); + for (i = 0; i < PR_ROUNDS; i++) { + ROUND384(i); + } + mlen -= aead_RATE; + m += aead_RATE; + c += aead_RATE; + } + memset(tempData, 0, sizeof(tempData)); + memcpy(tempData, m, mlen); + tempData[mlen] = 0x01; + packU96FormatToThreePacket(dataFormat, tempData); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + unpackU96FormatToThreePacket(tempData, s); + memcpy(c, tempData, mlen); + c += mlen; + } + // finalization + for (i = 0; i < PRF_ROUNDS; i++) { + ROUND384(i); + } + // return tag + unpackU96FormatToThreePacket(c, s); + unpackU96FormatToThreePacket((c + 12), (s + 3)); + 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) { + u8 i, j; + u32 s[12] = { 0 }; + u32 dataFormat[6] = { 0 }; + u32 dataFormat_1[3] = { 0 }; + u8 tempData[12] = { 0 }; + u8 tempU8[48] = { 0 }; + u32 s_temp[12] = { 0 }; + u32 t1, t2, t3, t5, t6, t8, t9, t11; + u32 t1_32, t2_64, t2_65; + u32 temp0[3] = { 0 }; + u32 temp1[3] = { 0 }; + u32 temp2[3] = { 0 }; + *mlen = clen - CRYPTO_ABYTES; + if (clen < CRYPTO_ABYTES) + return -1; + // initialization + packU96FormatToThreePacket(s, npub); + packU96FormatToThreePacket((s + 3), (npub + 12)); + packU96FormatToThreePacket((s + 6), k); + packU96FormatToThreePacket((s + 9), (k + 12)); + for (i = 0; i < PR0_ROUNDS; i++) { + ROUND384(i); + } + // process associated data + if (adlen) { + // rlen = adlen; + while (adlen >= aead_RATE) { + packU96FormatToThreePacket(dataFormat, ad); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND384(i); + } + adlen -= aead_RATE; + ad += aead_RATE; + } + memset(tempData, 0, sizeof(tempData)); + + memcpy(tempData, ad, adlen); + tempData[adlen] = 0x01; + packU96FormatToThreePacket(dataFormat, tempData); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND384(i); + } + } + s[9] ^= 0x80000000; + clen -= CRYPTO_ABYTES; + if (clen) { + while (clen >= aead_RATE) { + packU96FormatToThreePacket(dataFormat, c); + dataFormat_1[0] = s[0] ^ dataFormat[0]; + dataFormat_1[1] = s[1] ^ dataFormat[1]; + dataFormat_1[2] = s[2] ^ dataFormat[2]; + unpackU96FormatToThreePacket(m, dataFormat_1); + s[0] = dataFormat[0]; + s[1] = dataFormat[1]; + s[2] = dataFormat[2]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND384(i); + } + clen -= aead_RATE; + m += aead_RATE; + c += aead_RATE; + } + unpackU96FormatToThreePacket(tempU8, s); + for (i = 0; i < clen; ++i, ++m, ++c) + { + *m = tempU8[i] ^ *c; + tempU8[i] = *c; + } + tempU8[i] ^= 0x01; + packU96FormatToThreePacket(s, tempU8); + } + // finalization + for (i = 0; i < PRF_ROUNDS; i++) { + ROUND384(i); + } + // return tag + packU96FormatToThreePacket(dataFormat, c); + packU96FormatToThreePacket((dataFormat + 3), (c + 12)); + if (dataFormat[0] != s[0] || dataFormat[1] != s[1] || dataFormat[2] != s[2] || dataFormat[3] != s[3] + || dataFormat[4] != s[4] || dataFormat[5] != s[5]) { + return -1; + } + ////////// + return 0; +} diff --git a/knot/Implementations/crypto_aead/knot256/armcortexm_3/api.h b/knot/Implementations/crypto_aead/knot256/armcortexm_3/api.h new file mode 100644 index 0000000..b26e378 --- /dev/null +++ b/knot/Implementations/crypto_aead/knot256/armcortexm_3/api.h @@ -0,0 +1,8 @@ +#define CRYPTO_KEYBYTES 32 +#define CRYPTO_NSECBYTES 0 +#define CRYPTO_NPUBBYTES 32 +#define CRYPTO_ABYTES 32 +#define CRYPTO_NOOVERLAP 1 + + + diff --git a/knot/Implementations/crypto_aead/knot256/armcortexm_3/auxFormat.h b/knot/Implementations/crypto_aead/knot256/armcortexm_3/auxFormat.h new file mode 100644 index 0000000..969d758 --- /dev/null +++ b/knot/Implementations/crypto_aead/knot256/armcortexm_3/auxFormat.h @@ -0,0 +1,114 @@ + +#include"crypto_aead.h" +#include"api.h" +#include +#define U32BIG(x) (x) + + +#define ARR_SIZE(a) (sizeof((a))/sizeof((a[0]))) +#define LOTR32(x,n) (((x)<<(n))|((x)>>(32-(n)))) + + +#define sbox(a, b, c, d, e, f, g, h) \ +{ \ + t1 = ~a; t2 = b & t1;t3 = c ^ t2; h = d ^ t3; t5 = b | c; t6 = d ^ t1; g = t5 ^ t6; t8 = b ^ d; t9 = t3 & t6; e = t8 ^ t9; t11 = g & t8; f = t3 ^ t11; \ +} + +typedef unsigned char u8; +typedef unsigned int u32; +typedef unsigned long long u64; +void printU8(char name[], u8 var[], long len, int offset); + + +#define puck32(in)\ +{\ +t9 = (in ^ (in >> 1)) & 0x22222222; in ^= t9 ^ (t9 << 1);\ +t9 = (in ^ (in >> 2)) & 0x0C0C0C0C; in ^= t9 ^ (t9 << 2);\ +t9 = (in ^ (in >> 4)) & 0x00F000F0; in ^= t9 ^ (t9 << 4);\ +t9 = (in ^ (in >> 8)) & 0x0000FF00; in ^= t9 ^ (t9 << 8);\ +} + +#define unpuck32(t0){\ + t9 = (t0 ^ (t0 >> 8)) & 0x0000FF00, t0 ^= t9 ^ (t9 << 8); \ + t9 = (t0 ^ (t0 >> 4)) & 0x00F000F0, t0 ^= t9 ^ (t9 << 4); \ + t9 = (t0 ^ (t0 >> 2)) & 0x0C0C0C0C, t0 ^= t9 ^ (t9 << 2); \ + t9 = (t0 ^ (t0 >> 1)) & 0x22222222, t0 ^= t9 ^ (t9 << 1); \ +} + +#define packU128FormatToFourPacket(out,in) {\ + t8 = U32BIG(((u32*)in)[0]); \ + t1 = U32BIG(((u32*)in)[1]); \ + t2 = U32BIG(((u32*)in)[2]); \ + t3 = U32BIG(((u32*)in)[3]); \ + puck32(t8); puck32(t8); \ + puck32(t1); puck32(t1); \ + puck32(t2); puck32(t2); \ + puck32(t3); puck32(t3); \ + out[3] = t3 & 0xff000000 | ((t2 >> 8) & 0x00ff0000) | ((t1 >> 16) & 0x0000ff00) | (t8 >> 24); \ + out[2] = ((t3 << 8) & 0xff000000) | (t2 & 0x00ff0000) | ((t1 >> 8) & 0x0000ff00) | ((t8 >> 16) & 0x000000ff); \ + out[1] = ((t3 << 16) & 0xff000000) | ((t2 << 8) & 0x00ff0000) | (t1 & 0x0000ff00) | ((t8 >> 8) & 0x000000ff); \ + out[0] = ((t3 << 24) & 0xff000000) | ((t2 << 16) & 0x00ff0000) | ((t1 << 8) & 0x0000ff00) | (t8 & 0x000000ff); \ +} + +#define unpackU128FormatToFourPacket( out, in) {\ +memcpy(dataFormat, in, sizeof(unsigned int) * 4); \ +t3 = dataFormat[3] & 0xff000000 | ((dataFormat[2] >> 8) & 0x00ff0000) | ((dataFormat[1] >> 16) & 0x0000ff00) | (dataFormat[0] >> 24); \ +t2 = ((dataFormat[3] << 8) & 0xff000000) | (dataFormat[2] & 0x00ff0000) | ((dataFormat[1] >> 8) & 0x0000ff00) | ((dataFormat[0] >> 16) & 0x000000ff); \ +t1 = ((dataFormat[3] << 16) & 0xff000000) | ((dataFormat[2] << 8) & 0x00ff0000) | (dataFormat[1] & 0x0000ff00) | ((dataFormat[0] >> 8) & 0x000000ff); \ +t8 = ((dataFormat[3] << 24) & 0xff000000) | ((dataFormat[2] << 16) & 0x00ff0000) | ((dataFormat[1] << 8) & 0x0000ff00) | (dataFormat[0] & 0x000000ff); \ +unpuck32(t8); unpuck32(t8); \ +unpuck32(t1); unpuck32(t1); \ +unpuck32(t2); unpuck32(t2); \ +unpuck32(t3); unpuck32(t3); \ +((u32*)out)[0] = U32BIG(t8); \ +((u32*)out)[1] = U32BIG(t1); \ +((u32*)out)[2] = U32BIG(t2); \ +((u32*)out)[3] = U32BIG(t3); \ +} + +#define packU64FormatToFourPacket( out, in) {\ +t1 = U32BIG(((u32*)in)[0]); \ +t2 = U32BIG(((u32*)in)[1]); \ +puck32(t1); \ +puck32(t1); \ +puck32(t2); \ +puck32(t2); \ +out[3] = ((t2 >> 16) & 0x0000ff00) | ((t1 >> 24)); \ +out[2] = ((t2 >> 8) & 0x0000ff00) | ((t1 >> 16) & 0x000000ff); \ +out[1] = (t2 & 0x0000ff00) | ((t1 >> 8) & 0x000000ff); \ +out[0] = ((t2 << 8) & 0x0000ff00) | (t1 & 0x000000ff); \ +} +#define BIT_LOTR32_1(t0,t1,t2,t3,t4,t5,t6,t7){\ +t4= LOTR32(t3, 1);\ +t5 = t0;\ +t6 = t1; \ +t7 = t2; \ +} +#define BIT_LOTR32_16(t0,t1,t2,t3,t4,t5,t6,t7){\ +t4= LOTR32(t0, 4);\ +t5 = LOTR32(t1, 4);\ +t6 = LOTR32(t2, 4); \ +t7 = LOTR32(t3, 4); \ +} +#define BIT_LOTR32_25(t0,t1,t2,t3,t4,t5,t6,t7){\ +t4= LOTR32(t3, 7);\ +t5 = LOTR32(t0, 6);\ +t6 = LOTR32(t1, 6); \ +t7 = LOTR32(t2, 6); \ +} + +#define ROUND512( arr,lunNum) {\ +s[3] ^= (arr[lunNum] >> 6) & 0x3;\ +s[2] ^= (arr[lunNum] >> 4) & 0x3;\ +s[1] ^= (arr[lunNum] >> 2) & 0x3;\ +s[0] ^= arr[lunNum] & 0x3;\ +sbox(s[0], s[4], s[8], s[12], s_temp[0], s_temp[4], s_temp[8], s_temp[12]);\ +sbox(s[1], s[5], s[9], s[13], s_temp[1], s_temp[5], s_temp[9], s_temp[13]);\ +sbox(s[2], s[6], s[10], s[14], s_temp[2], s_temp[6], s_temp[10], s_temp[14]);\ +sbox(s[3], s[7], s[11], s[15], s_temp[3], s_temp[7], s_temp[11], s_temp[15]);\ +s[0] = s_temp[0], s[1] = s_temp[1], s[2] = s_temp[2], s[3] = s_temp[3];\ +BIT_LOTR32_1(s_temp[4], s_temp[5], s_temp[6], s_temp[7], s[4], s[5], s[6], s[7]);\ +BIT_LOTR32_16(s_temp[8], s_temp[9], s_temp[10], s_temp[11], s[8], s[9], s[10], s[11]);\ +BIT_LOTR32_25(s_temp[12], s_temp[13], s_temp[14], s_temp[15], s[12], s[13], s[14], s[15]);\ +} + diff --git a/knot/Implementations/crypto_aead/knot256/armcortexm_3/crypto_aead.h b/knot/Implementations/crypto_aead/knot256/armcortexm_3/crypto_aead.h new file mode 100644 index 0000000..cdfdf19 --- /dev/null +++ b/knot/Implementations/crypto_aead/knot256/armcortexm_3/crypto_aead.h @@ -0,0 +1,17 @@ +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 +); + +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 +); diff --git a/knot/Implementations/crypto_aead/knot256/armcortexm_3/encrypt.c b/knot/Implementations/crypto_aead/knot256/armcortexm_3/encrypt.c new file mode 100644 index 0000000..c9ef428 --- /dev/null +++ b/knot/Implementations/crypto_aead/knot256/armcortexm_3/encrypt.c @@ -0,0 +1,330 @@ + +#include"auxFormat.h" + +#define aead_RATE (128 / 8) +#define PR0_ROUNDS 100 +#define PR_ROUNDS 52 +#define PRF_ROUNDS 56 +unsigned char constant7Format_aead[127] = { + /*constant7_aead_256*/ +0x1, +0x4, +0x10, +0x40, +0x2, +0x8, +0x21, +0x5, +0x14, +0x50, +0x42, +0xa, +0x29, +0x24, +0x11, +0x44, +0x12, +0x48, +0x23, +0xd, +0x35, +0x55, +0x56, +0x5a, +0x6b, +0x2e, +0x38, +0x60, +0x3, +0xc, +0x31, +0x45, +0x16, +0x58, +0x63, +0xf, +0x3d, +0x74, +0x53, +0x4e, +0x3b, +0x6c, +0x32, +0x49, +0x27, +0x1d, +0x75, +0x57, +0x5e, +0x7b, +0x6e, +0x3a, +0x68, +0x22, +0x9, +0x25, +0x15, +0x54, +0x52, +0x4a, +0x2b, +0x2c, +0x30, +0x41, +0x6, +0x18, +0x61, +0x7, +0x1c, +0x71, +0x47, +0x1e, +0x79, +0x66, +0x1b, +0x6d, +0x36, +0x59, +0x67, +0x1f, +0x7d, +0x76, +0x5b, +0x6f, +0x3e, +0x78, +0x62, +0xb, +0x2d, +0x34, +0x51, +0x46, +0x1a, +0x69, +0x26, +0x19, +0x65, +0x17, +0x5c, +0x73, +0x4f, +0x3f, +0x7c, +0x72, +0x4b, +0x2f, +0x3c, +0x70, +0x43, +0xe, +0x39, +0x64, +0x13, +0x4c, +0x33, +0x4d, +0x37, +0x5d, +0x77, +0x5f, +0x7f, +0x7e, +0x7a, +0x6a, +0x2a, +0x28, +0x20, +}; + + + +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 +) { + u32 i, j; + u32 s_temp[16] = { 0 }; + u32 t1, t2, t3, t5, t6, t8, t9, t11; + // initialization + u32 s[16] = { 0 }; + u32 dataFormat[4] = { 0 }; + u8 tempData[16] = {0}; + *clen = mlen + CRYPTO_ABYTES; + //initialization + packU128FormatToFourPacket(s, npub); + packU128FormatToFourPacket((s + 4), (npub + 16)); + packU128FormatToFourPacket((s + 8), k); + packU128FormatToFourPacket((s + 12), (k + 16)); + for (i = 0; i < PR0_ROUNDS; i++) { + ROUND512(constant7Format_aead,i); + } + // process associated data + if (adlen) { + while (adlen >= aead_RATE) { + packU128FormatToFourPacket(dataFormat, ad); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + s[3] ^= dataFormat[3]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND512(constant7Format_aead, i); + } + adlen -= aead_RATE; + ad += aead_RATE; + } + memset(tempData, 0, sizeof(tempData)); + memcpy(tempData, ad, adlen * sizeof(unsigned char)); + tempData[adlen] = 0x01; + packU128FormatToFourPacket(dataFormat, tempData); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + s[3] ^= dataFormat[3]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND512(constant7Format_aead, i); + } + } + s[15] ^= 0x80000000; + if (mlen) { + while (mlen >= aead_RATE) { + packU128FormatToFourPacket(dataFormat, m); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + s[3] ^= dataFormat[3]; + unpackU128FormatToFourPacket(c, s); + for (i = 0; i < PR_ROUNDS; i++) { + ROUND512(constant7Format_aead, i); + } + mlen -= aead_RATE; + m += aead_RATE; + c += aead_RATE; + } + memset(tempData, 0, sizeof(tempData)); + memcpy(tempData, m, mlen * sizeof(unsigned char)); + tempData[mlen]= 0x01; + packU128FormatToFourPacket(dataFormat, tempData); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + s[3] ^= dataFormat[3]; + unpackU128FormatToFourPacket(tempData, s); + memcpy(c, tempData, mlen * sizeof(unsigned char)); + c += mlen; + } + // finalization + for (i = 0; i < PRF_ROUNDS; i++) { + ROUND512(constant7Format_aead, i); + } + // return tag + unpackU128FormatToFourPacket(c, s); + unpackU128FormatToFourPacket((c+16), (s+4)); + 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 +){ + u32 s_temp[16] = { 0 }; + u32 t1, t2, t3, t5, t6, t8, t9, t11; + u8 i, j; + // initialization + u32 s[16] = { 0 }; + u32 dataFormat[4] = { 0 }; + u32 dataFormat_1[4] = { 0 }; + u32 dataFormat_2[4] = { 0 }; + u8 tempData[16] = { 0 }; + u8 tempU8[64] = { 0 }; + + if (clen < CRYPTO_ABYTES) + return -1; + *mlen = clen - CRYPTO_ABYTES; + //initialization + packU128FormatToFourPacket(s, npub); + packU128FormatToFourPacket((s + 4), (npub + 16)); + packU128FormatToFourPacket((s + 8), k); + packU128FormatToFourPacket((s + 12), (k + 16)); + for (i = 0; i < PR0_ROUNDS; i++) { + ROUND512(constant7Format_aead, i); + } + // process associated data + if (adlen) { + while (adlen >= aead_RATE) { + packU128FormatToFourPacket(dataFormat, ad); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + s[3] ^= dataFormat[3]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND512(constant7Format_aead, i); + } + adlen -= aead_RATE; + ad += aead_RATE; + } + memset(tempData, 0, sizeof(tempData)); + + memcpy(tempData, ad, adlen * sizeof(unsigned char)); + tempData[adlen] = 0x01; + packU128FormatToFourPacket(dataFormat, tempData); + s[0] ^= dataFormat[0]; + s[1] ^= dataFormat[1]; + s[2] ^= dataFormat[2]; + s[3] ^= dataFormat[3]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND512(constant7Format_aead, i); + } + } + s[15] ^= 0x80000000; + clen = clen - CRYPTO_KEYBYTES; + + if (clen) { + while (clen >= aead_RATE) { + packU128FormatToFourPacket(dataFormat_2, c); + dataFormat_1[0] = s[0] ^ dataFormat_2[0]; + dataFormat_1[1] = s[1] ^ dataFormat_2[1]; + dataFormat_1[2] = s[2] ^ dataFormat_2[2]; + dataFormat_1[3] = s[3] ^ dataFormat_2[3]; + unpackU128FormatToFourPacket(m, dataFormat_1); + s[0] = dataFormat_2[0]; + s[1] = dataFormat_2[1]; + s[2] = dataFormat_2[2]; + s[3] = dataFormat_2[3]; + for (i = 0; i < PR_ROUNDS; i++) { + ROUND512(constant7Format_aead, i); + } + clen -= aead_RATE; + m += aead_RATE; + c += aead_RATE; + } + unpackU128FormatToFourPacket(tempU8, s); + for (i = 0; i < clen; ++i, ++m, ++c) + { + *m = tempU8[i] ^ *c; + tempU8[i] = *c; + } + tempU8[i] ^= 0x01; + packU128FormatToFourPacket(s, tempU8); + } + // finalization + for (i = 0; i < PRF_ROUNDS; i++) { + ROUND512(constant7Format_aead, i); + } + // return tag + packU128FormatToFourPacket(dataFormat, c); + packU128FormatToFourPacket(dataFormat_1, (c + 16)); + if (dataFormat[0] != s[0] || dataFormat[1] != s[1] || dataFormat[2] != s[2] || dataFormat[3] != s[3] + || dataFormat_1[0] != s[4] || dataFormat_1[1] != s[5] || dataFormat_1[2] != s[6] || dataFormat_1[3] != s[7]) { + return -1; + } + return 0; + +} \ No newline at end of file -- libgit2 0.26.0