Lab
/
siphash
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

autogen vectors, tweaked hsiphash

main
JP Aumasson 2016-12-17 14:14:22 +01:00
parent 7ce7f04709
commit 93ca99dcfa
5 changed files with 1052 additions and 471 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

114
halfsiphash.c
View File

@ -2,9 +2,7 @@
/* /*
SipHash reference C implementation SipHash reference C implementation
Copyright (c) 2012-2014 Jean-Philippe Aumasson Copyright (c) 2016 Jean-Philippe Aumasson <jeanphilippe.aumasson@gmail.com>
<jeanphilippe.aumasson@gmail.com>
Copyright (c) 2012-2014 Daniel J. Bernstein <djb@cr.yp.to>
To the extent possible under law, the author(s) have dedicated all copyright To the extent possible under law, the author(s) have dedicated all copyright
and related and neighboring rights to this software to the public domain and related and neighboring rights to this software to the public domain
@ -26,57 +24,58 @@
#define ROTL(x, b) (uint32_t)(((x) << (b)) | ((x) >> (32 - (b)))) #define ROTL(x, b) (uint32_t)(((x) << (b)) | ((x) >> (32 - (b))))
#define U32TO8_LE(p, v) \ #define U32TO8_LE(p, v) \
(p)[0] = (uint8_t)((v)); \ (p)[0] = (uint8_t)((v)); \
(p)[1] = (uint8_t)((v) >> 8); \ (p)[1] = (uint8_t)((v) >> 8); \
(p)[2] = (uint8_t)((v) >> 16); \ (p)[2] = (uint8_t)((v) >> 16); \
(p)[3] = (uint8_t)((v) >> 24); (p)[3] = (uint8_t)((v) >> 24);
#define U32TO8_LE(p, v) \ #define U32TO8_LE(p, v) \
(p)[0] = (uint8_t)((v)); \ (p)[0] = (uint8_t)((v)); \
(p)[1] = (uint8_t)((v) >> 8); \ (p)[1] = (uint8_t)((v) >> 8); \
(p)[2] = (uint8_t)((v) >> 16); \ (p)[2] = (uint8_t)((v) >> 16); \
(p)[3] = (uint8_t)((v) >> 24); (p)[3] = (uint8_t)((v) >> 24);
#define U8TO32_LE(p) \ #define U8TO32_LE(p) \
(((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \ (((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \
((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24)) \ ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24))
#define SIPROUND \ #define SIPROUND \
do { \ do { \
v0 += v1; \ v0 += v1; \
v1 = ROTL(v1, 5); \ v1 = ROTL(v1, 5); \
v1 ^= v0; \ v1 ^= v0; \
v0 = ROTL(v0, 16); \ v0 = ROTL(v0, 16); \
v2 += v3; \ v2 += v3; \
v3 = ROTL(v3, 8); \ v3 = ROTL(v3, 8); \
v3 ^= v2; \ v3 ^= v2; \
v0 += v3; \ v0 += v3; \
v3 = ROTL(v3, 7); \ v3 = ROTL(v3, 7); \
v3 ^= v0; \ v3 ^= v0; \
v2 += v1; \ v2 += v1; \
v1 = ROTL(v1, 13); \ v1 = ROTL(v1, 13); \
v1 ^= v2; \ v1 ^= v2; \
v2 = ROTL(v2, 16); \ v2 = ROTL(v2, 16); \
} while (0) } while (0)
#ifdef DEBUG #ifdef DEBUG
#define TRACE \ #define TRACE \
do { \ do { \
printf("(%3d) v0 %08x\n", (int)inlen, v0); \ printf("(%3d) v0 %08x\n", (int)inlen, v0); \
printf("(%3d) v1 %08x\n", (int)inlen, v1); \ printf("(%3d) v1 %08x\n", (int)inlen, v1); \
printf("(%3d) v2 %08x\n", (int)inlen, v2); \ printf("(%3d) v2 %08x\n", (int)inlen, v2); \
printf("(%3d) v3 %08x\n", (int)inlen, v3); \ printf("(%3d) v3 %08x\n", (int)inlen, v3); \
} while (0) } while (0)
#else #else
#define TRACE #define TRACE
#endif #endif
int halfsiphash(const uint8_t *in, const size_t inlen, const uint8_t *k, uint8_t *out, const size_t outlen) { int halfsiphash(const uint8_t *in, const size_t inlen, const uint8_t *k,
uint8_t *out, const size_t outlen) {
assert( (outlen == 4) || (outlen == 8)); assert((outlen == 4) || (outlen == 8));
uint32_t v0 = 0x736f6d65; uint32_t v0 = 0;
uint32_t v1 = 0x646f7261; uint32_t v1 = 0;
uint32_t v2 = 0x6c796765; uint32_t v2 = 0x6c796765;
uint32_t v3 = 0x74656462; uint32_t v3 = 0x74656462;
uint32_t k0 = U8TO32_LE(k); uint32_t k0 = U8TO32_LE(k);
@ -91,7 +90,8 @@ int halfsiphash(const uint8_t *in, const size_t inlen, const uint8_t *k, uint8_t
v1 ^= k1; v1 ^= k1;
v0 ^= k0; v0 ^= k0;
if (outlen == 8) v1 ^= 0xee; if (outlen == 8)
v1 ^= 0xee;
for (; in != end; in += 4) { for (; in != end; in += 4) {
m = U8TO32_LE(in); m = U8TO32_LE(in);
@ -105,15 +105,15 @@ int halfsiphash(const uint8_t *in, const size_t inlen, const uint8_t *k, uint8_t
} }
switch (left) { switch (left) {
case 3: case 3:
b |= ((uint32_t)in[2]) << 16; b |= ((uint32_t)in[2]) << 16;
case 2: case 2:
b |= ((uint32_t)in[1]) << 8; b |= ((uint32_t)in[1]) << 8;
case 1: case 1:
b |= ((uint32_t)in[0]); b |= ((uint32_t)in[0]);
break; break;
case 0: case 0:
break; break;
} }
v3 ^= b; v3 ^= b;
@ -124,17 +124,20 @@ int halfsiphash(const uint8_t *in, const size_t inlen, const uint8_t *k, uint8_t
v0 ^= b; v0 ^= b;
if (outlen == 8) v2 ^= 0xee; if (outlen == 8)
else v2 ^= 0xff; v2 ^= 0xee;
else
v2 ^= 0xff;
TRACE; TRACE;
for (i = 0; i < dROUNDS; ++i) for (i = 0; i < dROUNDS; ++i)
SIPROUND; SIPROUND;
b = v0 ^ v1 ^ v2 ^ v3; b = v1 ^ v3;
U32TO8_LE(out, b); U32TO8_LE(out, b);
if (outlen == 4) return 0; if (outlen == 4)
return 0;
v1 ^= 0xdd; v1 ^= 0xdd;
@ -142,9 +145,8 @@ int halfsiphash(const uint8_t *in, const size_t inlen, const uint8_t *k, uint8_t
for (i = 0; i < dROUNDS; ++i) for (i = 0; i < dROUNDS; ++i)
SIPROUND; SIPROUND;
b = v0 ^ v1 ^ v2 ^ v3; b = v1 ^ v3;
U32TO8_LE(out + 4, b); U32TO8_LE(out + 4, b);
return 0; return 0;
} }

11
makefile
View File

@ -1,7 +1,7 @@
CC=gcc CC=gcc
CFLAGS=-Wall CFLAGS=-Wall --std=c99
SRC=siphash.c halfsiphash.c test.c SRC=siphash.c halfsiphash.c test.c
BIN=test debug BIN=test debug vectors
all: $(BIN) all: $(BIN)
@ -11,8 +11,15 @@ test: $(SRC)
debug: $(SRC) debug: $(SRC)
$(CC) $(CFLAGS) $^ -o $@ -DDEBUG $(CC) $(CFLAGS) $^ -o $@ -DDEBUG
vectors: $(SRC)
$(CC) $(CFLAGS) $^ -o $@ -DGETVECTORS
clean: clean:
rm -f *.o $(BIN) rm -f *.o $(BIN)
format:
clang-format -style="{BasedOnStyle: llvm, IndentWidth: 4}" \
-i *.c *.h
dist: clean dist: clean
cd ..; \ cd ..; \

130
siphash.c
View File

@ -1,7 +1,7 @@
/* /*
SipHash reference C implementation SipHash reference C implementation
Copyright (c) 2012-2014 Jean-Philippe Aumasson Copyright (c) 2012-2016 Jean-Philippe Aumasson
<jeanphilippe.aumasson@gmail.com> <jeanphilippe.aumasson@gmail.com>
Copyright (c) 2012-2014 Daniel J. Bernstein <djb@cr.yp.to> Copyright (c) 2012-2014 Daniel J. Bernstein <djb@cr.yp.to>
@ -25,59 +25,60 @@
#define ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b)))) #define ROTL(x, b) (uint64_t)(((x) << (b)) | ((x) >> (64 - (b))))
#define U32TO8_LE(p, v) \ #define U32TO8_LE(p, v) \
(p)[0] = (uint8_t)((v)); \ (p)[0] = (uint8_t)((v)); \
(p)[1] = (uint8_t)((v) >> 8); \ (p)[1] = (uint8_t)((v) >> 8); \
(p)[2] = (uint8_t)((v) >> 16); \ (p)[2] = (uint8_t)((v) >> 16); \
(p)[3] = (uint8_t)((v) >> 24); (p)[3] = (uint8_t)((v) >> 24);
#define U64TO8_LE(p, v) \ #define U64TO8_LE(p, v) \
U32TO8_LE((p), (uint32_t)((v))); \ U32TO8_LE((p), (uint32_t)((v))); \
U32TO8_LE((p) + 4, (uint32_t)((v) >> 32)); U32TO8_LE((p) + 4, (uint32_t)((v) >> 32));
#define U8TO64_LE(p) \ #define U8TO64_LE(p) \
(((uint64_t)((p)[0])) | ((uint64_t)((p)[1]) << 8) | \ (((uint64_t)((p)[0])) | ((uint64_t)((p)[1]) << 8) | \
((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24) | \ ((uint64_t)((p)[2]) << 16) | ((uint64_t)((p)[3]) << 24) | \
((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40) | \ ((uint64_t)((p)[4]) << 32) | ((uint64_t)((p)[5]) << 40) | \
((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56)) ((uint64_t)((p)[6]) << 48) | ((uint64_t)((p)[7]) << 56))
#define SIPROUND \ #define SIPROUND \
do { \ do { \
v0 += v1; \ v0 += v1; \
v1 = ROTL(v1, 13); \ v1 = ROTL(v1, 13); \
v1 ^= v0; \ v1 ^= v0; \
v0 = ROTL(v0, 32); \ v0 = ROTL(v0, 32); \
v2 += v3; \ v2 += v3; \
v3 = ROTL(v3, 16); \ v3 = ROTL(v3, 16); \
v3 ^= v2; \ v3 ^= v2; \
v0 += v3; \ v0 += v3; \
v3 = ROTL(v3, 21); \ v3 = ROTL(v3, 21); \
v3 ^= v0; \ v3 ^= v0; \
v2 += v1; \ v2 += v1; \
v1 = ROTL(v1, 17); \ v1 = ROTL(v1, 17); \
v1 ^= v2; \ v1 ^= v2; \
v2 = ROTL(v2, 32); \ v2 = ROTL(v2, 32); \
} while (0) } while (0)
#ifdef DEBUG #ifdef DEBUG
#define TRACE \ #define TRACE \
do { \ do { \
printf("(%3d) v0 %08x %08x\n", (int)inlen, (uint32_t)(v0 >> 32), \ printf("(%3d) v0 %08x %08x\n", (int)inlen, (uint32_t)(v0 >> 32), \
(uint32_t)v0); \ (uint32_t)v0); \
printf("(%3d) v1 %08x %08x\n", (int)inlen, (uint32_t)(v1 >> 32), \ printf("(%3d) v1 %08x %08x\n", (int)inlen, (uint32_t)(v1 >> 32), \
(uint32_t)v1); \ (uint32_t)v1); \
printf("(%3d) v2 %08x %08x\n", (int)inlen, (uint32_t)(v2 >> 32), \ printf("(%3d) v2 %08x %08x\n", (int)inlen, (uint32_t)(v2 >> 32), \
(uint32_t)v2); \ (uint32_t)v2); \
printf("(%3d) v3 %08x %08x\n", (int)inlen, (uint32_t)(v3 >> 32), \ printf("(%3d) v3 %08x %08x\n", (int)inlen, (uint32_t)(v3 >> 32), \
(uint32_t)v3); \ (uint32_t)v3); \
} while (0) } while (0)
#else #else
#define TRACE #define TRACE
#endif #endif
int siphash(const uint8_t *in, const size_t inlen, const uint8_t *k, uint8_t *out, const size_t outlen) { int siphash(const uint8_t *in, const size_t inlen, const uint8_t *k,
uint8_t *out, const size_t outlen) {
assert( (outlen == 8) || (outlen == 16));
assert((outlen == 8) || (outlen == 16));
uint64_t v0 = 0x736f6d6570736575ULL; uint64_t v0 = 0x736f6d6570736575ULL;
uint64_t v1 = 0x646f72616e646f6dULL; uint64_t v1 = 0x646f72616e646f6dULL;
uint64_t v2 = 0x6c7967656e657261ULL; uint64_t v2 = 0x6c7967656e657261ULL;
@ -94,7 +95,8 @@ int siphash(const uint8_t *in, const size_t inlen, const uint8_t *k, uint8_t *ou
v1 ^= k1; v1 ^= k1;
v0 ^= k0; v0 ^= k0;
if (outlen == 16) v1 ^= 0xee; if (outlen == 16)
v1 ^= 0xee;
for (; in != end; in += 8) { for (; in != end; in += 8) {
m = U8TO64_LE(in); m = U8TO64_LE(in);
@ -108,23 +110,23 @@ int siphash(const uint8_t *in, const size_t inlen, const uint8_t *k, uint8_t *ou
} }
switch (left) { switch (left) {
case 7: case 7:
b |= ((uint64_t)in[6]) << 48; b |= ((uint64_t)in[6]) << 48;
case 6: case 6:
b |= ((uint64_t)in[5]) << 40; b |= ((uint64_t)in[5]) << 40;
case 5: case 5:
b |= ((uint64_t)in[4]) << 32; b |= ((uint64_t)in[4]) << 32;
case 4: case 4:
b |= ((uint64_t)in[3]) << 24; b |= ((uint64_t)in[3]) << 24;
case 3: case 3:
b |= ((uint64_t)in[2]) << 16; b |= ((uint64_t)in[2]) << 16;
case 2: case 2:
b |= ((uint64_t)in[1]) << 8; b |= ((uint64_t)in[1]) << 8;
case 1: case 1:
b |= ((uint64_t)in[0]); b |= ((uint64_t)in[0]);
break; break;
case 0: case 0:
break; break;
} }
v3 ^= b; v3 ^= b;
@ -135,8 +137,10 @@ int siphash(const uint8_t *in, const size_t inlen, const uint8_t *k, uint8_t *ou
v0 ^= b; v0 ^= b;
if (outlen == 16) v2 ^= 0xee; if (outlen == 16)
else v2 ^= 0xff; v2 ^= 0xee;
else
v2 ^= 0xff;
TRACE; TRACE;
for (i = 0; i < dROUNDS; ++i) for (i = 0; i < dROUNDS; ++i)
@ -145,7 +149,8 @@ int siphash(const uint8_t *in, const size_t inlen, const uint8_t *k, uint8_t *ou
b = v0 ^ v1 ^ v2 ^ v3; b = v0 ^ v1 ^ v2 ^ v3;
U64TO8_LE(out, b); U64TO8_LE(out, b);
if (outlen == 8) return 0; if (outlen == 8)
return 0;
v1 ^= 0xdd; v1 ^= 0xdd;
@ -158,4 +163,3 @@ int siphash(const uint8_t *in, const size_t inlen, const uint8_t *k, uint8_t *ou
return 0; return 0;
} }

426
test.c
View File

@ -1,380 +1,106 @@
/* /*
SipHash reference C implementation SipHash reference C implementation
Copyright (c) 2012 Jean-Philippe Aumasson <jeanphilippe.aumasson@gmail.com> Copyright (c) 2012-2016 Jean-Philippe Aumasson
<jeanphilippe.aumasson@gmail.com>
Copyright (c) 2012 Daniel J. Bernstein <djb@cr.yp.to> Copyright (c) 2012 Daniel J. Bernstein <djb@cr.yp.to>
To the extent possible under law, the author(s) have dedicated all copyright To the extent possible under law, the author(s) have dedicated all copyright
and related and neighboring rights to this software to the public domain and related and neighboring rights to this software to the public domain
worldwide. This software is distributed without any warranty. worldwide. This software is distributed without any warranty.
You should have received a copy of the CC0 Public Domain Dedication along with You should have received a copy of the CC0 Public Domain Dedication along
this software. If not, see <http://creativecommons.org/publicdomain/zero/1.0/>. with
this software. If not, see
<http://creativecommons.org/publicdomain/zero/1.0/>.
*/ */
#include "vectors.h"
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#define MAXLEN 64 #define PRINTHASH(n) \
printf(" { "); \
for (int j = 0; j < n; ++j) { \
printf("0x%02x, ", out[j]); \
} \
printf("},\n");
int siphash(const uint8_t *in, const size_t inlen, const uint8_t *k, \ int siphash(const uint8_t *in, const size_t inlen, const uint8_t *k,
uint8_t *out, const size_t outlen); uint8_t *out, const size_t outlen);
int halfsiphash(const uint8_t *in, const size_t inlen, const uint8_t *k,\ int halfsiphash(const uint8_t *in, const size_t inlen, const uint8_t *k,
uint8_t *out, const size_t outlen); uint8_t *out, const size_t outlen);
/* const char *functions[4] = {
SipHash-2-4 output with "const uint8_t vectors_sip64[64][8] =",
k = 00 01 02 ... "const uint8_t vectors_sip128[64][16] =",
and "const uint8_t vectors_hsip32[64][4] =",
in = (empty string) "const uint8_t vectors_hsip64[64][8] =",
in = 00 (1 byte)
in = 00 01 (2 bytes)
in = 00 01 02 (3 bytes)
...
in = 00 01 02 ... 3e (63 bytes)
*/
const uint8_t vectors_sip64[MAXLEN][8] =
{
{ 0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72 },
{ 0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74 },
{ 0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d },
{ 0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85 },
{ 0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf },
{ 0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18 },
{ 0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb },
{ 0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab },
{ 0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93 },
{ 0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e },
{ 0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a },
{ 0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4 },
{ 0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75 },
{ 0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14 },
{ 0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7 },
{ 0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1 },
{ 0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f },
{ 0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69 },
{ 0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b },
{ 0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb },
{ 0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe },
{ 0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0 },
{ 0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93 },
{ 0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8 },
{ 0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8 },
{ 0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc },
{ 0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17 },
{ 0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f },
{ 0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde },
{ 0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6 },
{ 0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad },
{ 0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32 },
{ 0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71 },
{ 0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7 },
{ 0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12 },
{ 0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15 },
{ 0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31 },
{ 0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02 },
{ 0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca },
{ 0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a },
{ 0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e },
{ 0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad },
{ 0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18 },
{ 0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4 },
{ 0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9 },
{ 0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9 },
{ 0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb },
{ 0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0 },
{ 0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6 },
{ 0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7 },
{ 0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee },
{ 0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1 },
{ 0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a },
{ 0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81 },
{ 0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f },
{ 0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24 },
{ 0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7 },
{ 0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea },
{ 0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60 },
{ 0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66 },
{ 0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c },
{ 0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f },
{ 0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5 },
{ 0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95 }
}; };
const uint8_t vectors_sip128[MAXLEN][16] = const char *labels[4] = {
{ "SipHash 64-bit tag:", "SipHash 128-bit tag:", "HalfSipHash 32-bit tag:",
{ 0xa3, 0x81, 0x7f, 0x04, 0xba, 0x25, 0xa8, 0xe6, 0x6d, 0xf6, 0x72, 0x14, 0xc7, 0x55, 0x02, 0x93 }, "HalfSipHash 64-bit tag:",
{ 0xda, 0x87, 0xc1, 0xd8, 0x6b, 0x99, 0xaf, 0x44, 0x34, 0x76, 0x59, 0x11, 0x9b, 0x22, 0xfc, 0x45 },
{ 0x81, 0x77, 0x22, 0x8d, 0xa4, 0xa4, 0x5d, 0xc7, 0xfc, 0xa3, 0x8b, 0xde, 0xf6, 0x0a, 0xff, 0xe4 },
{ 0x9c, 0x70, 0xb6, 0x0c, 0x52, 0x67, 0xa9, 0x4e, 0x5f, 0x33, 0xb6, 0xb0, 0x29, 0x85, 0xed, 0x51 },
{ 0xf8, 0x81, 0x64, 0xc1, 0x2d, 0x9c, 0x8f, 0xaf, 0x7d, 0x0f, 0x6e, 0x7c, 0x7b, 0xcd, 0x55, 0x79 },
{ 0x13, 0x68, 0x87, 0x59, 0x80, 0x77, 0x6f, 0x88, 0x54, 0x52, 0x7a, 0x07, 0x69, 0x0e, 0x96, 0x27 },
{ 0x14, 0xee, 0xca, 0x33, 0x8b, 0x20, 0x86, 0x13, 0x48, 0x5e, 0xa0, 0x30, 0x8f, 0xd7, 0xa1, 0x5e },
{ 0xa1, 0xf1, 0xeb, 0xbe, 0xd8, 0xdb, 0xc1, 0x53, 0xc0, 0xb8, 0x4a, 0xa6, 0x1f, 0xf0, 0x82, 0x39 },
{ 0x3b, 0x62, 0xa9, 0xba, 0x62, 0x58, 0xf5, 0x61, 0x0f, 0x83, 0xe2, 0x64, 0xf3, 0x14, 0x97, 0xb4 },
{ 0x26, 0x44, 0x99, 0x06, 0x0a, 0xd9, 0xba, 0xab, 0xc4, 0x7f, 0x8b, 0x02, 0xbb, 0x6d, 0x71, 0xed },
{ 0x00, 0x11, 0x0d, 0xc3, 0x78, 0x14, 0x69, 0x56, 0xc9, 0x54, 0x47, 0xd3, 0xf3, 0xd0, 0xfb, 0xba },
{ 0x01, 0x51, 0xc5, 0x68, 0x38, 0x6b, 0x66, 0x77, 0xa2, 0xb4, 0xdc, 0x6f, 0x81, 0xe5, 0xdc, 0x18 },
{ 0xd6, 0x26, 0xb2, 0x66, 0x90, 0x5e, 0xf3, 0x58, 0x82, 0x63, 0x4d, 0xf6, 0x85, 0x32, 0xc1, 0x25 },
{ 0x98, 0x69, 0xe2, 0x47, 0xe9, 0xc0, 0x8b, 0x10, 0xd0, 0x29, 0x93, 0x4f, 0xc4, 0xb9, 0x52, 0xf7 },
{ 0x31, 0xfc, 0xef, 0xac, 0x66, 0xd7, 0xde, 0x9c, 0x7e, 0xc7, 0x48, 0x5f, 0xe4, 0x49, 0x49, 0x02 },
{ 0x54, 0x93, 0xe9, 0x99, 0x33, 0xb0, 0xa8, 0x11, 0x7e, 0x08, 0xec, 0x0f, 0x97, 0xcf, 0xc3, 0xd9 },
{ 0x6e, 0xe2, 0xa4, 0xca, 0x67, 0xb0, 0x54, 0xbb, 0xfd, 0x33, 0x15, 0xbf, 0x85, 0x23, 0x05, 0x77 },
{ 0x47, 0x3d, 0x06, 0xe8, 0x73, 0x8d, 0xb8, 0x98, 0x54, 0xc0, 0x66, 0xc4, 0x7a, 0xe4, 0x77, 0x40 },
{ 0xa4, 0x26, 0xe5, 0xe4, 0x23, 0xbf, 0x48, 0x85, 0x29, 0x4d, 0xa4, 0x81, 0xfe, 0xae, 0xf7, 0x23 },
{ 0x78, 0x01, 0x77, 0x31, 0xcf, 0x65, 0xfa, 0xb0, 0x74, 0xd5, 0x20, 0x89, 0x52, 0x51, 0x2e, 0xb1 },
{ 0x9e, 0x25, 0xfc, 0x83, 0x3f, 0x22, 0x90, 0x73, 0x3e, 0x93, 0x44, 0xa5, 0xe8, 0x38, 0x39, 0xeb },
{ 0x56, 0x8e, 0x49, 0x5a, 0xbe, 0x52, 0x5a, 0x21, 0x8a, 0x22, 0x14, 0xcd, 0x3e, 0x07, 0x1d, 0x12 },
{ 0x4a, 0x29, 0xb5, 0x45, 0x52, 0xd1, 0x6b, 0x9a, 0x46, 0x9c, 0x10, 0x52, 0x8e, 0xff, 0x0a, 0xae },
{ 0xc9, 0xd1, 0x84, 0xdd, 0xd5, 0xa9, 0xf5, 0xe0, 0xcf, 0x8c, 0xe2, 0x9a, 0x9a, 0xbf, 0x69, 0x1c },
{ 0x2d, 0xb4, 0x79, 0xae, 0x78, 0xbd, 0x50, 0xd8, 0x88, 0x2a, 0x8a, 0x17, 0x8a, 0x61, 0x32, 0xad },
{ 0x8e, 0xce, 0x5f, 0x04, 0x2d, 0x5e, 0x44, 0x7b, 0x50, 0x51, 0xb9, 0xea, 0xcb, 0x8d, 0x8f, 0x6f },
{ 0x9c, 0x0b, 0x53, 0xb4, 0xb3, 0xc3, 0x07, 0xe8, 0x7e, 0xae, 0xe0, 0x86, 0x78, 0x14, 0x1f, 0x66 },
{ 0xab, 0xf2, 0x48, 0xaf, 0x69, 0xa6, 0xea, 0xe4, 0xbf, 0xd3, 0xeb, 0x2f, 0x12, 0x9e, 0xeb, 0x94 },
{ 0x06, 0x64, 0xda, 0x16, 0x68, 0x57, 0x4b, 0x88, 0xb9, 0x35, 0xf3, 0x02, 0x73, 0x58, 0xae, 0xf4 },
{ 0xaa, 0x4b, 0x9d, 0xc4, 0xbf, 0x33, 0x7d, 0xe9, 0x0c, 0xd4, 0xfd, 0x3c, 0x46, 0x7c, 0x6a, 0xb7 },
{ 0xea, 0x5c, 0x7f, 0x47, 0x1f, 0xaf, 0x6b, 0xde, 0x2b, 0x1a, 0xd7, 0xd4, 0x68, 0x6d, 0x22, 0x87 },
{ 0x29, 0x39, 0xb0, 0x18, 0x32, 0x23, 0xfa, 0xfc, 0x17, 0x23, 0xde, 0x4f, 0x52, 0xc4, 0x3d, 0x35 },
{ 0x7c, 0x39, 0x56, 0xca, 0x5e, 0xea, 0xfc, 0x3e, 0x36, 0x3e, 0x9d, 0x55, 0x65, 0x46, 0xeb, 0x68 },
{ 0x77, 0xc6, 0x07, 0x71, 0x46, 0xf0, 0x1c, 0x32, 0xb6, 0xb6, 0x9d, 0x5f, 0x4e, 0xa9, 0xff, 0xcf },
{ 0x37, 0xa6, 0x98, 0x6c, 0xb8, 0x84, 0x7e, 0xdf, 0x09, 0x25, 0xf0, 0xf1, 0x30, 0x9b, 0x54, 0xde },
{ 0xa7, 0x05, 0xf0, 0xe6, 0x9d, 0xa9, 0xa8, 0xf9, 0x07, 0x24, 0x1a, 0x2e, 0x92, 0x3c, 0x8c, 0xc8 },
{ 0x3d, 0xc4, 0x7d, 0x1f, 0x29, 0xc4, 0x48, 0x46, 0x1e, 0x9e, 0x76, 0xed, 0x90, 0x4f, 0x67, 0x11 },
{ 0x0d, 0x62, 0xbf, 0x01, 0xe6, 0xfc, 0x0e, 0x1a, 0x0d, 0x3c, 0x47, 0x51, 0xc5, 0xd3, 0x69, 0x2b },
{ 0x8c, 0x03, 0x46, 0x8b, 0xca, 0x7c, 0x66, 0x9e, 0xe4, 0xfd, 0x5e, 0x08, 0x4b, 0xbe, 0xe7, 0xb5 },
{ 0x52, 0x8a, 0x5b, 0xb9, 0x3b, 0xaf, 0x2c, 0x9c, 0x44, 0x73, 0xcc, 0xe5, 0xd0, 0xd2, 0x2b, 0xd9 },
{ 0xdf, 0x6a, 0x30, 0x1e, 0x95, 0xc9, 0x5d, 0xad, 0x97, 0xae, 0x0c, 0xc8, 0xc6, 0x91, 0x3b, 0xd8 },
{ 0x80, 0x11, 0x89, 0x90, 0x2c, 0x85, 0x7f, 0x39, 0xe7, 0x35, 0x91, 0x28, 0x5e, 0x70, 0xb6, 0xdb },
{ 0xe6, 0x17, 0x34, 0x6a, 0xc9, 0xc2, 0x31, 0xbb, 0x36, 0x50, 0xae, 0x34, 0xcc, 0xca, 0x0c, 0x5b },
{ 0x27, 0xd9, 0x34, 0x37, 0xef, 0xb7, 0x21, 0xaa, 0x40, 0x18, 0x21, 0xdc, 0xec, 0x5a, 0xdf, 0x89 },
{ 0x89, 0x23, 0x7d, 0x9d, 0xed, 0x9c, 0x5e, 0x78, 0xd8, 0xb1, 0xc9, 0xb1, 0x66, 0xcc, 0x73, 0x42 },
{ 0x4a, 0x6d, 0x80, 0x91, 0xbf, 0x5e, 0x7d, 0x65, 0x11, 0x89, 0xfa, 0x94, 0xa2, 0x50, 0xb1, 0x4c },
{ 0x0e, 0x33, 0xf9, 0x60, 0x55, 0xe7, 0xae, 0x89, 0x3f, 0xfc, 0x0e, 0x3d, 0xcf, 0x49, 0x29, 0x02 },
{ 0xe6, 0x1c, 0x43, 0x2b, 0x72, 0x0b, 0x19, 0xd1, 0x8e, 0xc8, 0xd8, 0x4b, 0xdc, 0x63, 0x15, 0x1b },
{ 0xf7, 0xe5, 0xae, 0xf5, 0x49, 0xf7, 0x82, 0xcf, 0x37, 0x90, 0x55, 0xa6, 0x08, 0x26, 0x9b, 0x16 },
{ 0x43, 0x8d, 0x03, 0x0f, 0xd0, 0xb7, 0xa5, 0x4f, 0xa8, 0x37, 0xf2, 0xad, 0x20, 0x1a, 0x64, 0x03 },
{ 0xa5, 0x90, 0xd3, 0xee, 0x4f, 0xbf, 0x04, 0xe3, 0x24, 0x7e, 0x0d, 0x27, 0xf2, 0x86, 0x42, 0x3f },
{ 0x5f, 0xe2, 0xc1, 0xa1, 0x72, 0xfe, 0x93, 0xc4, 0xb1, 0x5c, 0xd3, 0x7c, 0xae, 0xf9, 0xf5, 0x38 },
{ 0x2c, 0x97, 0x32, 0x5c, 0xbd, 0x06, 0xb3, 0x6e, 0xb2, 0x13, 0x3d, 0xd0, 0x8b, 0x3a, 0x01, 0x7c },
{ 0x92, 0xc8, 0x14, 0x22, 0x7a, 0x6b, 0xca, 0x94, 0x9f, 0xf0, 0x65, 0x9f, 0x00, 0x2a, 0xd3, 0x9e },
{ 0xdc, 0xe8, 0x50, 0x11, 0x0b, 0xd8, 0x32, 0x8c, 0xfb, 0xd5, 0x08, 0x41, 0xd6, 0x91, 0x1d, 0x87 },
{ 0x67, 0xf1, 0x49, 0x84, 0xc7, 0xda, 0x79, 0x12, 0x48, 0xe3, 0x2b, 0xb5, 0x92, 0x25, 0x83, 0xda },
{ 0x19, 0x38, 0xf2, 0xcf, 0x72, 0xd5, 0x4e, 0xe9, 0x7e, 0x94, 0x16, 0x6f, 0xa9, 0x1d, 0x2a, 0x36 },
{ 0x74, 0x48, 0x1e, 0x96, 0x46, 0xed, 0x49, 0xfe, 0x0f, 0x62, 0x24, 0x30, 0x16, 0x04, 0x69, 0x8e },
{ 0x57, 0xfc, 0xa5, 0xde, 0x98, 0xa9, 0xd6, 0xd8, 0x00, 0x64, 0x38, 0xd0, 0x58, 0x3d, 0x8a, 0x1d },
{ 0x9f, 0xec, 0xde, 0x1c, 0xef, 0xdc, 0x1c, 0xbe, 0xd4, 0x76, 0x36, 0x74, 0xd9, 0x57, 0x53, 0x59 },
{ 0xe3, 0x04, 0x0c, 0x00, 0xeb, 0x28, 0xf1, 0x53, 0x66, 0xca, 0x73, 0xcb, 0xd8, 0x72, 0xe7, 0x40 },
{ 0x76, 0x97, 0x00, 0x9a, 0x6a, 0x83, 0x1d, 0xfe, 0xcc, 0xa9, 0x1c, 0x59, 0x93, 0x67, 0x0f, 0x7a },
{ 0x58, 0x53, 0x54, 0x23, 0x21, 0xf5, 0x67, 0xa0, 0x05, 0xd5, 0x47, 0xa4, 0xf0, 0x47, 0x59, 0xbd },
{ 0x51, 0x50, 0xd1, 0x77, 0x2f, 0x50, 0x83, 0x4a, 0x50, 0x3e, 0x06, 0x9a, 0x97, 0x3f, 0xbd, 0x7c }
}; };
const uint8_t vectors_halfsip32[MAXLEN][4] = size_t lengths[4] = {8, 16, 4, 8};
{
{0x08, 0x99, 0xcb, 0xf6 },
{0xbc, 0xc9, 0x99, 0xe4 },
{0x48, 0x62, 0x08, 0xc5 },
{0x1b, 0x1c, 0x06, 0x8c },
{0xe7, 0x60, 0x30, 0xfd },
{0xe9, 0x73, 0xbb, 0xba },
{0xf1, 0xeb, 0xa4, 0x9c },
{0x92, 0x52, 0xa9, 0x2c },
{0xeb, 0x00, 0xf4, 0xa7 },
{0x39, 0xf4, 0xcd, 0xf6 },
{0x28, 0xaa, 0x20, 0x71 },
{0x76, 0xcc, 0x30, 0x5d },
{0x5e, 0x7c, 0xff, 0x01 },
{0x2b, 0x53, 0x2e, 0xb4 },
{0x7d, 0x35, 0x77, 0xe9 },
{0xe2, 0x7d, 0xbe, 0xe7 },
{0x8c, 0x1b, 0xe7, 0x97 },
{0x0e, 0x01, 0xba, 0xee },
{0xe7, 0x1a, 0x84, 0x27 },
{0xf8, 0xc3, 0x76, 0xf9 },
{0xf4, 0xbb, 0x68, 0x3c },
{0x6f, 0x9e, 0x29, 0xc7 },
{0xbc, 0xa0, 0xfa, 0x94 },
{0xd1, 0x6a, 0x55, 0xbc },
{0xf4, 0xd6, 0x08, 0x96 },
{0x50, 0xf1, 0xff, 0xa5 },
{0xca, 0x30, 0x6b, 0x0d },
{0x3d, 0xad, 0x3c, 0xdc },
{0x7b, 0x4b, 0xbb, 0x5d },
{0x29, 0x97, 0xbf, 0x8d },
{0x56, 0xb9, 0x50, 0x90 },
{0xe8, 0x54, 0x7d, 0xc0 },
{0x34, 0xd0, 0x3a, 0xc4 },
{0xfb, 0x6f, 0x04, 0x6d },
{0x86, 0x11, 0x8a, 0x54 },
{0x76, 0x21, 0x02, 0x7c },
{0x25, 0xc3, 0x55, 0x46 },
{0x7a, 0xe5, 0x19, 0x61 },
{0xef, 0x77, 0x52, 0xe2 },
{0xb5, 0x8a, 0x16, 0x95 },
{0x48, 0x40, 0x47, 0x41 },
{0x5e, 0xa9, 0x09, 0xde },
{0xb3, 0x83, 0xd0, 0x08 },
{0xb3, 0x81, 0x5b, 0x1f },
{0x20, 0x7a, 0xdb, 0x50 },
{0x91, 0x6a, 0x77, 0x0e },
{0xfb, 0x7d, 0x5f, 0x65 },
{0xd8, 0x91, 0x36, 0xef },
{0xc0, 0xa2, 0x25, 0x7f },
{0x68, 0x82, 0xb2, 0x08 },
{0x01, 0xd1, 0x1b, 0xb5 },
{0x2a, 0x7c, 0x73, 0x7d },
{0xa0, 0xf2, 0xde, 0x0e },
{0x59, 0xc4, 0x8d, 0x4a },
{0x43, 0xc4, 0x38, 0x73 },
{0xd9, 0x02, 0xc3, 0x33 },
{0xb9, 0xd2, 0xfb, 0x16 },
{0x98, 0x3c, 0xdc, 0x43 },
{0x34, 0xbf, 0x29, 0x3c },
{0x17, 0x32, 0x39, 0x01 },
{0xc1, 0xa8, 0x89, 0x02 },
{0xed, 0xa5, 0x8d, 0x32 },
{0xea, 0x75, 0xa7, 0xf6 },
{0xd0, 0x51, 0x73, 0x5c }
};
int main() {
const uint8_t vectors_halfsip64[MAXLEN][8] = uint8_t in[64], out[16], k[16];
{
{0x2b, 0x21, 0x70, 0xca, 0x52, 0x14, 0xce, 0x7c },
{0x2f, 0x7b, 0x14, 0x5b, 0xf0, 0xc0, 0x35, 0xbe },
{0xd9, 0x65, 0x05, 0x6f, 0x38, 0x69, 0xd1, 0xe4 },
{0x97, 0xa6, 0x3d, 0x56, 0x45, 0xba, 0xee, 0x3e },
{0x63, 0xe8, 0x92, 0x6f, 0xbe, 0xfd, 0xe2, 0x2a },
{0x34, 0xb9, 0xd8, 0x9b, 0xda, 0x60, 0x3c, 0x60 },
{0xb5, 0xcb, 0xbf, 0xdc, 0x11, 0x88, 0xe6, 0xc5 },
{0x24, 0x5e, 0x4b, 0x2e, 0xea, 0xf8, 0x66, 0xa3 },
{0x1e, 0x25, 0x8f, 0x31, 0x01, 0x51, 0x6a, 0x55 },
{0x72, 0x86, 0x52, 0xc3, 0xe7, 0x10, 0x37, 0x02 },
{0xbc, 0xdd, 0x32, 0x5f, 0xa3, 0x02, 0xef, 0x68 },
{0xf1, 0x89, 0x0d, 0xe5, 0xd6, 0xf3, 0xc6, 0x27 },
{0x9c, 0x09, 0x37, 0x57, 0xa5, 0x06, 0xc5, 0x3e },
{0x2a, 0x32, 0x80, 0xb8, 0xee, 0x44, 0x8a, 0xa4 },
{0xca, 0xb9, 0xdf, 0xa2, 0x03, 0xae, 0x92, 0x9d },
{0xae, 0x36, 0x26, 0x08, 0x32, 0xa6, 0x31, 0xb2 },
{0x7b, 0x32, 0x86, 0xb0, 0x17, 0x5e, 0x26, 0x01 },
{0x9e, 0xba, 0xb3, 0xa1, 0xe8, 0xd4, 0x32, 0xb1 },
{0x00, 0xe1, 0x7d, 0xe3, 0x1d, 0x04, 0xda, 0xe2 },
{0x39, 0x27, 0x3f, 0xef, 0xa7, 0x36, 0xbc, 0xdf },
{0xd8, 0xe7, 0x0a, 0xfb, 0x9c, 0x12, 0x55, 0xcc },
{0x4c, 0x40, 0xd5, 0x8c, 0x3d, 0x86, 0xb0, 0x10 },
{0x34, 0x95, 0xc1, 0xc4, 0x62, 0x5c, 0x42, 0x09 },
{0xe5, 0xed, 0x01, 0xa7, 0x3a, 0xf2, 0xea, 0x26 },
{0x94, 0x78, 0x8c, 0x8a, 0xb1, 0xa2, 0xd7, 0xfb },
{0x33, 0x4e, 0x46, 0x2c, 0x0e, 0xb7, 0x56, 0x67 },
{0x14, 0xa5, 0x34, 0x0f, 0x48, 0x61, 0x90, 0xea },
{0xcf, 0x0b, 0xd7, 0x27, 0xc0, 0x79, 0x7c, 0x25 },
{0x2c, 0x6b, 0x19, 0xbd, 0xc2, 0x22, 0x17, 0x11 },
{0x5a, 0xb2, 0xb1, 0x6a, 0x92, 0x52, 0xe3, 0x44 },
{0x7c, 0xa7, 0xf3, 0xc4, 0x45, 0xa2, 0x33, 0xc1 },
{0x8e, 0x36, 0xe0, 0x0c, 0x93, 0x59, 0xf7, 0x61 },
{0x58, 0x90, 0xd3, 0xdb, 0x17, 0xc6, 0x90, 0x4a },
{0x88, 0x48, 0x7b, 0x94, 0x18, 0x12, 0x7c, 0xa1 },
{0x15, 0x9e, 0xb3, 0x70, 0x3f, 0x81, 0x7d, 0x55 },
{0x2a, 0xec, 0x9c, 0x81, 0xee, 0xa8, 0x92, 0xac },
{0xac, 0x5b, 0x79, 0x0e, 0x61, 0x8b, 0xf3, 0xa8 },
{0x8f, 0xc5, 0xeb, 0x57, 0xee, 0xe4, 0x81, 0x63 },
{0x0e, 0xd0, 0xab, 0xbc, 0x9d, 0x94, 0xe2, 0xd9 },
{0x5d, 0xa3, 0xe5, 0x39, 0x9d, 0xae, 0x66, 0xa5 },
{0x34, 0x13, 0xf9, 0x4c, 0x8c, 0xe9, 0x93, 0x9a },
{0x27, 0x0f, 0xc4, 0xd0, 0x1e, 0x7a, 0x71, 0xb4 },
{0xcd, 0x6a, 0xd8, 0x07, 0x04, 0x3c, 0x84, 0xad },
{0xb7, 0x51, 0x18, 0x64, 0x22, 0xf4, 0x0c, 0x5d },
{0x90, 0xcf, 0x8d, 0xc2, 0x1a, 0x75, 0x82, 0xe2 },
{0x22, 0x96, 0x4a, 0x10, 0xaf, 0xa3, 0x0c, 0x3f },
{0x9c, 0x38, 0x2e, 0x80, 0x14, 0x37, 0x7b, 0xa0 },
{0x98, 0x1c, 0x11, 0x08, 0xe6, 0x4a, 0x36, 0xbb },
{0xc4, 0x51, 0xbb, 0x39, 0x4b, 0xdc, 0x43, 0x55 },
{0x27, 0xb8, 0x2e, 0x1c, 0x92, 0x2c, 0xf2, 0x7c },
{0xbb, 0x4b, 0x27, 0xf0, 0xa6, 0xbb, 0xac, 0x85 },
{0x6c, 0x46, 0xa4, 0xc6, 0x1c, 0xba, 0x82, 0xa4 },
{0x1c, 0xa4, 0xe0, 0x6f, 0xb6, 0x00, 0x5a, 0xe5 },
{0x1f, 0xd2, 0x33, 0x97, 0x70, 0x88, 0x2b, 0x03 },
{0x18, 0xce, 0xa4, 0x4c, 0xea, 0xcb, 0x69, 0x69 },
{0x77, 0x9d, 0x2b, 0xe4, 0xec, 0xd5, 0xd7, 0xe9 },
{0xac, 0x5f, 0x9f, 0xa2, 0x67, 0xc9, 0xae, 0xd1 },
{0x55, 0x86, 0x68, 0x08, 0xea, 0x1f, 0x47, 0xa4 },
{0x23, 0x03, 0x88, 0x1d, 0x4a, 0xea, 0x59, 0xa0 },
{0x4b, 0x06, 0xd7, 0x7d, 0x19, 0x57, 0xfe, 0xee },
{0x87, 0xa8, 0x08, 0x1a, 0xd9, 0x08, 0xac, 0xaa },
{0x4f, 0xb6, 0xce, 0x59, 0xfd, 0xc4, 0xf5, 0x81 },
{0xd5, 0xd2, 0x74, 0xfc, 0xa0, 0x01, 0x91, 0x60 },
{0xd2, 0x6c, 0xed, 0x5b, 0x43, 0x65, 0x36, 0xea },
};
int main()
{
uint8_t in[MAXLEN], out[16], k[16];
int i; int i;
int fails = 0; int fails = 0;
for( i = 0; i < 16; ++i ) k[i] = i; for (i = 0; i < 16; ++i)
k[i] = i;
for (int version = 0; version < 4; ++version) {
#ifdef GETVECTORS
printf("%s\n{\n", functions[version]);
#else
printf("%s\n", labels[version]);
#endif
printf( "SipHash 64-bit tag:\n"); for (i = 0; i < 64; ++i) {
for( i = 0; i < MAXLEN; ++i ) in[i] = i;
{ int len = lengths[version];
in[i] = i; if (version < 2)
siphash( in, i, k, out, 8 ); siphash(in, i, k, out, len);
else
halfsiphash(in, i, k, out, len);
#ifdef GETVECTORS
PRINTHASH(len);
#else
const uint8_t *v = NULL;
switch (version) {
case 0:
v = (uint8_t *)vectors_sip64;
break;
case 1:
v = (uint8_t *)vectors_sip128;
break;
case 2:
v = (uint8_t *)vectors_hsip32;
break;
case 3:
v = (uint8_t *)vectors_hsip64;
break;
default:
break;
}
if ( memcmp( out, vectors_sip64[i], 8 ) ) if (memcmp(out, v + (i * len), len)) {
{ printf("fail for %d bytes\n", i);
printf( "fail for %d bytes\n", i ); fails++;
fails++; }
#endif
} }
#ifdef GETVECTORS
printf("};\n");
#else
if (!fails)
printf("OK\n");
#endif
fails = 0;
} }
if (!fails) printf("OK\n");
fails = 0;
printf( "SipHash 128-bit tag:\n");
for( i = 0; i < MAXLEN; ++i )
{
in[i] = i;
siphash( in, i, k, out, 16 );
if ( memcmp( out, vectors_sip128[i], 16 ) )
{
printf( "fail for %d bytes\n", i );
fails++;
}
}
if (!fails) printf("OK\n");
fails = 0;
printf( "HalfSipHash 32-bit tag:\n");
for( i = 0; i < MAXLEN; ++i )
{
in[i] = i;
halfsiphash( in, i, k, out, 4 );
if ( memcmp( out, vectors_halfsip32[i], 4 ) )
{
printf( "fail for %d bytes\n", i );
fails++;
}
}
if (!fails) printf("OK\n");
fails = 0;
printf( "HalfSipHash 64-bit tag:\n");
for( i = 0; i < MAXLEN; ++i )
{
in[i] = i;
halfsiphash( in, i, k, out, 8 );
if ( memcmp( out, vectors_halfsip64[i], 8 ) )
{
printf( "fail for %d bytes\n", i );
fails++;
}
}
if (!fails) printf("OK\n");
return 0; return 0;
} }

842
vectors.h 100644
View File

@ -0,0 +1,842 @@
#include <stdint.h>
const uint8_t vectors_sip64[64][8] = {
{
0x31, 0x0e, 0x0e, 0xdd, 0x47, 0xdb, 0x6f, 0x72,
},
{
0xfd, 0x67, 0xdc, 0x93, 0xc5, 0x39, 0xf8, 0x74,
},
{
0x5a, 0x4f, 0xa9, 0xd9, 0x09, 0x80, 0x6c, 0x0d,
},
{
0x2d, 0x7e, 0xfb, 0xd7, 0x96, 0x66, 0x67, 0x85,
},
{
0xb7, 0x87, 0x71, 0x27, 0xe0, 0x94, 0x27, 0xcf,
},
{
0x8d, 0xa6, 0x99, 0xcd, 0x64, 0x55, 0x76, 0x18,
},
{
0xce, 0xe3, 0xfe, 0x58, 0x6e, 0x46, 0xc9, 0xcb,
},
{
0x37, 0xd1, 0x01, 0x8b, 0xf5, 0x00, 0x02, 0xab,
},
{
0x62, 0x24, 0x93, 0x9a, 0x79, 0xf5, 0xf5, 0x93,
},
{
0xb0, 0xe4, 0xa9, 0x0b, 0xdf, 0x82, 0x00, 0x9e,
},
{
0xf3, 0xb9, 0xdd, 0x94, 0xc5, 0xbb, 0x5d, 0x7a,
},
{
0xa7, 0xad, 0x6b, 0x22, 0x46, 0x2f, 0xb3, 0xf4,
},
{
0xfb, 0xe5, 0x0e, 0x86, 0xbc, 0x8f, 0x1e, 0x75,
},
{
0x90, 0x3d, 0x84, 0xc0, 0x27, 0x56, 0xea, 0x14,
},
{
0xee, 0xf2, 0x7a, 0x8e, 0x90, 0xca, 0x23, 0xf7,
},
{
0xe5, 0x45, 0xbe, 0x49, 0x61, 0xca, 0x29, 0xa1,
},
{
0xdb, 0x9b, 0xc2, 0x57, 0x7f, 0xcc, 0x2a, 0x3f,
},
{
0x94, 0x47, 0xbe, 0x2c, 0xf5, 0xe9, 0x9a, 0x69,
},
{
0x9c, 0xd3, 0x8d, 0x96, 0xf0, 0xb3, 0xc1, 0x4b,
},
{
0xbd, 0x61, 0x79, 0xa7, 0x1d, 0xc9, 0x6d, 0xbb,
},
{
0x98, 0xee, 0xa2, 0x1a, 0xf2, 0x5c, 0xd6, 0xbe,
},
{
0xc7, 0x67, 0x3b, 0x2e, 0xb0, 0xcb, 0xf2, 0xd0,
},
{
0x88, 0x3e, 0xa3, 0xe3, 0x95, 0x67, 0x53, 0x93,
},
{
0xc8, 0xce, 0x5c, 0xcd, 0x8c, 0x03, 0x0c, 0xa8,
},
{
0x94, 0xaf, 0x49, 0xf6, 0xc6, 0x50, 0xad, 0xb8,
},
{
0xea, 0xb8, 0x85, 0x8a, 0xde, 0x92, 0xe1, 0xbc,
},
{
0xf3, 0x15, 0xbb, 0x5b, 0xb8, 0x35, 0xd8, 0x17,
},
{
0xad, 0xcf, 0x6b, 0x07, 0x63, 0x61, 0x2e, 0x2f,
},
{
0xa5, 0xc9, 0x1d, 0xa7, 0xac, 0xaa, 0x4d, 0xde,
},
{
0x71, 0x65, 0x95, 0x87, 0x66, 0x50, 0xa2, 0xa6,
},
{
0x28, 0xef, 0x49, 0x5c, 0x53, 0xa3, 0x87, 0xad,
},
{
0x42, 0xc3, 0x41, 0xd8, 0xfa, 0x92, 0xd8, 0x32,
},
{
0xce, 0x7c, 0xf2, 0x72, 0x2f, 0x51, 0x27, 0x71,
},
{
0xe3, 0x78, 0x59, 0xf9, 0x46, 0x23, 0xf3, 0xa7,
},
{
0x38, 0x12, 0x05, 0xbb, 0x1a, 0xb0, 0xe0, 0x12,
},
{
0xae, 0x97, 0xa1, 0x0f, 0xd4, 0x34, 0xe0, 0x15,
},
{
0xb4, 0xa3, 0x15, 0x08, 0xbe, 0xff, 0x4d, 0x31,
},
{
0x81, 0x39, 0x62, 0x29, 0xf0, 0x90, 0x79, 0x02,
},
{
0x4d, 0x0c, 0xf4, 0x9e, 0xe5, 0xd4, 0xdc, 0xca,
},
{
0x5c, 0x73, 0x33, 0x6a, 0x76, 0xd8, 0xbf, 0x9a,
},
{
0xd0, 0xa7, 0x04, 0x53, 0x6b, 0xa9, 0x3e, 0x0e,
},
{
0x92, 0x59, 0x58, 0xfc, 0xd6, 0x42, 0x0c, 0xad,
},
{
0xa9, 0x15, 0xc2, 0x9b, 0xc8, 0x06, 0x73, 0x18,
},
{
0x95, 0x2b, 0x79, 0xf3, 0xbc, 0x0a, 0xa6, 0xd4,
},
{
0xf2, 0x1d, 0xf2, 0xe4, 0x1d, 0x45, 0x35, 0xf9,
},
{
0x87, 0x57, 0x75, 0x19, 0x04, 0x8f, 0x53, 0xa9,
},
{
0x10, 0xa5, 0x6c, 0xf5, 0xdf, 0xcd, 0x9a, 0xdb,
},
{
0xeb, 0x75, 0x09, 0x5c, 0xcd, 0x98, 0x6c, 0xd0,
},
{
0x51, 0xa9, 0xcb, 0x9e, 0xcb, 0xa3, 0x12, 0xe6,
},
{
0x96, 0xaf, 0xad, 0xfc, 0x2c, 0xe6, 0x66, 0xc7,
},
{
0x72, 0xfe, 0x52, 0x97, 0x5a, 0x43, 0x64, 0xee,
},
{
0x5a, 0x16, 0x45, 0xb2, 0x76, 0xd5, 0x92, 0xa1,
},
{
0xb2, 0x74, 0xcb, 0x8e, 0xbf, 0x87, 0x87, 0x0a,
},
{
0x6f, 0x9b, 0xb4, 0x20, 0x3d, 0xe7, 0xb3, 0x81,
},
{
0xea, 0xec, 0xb2, 0xa3, 0x0b, 0x22, 0xa8, 0x7f,
},
{
0x99, 0x24, 0xa4, 0x3c, 0xc1, 0x31, 0x57, 0x24,
},
{
0xbd, 0x83, 0x8d, 0x3a, 0xaf, 0xbf, 0x8d, 0xb7,
},
{
0x0b, 0x1a, 0x2a, 0x32, 0x65, 0xd5, 0x1a, 0xea,
},
{
0x13, 0x50, 0x79, 0xa3, 0x23, 0x1c, 0xe6, 0x60,
},
{
0x93, 0x2b, 0x28, 0x46, 0xe4, 0xd7, 0x06, 0x66,
},
{
0xe1, 0x91, 0x5f, 0x5c, 0xb1, 0xec, 0xa4, 0x6c,
},
{
0xf3, 0x25, 0x96, 0x5c, 0xa1, 0x6d, 0x62, 0x9f,
},
{
0x57, 0x5f, 0xf2, 0x8e, 0x60, 0x38, 0x1b, 0xe5,
},
{
0x72, 0x45, 0x06, 0xeb, 0x4c, 0x32, 0x8a, 0x95,
},
};
const uint8_t vectors_sip128[64][16] = {
{
0xa3, 0x81, 0x7f, 0x04, 0xba, 0x25, 0xa8, 0xe6, 0x6d, 0xf6, 0x72, 0x14,
0xc7, 0x55, 0x02, 0x93,
},
{
0xda, 0x87, 0xc1, 0xd8, 0x6b, 0x99, 0xaf, 0x44, 0x34, 0x76, 0x59, 0x11,
0x9b, 0x22, 0xfc, 0x45,
},
{
0x81, 0x77, 0x22, 0x8d, 0xa4, 0xa4, 0x5d, 0xc7, 0xfc, 0xa3, 0x8b, 0xde,
0xf6, 0x0a, 0xff, 0xe4,
},
{
0x9c, 0x70, 0xb6, 0x0c, 0x52, 0x67, 0xa9, 0x4e, 0x5f, 0x33, 0xb6, 0xb0,
0x29, 0x85, 0xed, 0x51,
},
{
0xf8, 0x81, 0x64, 0xc1, 0x2d, 0x9c, 0x8f, 0xaf, 0x7d, 0x0f, 0x6e, 0x7c,
0x7b, 0xcd, 0x55, 0x79,
},
{
0x13, 0x68, 0x87, 0x59, 0x80, 0x77, 0x6f, 0x88, 0x54, 0x52, 0x7a, 0x07,
0x69, 0x0e, 0x96, 0x27,
},
{
0x14, 0xee, 0xca, 0x33, 0x8b, 0x20, 0x86, 0x13, 0x48, 0x5e, 0xa0, 0x30,
0x8f, 0xd7, 0xa1, 0x5e,
},
{
0xa1, 0xf1, 0xeb, 0xbe, 0xd8, 0xdb, 0xc1, 0x53, 0xc0, 0xb8, 0x4a, 0xa6,
0x1f, 0xf0, 0x82, 0x39,
},
{
0x3b, 0x62, 0xa9, 0xba, 0x62, 0x58, 0xf5, 0x61, 0x0f, 0x83, 0xe2, 0x64,
0xf3, 0x14, 0x97, 0xb4,
},
{
0x26, 0x44, 0x99, 0x06, 0x0a, 0xd9, 0xba, 0xab, 0xc4, 0x7f, 0x8b, 0x02,
0xbb, 0x6d, 0x71, 0xed,
},
{
0x00, 0x11, 0x0d, 0xc3, 0x78, 0x14, 0x69, 0x56, 0xc9, 0x54, 0x47, 0xd3,
0xf3, 0xd0, 0xfb, 0xba,
},
{
0x01, 0x51, 0xc5, 0x68, 0x38, 0x6b, 0x66, 0x77, 0xa2, 0xb4, 0xdc, 0x6f,
0x81, 0xe5, 0xdc, 0x18,
},
{
0xd6, 0x26, 0xb2, 0x66, 0x90, 0x5e, 0xf3, 0x58, 0x82, 0x63, 0x4d, 0xf6,
0x85, 0x32, 0xc1, 0x25,
},
{
0x98, 0x69, 0xe2, 0x47, 0xe9, 0xc0, 0x8b, 0x10, 0xd0, 0x29, 0x93, 0x4f,
0xc4, 0xb9, 0x52, 0xf7,
},
{
0x31, 0xfc, 0xef, 0xac, 0x66, 0xd7, 0xde, 0x9c, 0x7e, 0xc7, 0x48, 0x5f,
0xe4, 0x49, 0x49, 0x02,
},
{
0x54, 0x93, 0xe9, 0x99, 0x33, 0xb0, 0xa8, 0x11, 0x7e, 0x08, 0xec, 0x0f,
0x97, 0xcf, 0xc3, 0xd9,
},
{
0x6e, 0xe2, 0xa4, 0xca, 0x67, 0xb0, 0x54, 0xbb, 0xfd, 0x33, 0x15, 0xbf,
0x85, 0x23, 0x05, 0x77,
},
{
0x47, 0x3d, 0x06, 0xe8, 0x73, 0x8d, 0xb8, 0x98, 0x54, 0xc0, 0x66, 0xc4,
0x7a, 0xe4, 0x77, 0x40,
},
{
0xa4, 0x26, 0xe5, 0xe4, 0x23, 0xbf, 0x48, 0x85, 0x29, 0x4d, 0xa4, 0x81,
0xfe, 0xae, 0xf7, 0x23,
},
{
0x78, 0x01, 0x77, 0x31, 0xcf, 0x65, 0xfa, 0xb0, 0x74, 0xd5, 0x20, 0x89,
0x52, 0x51, 0x2e, 0xb1,
},
{
0x9e, 0x25, 0xfc, 0x83, 0x3f, 0x22, 0x90, 0x73, 0x3e, 0x93, 0x44, 0xa5,
0xe8, 0x38, 0x39, 0xeb,
},
{
0x56, 0x8e, 0x49, 0x5a, 0xbe, 0x52, 0x5a, 0x21, 0x8a, 0x22, 0x14, 0xcd,
0x3e, 0x07, 0x1d, 0x12,
},
{
0x4a, 0x29, 0xb5, 0x45, 0x52, 0xd1, 0x6b, 0x9a, 0x46, 0x9c, 0x10, 0x52,
0x8e, 0xff, 0x0a, 0xae,
},
{
0xc9, 0xd1, 0x84, 0xdd, 0xd5, 0xa9, 0xf5, 0xe0, 0xcf, 0x8c, 0xe2, 0x9a,
0x9a, 0xbf, 0x69, 0x1c,
},
{
0x2d, 0xb4, 0x79, 0xae, 0x78, 0xbd, 0x50, 0xd8, 0x88, 0x2a, 0x8a, 0x17,
0x8a, 0x61, 0x32, 0xad,
},
{
0x8e, 0xce, 0x5f, 0x04, 0x2d, 0x5e, 0x44, 0x7b, 0x50, 0x51, 0xb9, 0xea,
0xcb, 0x8d, 0x8f, 0x6f,
},
{
0x9c, 0x0b, 0x53, 0xb4, 0xb3, 0xc3, 0x07, 0xe8, 0x7e, 0xae, 0xe0, 0x86,
0x78, 0x14, 0x1f, 0x66,
},
{
0xab, 0xf2, 0x48, 0xaf, 0x69, 0xa6, 0xea, 0xe4, 0xbf, 0xd3, 0xeb, 0x2f,
0x12, 0x9e, 0xeb, 0x94,
},
{
0x06, 0x64, 0xda, 0x16, 0x68, 0x57, 0x4b, 0x88, 0xb9, 0x35, 0xf3, 0x02,
0x73, 0x58, 0xae, 0xf4,
},
{
0xaa, 0x4b, 0x9d, 0xc4, 0xbf, 0x33, 0x7d, 0xe9, 0x0c, 0xd4, 0xfd, 0x3c,
0x46, 0x7c, 0x6a, 0xb7,
},
{
0xea, 0x5c, 0x7f, 0x47, 0x1f, 0xaf, 0x6b, 0xde, 0x2b, 0x1a, 0xd7, 0xd4,
0x68, 0x6d, 0x22, 0x87,
},
{
0x29, 0x39, 0xb0, 0x18, 0x32, 0x23, 0xfa, 0xfc, 0x17, 0x23, 0xde, 0x4f,
0x52, 0xc4, 0x3d, 0x35,
},
{
0x7c, 0x39, 0x56, 0xca, 0x5e, 0xea, 0xfc, 0x3e, 0x36, 0x3e, 0x9d, 0x55,
0x65, 0x46, 0xeb, 0x68,
},
{
0x77, 0xc6, 0x07, 0x71, 0x46, 0xf0, 0x1c, 0x32, 0xb6, 0xb6, 0x9d, 0x5f,
0x4e, 0xa9, 0xff, 0xcf,
},
{
0x37, 0xa6, 0x98, 0x6c, 0xb8, 0x84, 0x7e, 0xdf, 0x09, 0x25, 0xf0, 0xf1,
0x30, 0x9b, 0x54, 0xde,
},
{
0xa7, 0x05, 0xf0, 0xe6, 0x9d, 0xa9, 0xa8, 0xf9, 0x07, 0x24, 0x1a, 0x2e,
0x92, 0x3c, 0x8c, 0xc8,
},
{
0x3d, 0xc4, 0x7d, 0x1f, 0x29, 0xc4, 0x48, 0x46, 0x1e, 0x9e, 0x76, 0xed,
0x90, 0x4f, 0x67, 0x11,
},
{
0x0d, 0x62, 0xbf, 0x01, 0xe6, 0xfc, 0x0e, 0x1a, 0x0d, 0x3c, 0x47, 0x51,
0xc5, 0xd3, 0x69, 0x2b,
},
{
0x8c, 0x03, 0x46, 0x8b, 0xca, 0x7c, 0x66, 0x9e, 0xe4, 0xfd, 0x5e, 0x08,
0x4b, 0xbe, 0xe7, 0xb5,
},
{
0x52, 0x8a, 0x5b, 0xb9, 0x3b, 0xaf, 0x2c, 0x9c, 0x44, 0x73, 0xcc, 0xe5,
0xd0, 0xd2, 0x2b, 0xd9,
},
{
0xdf, 0x6a, 0x30, 0x1e, 0x95, 0xc9, 0x5d, 0xad, 0x97, 0xae, 0x0c, 0xc8,
0xc6, 0x91, 0x3b, 0xd8,
},
{
0x80, 0x11, 0x89, 0x90, 0x2c, 0x85, 0x7f, 0x39, 0xe7, 0x35, 0x91, 0x28,
0x5e, 0x70, 0xb6, 0xdb,
},
{
0xe6, 0x17, 0x34, 0x6a, 0xc9, 0xc2, 0x31, 0xbb, 0x36, 0x50, 0xae, 0x34,
0xcc, 0xca, 0x0c, 0x5b,
},
{
0x27, 0xd9, 0x34, 0x37, 0xef, 0xb7, 0x21, 0xaa, 0x40, 0x18, 0x21, 0xdc,
0xec, 0x5a, 0xdf, 0x89,
},
{
0x89, 0x23, 0x7d, 0x9d, 0xed, 0x9c, 0x5e, 0x78, 0xd8, 0xb1, 0xc9, 0xb1,
0x66, 0xcc, 0x73, 0x42,
},
{
0x4a, 0x6d, 0x80, 0x91, 0xbf, 0x5e, 0x7d, 0x65, 0x11, 0x89, 0xfa, 0x94,
0xa2, 0x50, 0xb1, 0x4c,
},
{
0x0e, 0x33, 0xf9, 0x60, 0x55, 0xe7, 0xae, 0x89, 0x3f, 0xfc, 0x0e, 0x3d,
0xcf, 0x49, 0x29, 0x02,
},
{
0xe6, 0x1c, 0x43, 0x2b, 0x72, 0x0b, 0x19, 0xd1, 0x8e, 0xc8, 0xd8, 0x4b,
0xdc, 0x63, 0x15, 0x1b,
},
{
0xf7, 0xe5, 0xae, 0xf5, 0x49, 0xf7, 0x82, 0xcf, 0x37, 0x90, 0x55, 0xa6,
0x08, 0x26, 0x9b, 0x16,
},
{
0x43, 0x8d, 0x03, 0x0f, 0xd0, 0xb7, 0xa5, 0x4f, 0xa8, 0x37, 0xf2, 0xad,
0x20, 0x1a, 0x64, 0x03,
},
{
0xa5, 0x90, 0xd3, 0xee, 0x4f, 0xbf, 0x04, 0xe3, 0x24, 0x7e, 0x0d, 0x27,
0xf2, 0x86, 0x42, 0x3f,
},
{
0x5f, 0xe2, 0xc1, 0xa1, 0x72, 0xfe, 0x93, 0xc4, 0xb1, 0x5c, 0xd3, 0x7c,
0xae, 0xf9, 0xf5, 0x38,
},
{
0x2c, 0x97, 0x32, 0x5c, 0xbd, 0x06, 0xb3, 0x6e, 0xb2, 0x13, 0x3d, 0xd0,
0x8b, 0x3a, 0x01, 0x7c,
},
{
0x92, 0xc8, 0x14, 0x22, 0x7a, 0x6b, 0xca, 0x94, 0x9f, 0xf0, 0x65, 0x9f,
0x00, 0x2a, 0xd3, 0x9e,
},
{
0xdc, 0xe8, 0x50, 0x11, 0x0b, 0xd8, 0x32, 0x8c, 0xfb, 0xd5, 0x08, 0x41,
0xd6, 0x91, 0x1d, 0x87,
},
{
0x67, 0xf1, 0x49, 0x84, 0xc7, 0xda, 0x79, 0x12, 0x48, 0xe3, 0x2b, 0xb5,
0x92, 0x25, 0x83, 0xda,
},
{
0x19, 0x38, 0xf2, 0xcf, 0x72, 0xd5, 0x4e, 0xe9, 0x7e, 0x94, 0x16, 0x6f,
0xa9, 0x1d, 0x2a, 0x36,
},
{
0x74, 0x48, 0x1e, 0x96, 0x46, 0xed, 0x49, 0xfe, 0x0f, 0x62, 0x24, 0x30,
0x16, 0x04, 0x69, 0x8e,
},
{
0x57, 0xfc, 0xa5, 0xde, 0x98, 0xa9, 0xd6, 0xd8, 0x00, 0x64, 0x38, 0xd0,
0x58, 0x3d, 0x8a, 0x1d,
},
{
0x9f, 0xec, 0xde, 0x1c, 0xef, 0xdc, 0x1c, 0xbe, 0xd4, 0x76, 0x36, 0x74,
0xd9, 0x57, 0x53, 0x59,
},
{
0xe3, 0x04, 0x0c, 0x00, 0xeb, 0x28, 0xf1, 0x53, 0x66, 0xca, 0x73, 0xcb,
0xd8, 0x72, 0xe7, 0x40,
},
{
0x76, 0x97, 0x00, 0x9a, 0x6a, 0x83, 0x1d, 0xfe, 0xcc, 0xa9, 0x1c, 0x59,
0x93, 0x67, 0x0f, 0x7a,
},
{
0x58, 0x53, 0x54, 0x23, 0x21, 0xf5, 0x67, 0xa0, 0x05, 0xd5, 0x47, 0xa4,
0xf0, 0x47, 0x59, 0xbd,
},
{
0x51, 0x50, 0xd1, 0x77, 0x2f, 0x50, 0x83, 0x4a, 0x50, 0x3e, 0x06, 0x9a,
0x97, 0x3f, 0xbd, 0x7c,
},
};
const uint8_t vectors_hsip32[64][4] = {
{
0xa9, 0x35, 0x9f, 0x5b,
},
{
0x27, 0x47, 0x5a, 0xb8,
},
{
0xfa, 0x62, 0xa6, 0x03,
},
{
0x8a, 0xfe, 0xe7, 0x04,
},
{
0x2a, 0x6e, 0x46, 0x89,
},
{
0x96, 0x6b, 0x93, 0xe7,
},
{
0x43, 0x4b, 0x6d, 0x41,
},
{
0x28, 0xb5, 0x0d, 0x07,
},
{
0xd0, 0xb8, 0x84, 0x8f,
},
{
0xf8, 0x06, 0xe7, 0x79,
},
{
0x94, 0xb0, 0x79, 0x34,
},
{
0x08, 0x08, 0x30, 0x50,
},
{
0x57, 0xf0, 0x87, 0x2f,
},
{
0xa1, 0x0f, 0x73, 0x9f,
},
{
0x38, 0x48, 0x0e, 0x12,
},
{
0xf5, 0x57, 0xcd, 0x5e,
},
{
0xd9, 0xb5, 0xac, 0x84,
},
{
0xc4, 0x74, 0x64, 0x5b,
},
{
0x46, 0x5b, 0x8d, 0x9b,
},
{
0x7b, 0xef, 0xe3, 0x87,
},
{
0xe3, 0x4d, 0x10, 0x45,
},
{
0x95, 0xba, 0x05, 0xfe,
},
{
0x9d, 0x7c, 0x9a, 0x07,
},
{
0xcd, 0x96, 0x37, 0xbe,
},
{
0x27, 0x40, 0x0c, 0x63,
},
{
0x26, 0x78, 0x78, 0x75,
},
{
0x4f, 0x56, 0x7b, 0x5f,
},
{
0x3a, 0xb0, 0xe6, 0x69,
},
{
0xb0, 0x64, 0x40, 0x00,
},
{
0xad, 0x29, 0x2c, 0x76,
},
{
0x42, 0x05, 0x54, 0x3e,
},
{
0xc1, 0xda, 0x40, 0x4b,
},
{
0xfe, 0xe7, 0x21, 0x12,
},
{
0x33, 0x75, 0x32, 0x59,
},
{
0x6a, 0x43, 0x4f, 0x8c,
},
{
0xfe, 0x28, 0xb7, 0x29,
},
{
0xe7, 0x5c, 0xc6, 0xec,
},
{
0x88, 0x25, 0x34, 0x1c,
},
{
0x90, 0x4c, 0xc5, 0x8a,
},
{
0xf9, 0xe9, 0x16, 0x41,
},
{
0xb6, 0xbc, 0x18, 0x40,
},
{
0x5d, 0x07, 0x45, 0x05,
},
{
0x24, 0x42, 0xfd, 0x2e,
},
{
0x7b, 0xb7, 0x86, 0x3a,
},
{
0x77, 0x05, 0xd5, 0x48,
},
{
0x5b, 0x5a, 0xb7, 0x0f,
},
{
0x5e, 0xc0, 0x6e, 0x74,
},
{
0xca, 0x87, 0x82, 0x24,
},
{
0x69, 0xe1, 0x2c, 0xe3,
},
{
0x8d, 0xb5, 0x80, 0xe5,
},
{
0x36, 0x97, 0x64, 0xc6,
},
{
0x01, 0x6e, 0x02, 0x04,
},
{
0x3b, 0x85, 0xf3, 0xd4,
},
{
0xc8, 0xc5, 0x57, 0x61,
},
{
0xf3, 0x91, 0x27, 0xc1,
},
{
0x78, 0xbb, 0xb1, 0x05,
},
{
0xa5, 0xc5, 0xb9, 0x40,
},
{
0x9b, 0xe9, 0xe8, 0x8c,
},
{
0x7d, 0xbc, 0x81, 0x40,
},
{
0x7c, 0x07, 0x8e, 0xc5,
},
{
0xd4, 0xe7, 0x6c, 0x73,
},
{
0xb4, 0xca, 0xe1, 0x2a,
},
{
0xed, 0x5d, 0x0a, 0x4f,
},
{
0x3b, 0x29, 0xe1, 0x55,
},
};
const uint8_t vectors_hsip64[64][8] = {
{
0x21, 0x8d, 0x1f, 0x59, 0xb9, 0xb8, 0x3c, 0xc8,
},
{
0xbe, 0x55, 0x24, 0x12, 0xf8, 0x38, 0x73, 0x15,
},
{
0x06, 0x4f, 0x39, 0xef, 0x7c, 0x50, 0xeb, 0x57,
},
{
0xce, 0x0f, 0x1a, 0x45, 0xf7, 0x06, 0x06, 0x79,
},
{
0xd5, 0xe7, 0x8a, 0x17, 0x5b, 0xe5, 0x2e, 0xa1,
},
{
0x8b, 0x61, 0x44, 0x6b, 0x69, 0x65, 0x45, 0x3f,
},
{
0x43, 0xb6, 0xd1, 0x2c, 0x12, 0xe6, 0xa4, 0x83,
},
{
0xa1, 0x97, 0xbf, 0x56, 0x20, 0x9e, 0x3f, 0xb5,
},
{
0xed, 0xfe, 0xe8, 0x20, 0xbc, 0xe4, 0x85, 0x8c,
},
{
0x5b, 0x51, 0xcc, 0xcc, 0x13, 0x88, 0x83, 0x07,
},
{
0x95, 0xb0, 0x46, 0x9f, 0x06, 0xa6, 0xf2, 0xee,
},
{
0xae, 0x26, 0x33, 0x39, 0x94, 0xdd, 0xcd, 0x48,
},
{
0x7b, 0xc7, 0x1f, 0x9f, 0xae, 0xf5, 0xc7, 0x99,
},
{
0xbb, 0x2f, 0x5b, 0xb8, 0x24, 0x5d, 0x05, 0x6b,
},
{
0x2f, 0x7b, 0xb0, 0xc8, 0xfd, 0x90, 0x99, 0xb9,
},
{
0x52, 0x7a, 0x26, 0x11, 0x58, 0xbf, 0x5d, 0xd7,
},
{
0x73, 0x36, 0xaa, 0xd2, 0x5f, 0x7b, 0xf3, 0xb5,
},
{
0x37, 0xad, 0xc0, 0x64, 0x1c, 0x4c, 0x4f, 0x6a,
},
{
0xc9, 0xb2, 0xdb, 0x2b, 0x9a, 0x3e, 0x42, 0xf9,
},
{
0xf9, 0x10, 0xe4, 0x80, 0x20, 0xab, 0x36, 0x3c,
},
{
0x1b, 0xf5, 0x2b, 0x0a, 0x6f, 0xee, 0xa7, 0xdb,
},
{
0x58, 0x74, 0xd9, 0x26, 0x7b, 0x8e, 0xb7, 0xd2,
},
{
0x5b, 0x82, 0x73, 0x21, 0xf7, 0xef, 0xa8, 0x08,
},
{
0x61, 0x8e, 0x73, 0xc7, 0x7e, 0x26, 0xa6, 0xad,
},
{
0x70, 0x74, 0x10, 0x45, 0xae, 0x3f, 0xa6, 0xf1,
},
{
0x0c, 0x86, 0x40, 0x37, 0x39, 0x71, 0x40, 0x38,
},
{
0x0d, 0x89, 0x9e, 0xd8, 0x11, 0x29, 0x23, 0xf0,
},
{
0x22, 0x6b, 0xf5, 0xfa, 0xb8, 0x1e, 0xe1, 0xb8,
},
{
0x2d, 0x92, 0x5f, 0xfb, 0x1e, 0x00, 0x16, 0xb5,
},
{
0x05, 0x1c, 0xb8, 0x28, 0xc2, 0xd3, 0xbb, 0x5d,
},
{
0xc0, 0xb9, 0xf9, 0x13, 0x5f, 0xdf, 0x47, 0x38,
},
{
0x63, 0x08, 0x23, 0x13, 0xd7, 0x8a, 0x9d, 0xe5,
},
{
0x28, 0x70, 0x9d, 0x46, 0xd8, 0x11, 0x62, 0x6c,
},
{
0x24, 0x84, 0x77, 0x68, 0x1d, 0x28, 0xf8, 0x9c,
},
{
0x83, 0x24, 0xe4, 0xd7, 0x52, 0x8f, 0x98, 0x30,
},
{
0xf9, 0xef, 0xd4, 0xe1, 0x3a, 0xea, 0x6b, 0xd8,
},
{
0x86, 0xd6, 0x7a, 0x40, 0xec, 0x42, 0x76, 0xdc,
},
{
0x63, 0x28, 0x0a, 0x25, 0x56, 0xc8, 0x2e, 0x39,
},
{
0x01, 0xd3, 0xcd, 0xb4, 0xe5, 0xb0, 0x5c, 0x93,
},
{
0x7a, 0x7d, 0x1c, 0x15, 0x8c, 0xc3, 0x12, 0x86,
},
{
0x5b, 0x38, 0xc8, 0x1c, 0x67, 0xc8, 0xae, 0x4c,
},
{
0x95, 0xab, 0x71, 0x89, 0xd4, 0x39, 0xac, 0xb3,
},
{
0xa9, 0x1a, 0x52, 0xc0, 0x25, 0x32, 0x70, 0x24,
},
{
0x5b, 0x00, 0x87, 0xc6, 0x95, 0x28, 0xac, 0xea,
},
{
0x1e, 0x30, 0xf3, 0xad, 0x27, 0xdc, 0xb1, 0x5a,
},
{
0xd4, 0xf7, 0x64, 0x16, 0x36, 0xe4, 0x1e, 0xf8,
},
{
0x53, 0x50, 0x4e, 0x3e, 0x26, 0xa9, 0x0c, 0x10,
},
{
0x86, 0xc4, 0xfa, 0xe9, 0x82, 0xd9, 0x28, 0xac,
},
{
0xa9, 0xea, 0xa8, 0xc0, 0x4b, 0xa9, 0x3e, 0x3e,
},
{
0xee, 0xa4, 0xc1, 0x73, 0x7d, 0x01, 0x12, 0x18,
},
{
0x91, 0x2d, 0x56, 0x8f, 0xd8, 0xf6, 0x5a, 0x49,
},
{
0x56, 0x91, 0x95, 0x96, 0xb0, 0xff, 0x5c, 0x97,
},
{
0x02, 0x44, 0x5a, 0x79, 0x98, 0xf5, 0x50, 0xe1,
},
{
0x46, 0x9d, 0x24, 0xfd, 0x2c, 0xa1, 0x17, 0x84,
},
{
0xd0, 0x0f, 0x8e, 0x6f, 0xad, 0x4b, 0xdc, 0x9a,
},
{
0x8e, 0x3f, 0x4f, 0x1c, 0x9c, 0x67, 0xaf, 0x49,
},
{
0xa1, 0xa4, 0x92, 0xf9, 0x42, 0xf1, 0x5f, 0x1d,
},
{
0x12, 0xec, 0x26, 0x7f, 0xf6, 0x09, 0x5b, 0x6e,
},
{
0x5d, 0x1b, 0x5e, 0xa1, 0xb2, 0x31, 0xd8, 0x9d,
},
{
0xd8, 0xcf, 0xb4, 0x45, 0x3f, 0x92, 0xee, 0x54,
},
{
0xd6, 0x76, 0x28, 0x90, 0xbf, 0x26, 0xe4, 0x60,
},
{
0xb0, 0x66, 0x86, 0x1e, 0xf2, 0x44, 0x1d, 0x2a,
},
{
0xd6, 0x15, 0xa6, 0xbb, 0xab, 0xf8, 0xff, 0x78,
},
{
0x7c, 0x70, 0x85, 0x9a, 0xcd, 0x70, 0x16, 0xce,
},
};