528 lines
20 KiB
C
528 lines
20 KiB
C
#include "include/conf.h"
|
|
|
|
#include "include/def.h"
|
|
#include "include/hashing.h"
|
|
|
|
#define VS_ROTL64(arg, rot) \
|
|
(((arg) << ((uint64_t)(rot))) | ((arg) >> (((uint64_t)64) - ((uint64_t)(rot)))))
|
|
|
|
size_t vs_u64_to_hash_size(uint64_t num) {
|
|
#if SIZE_MAX == UINT64_MAX
|
|
return (size_t)num;
|
|
#elif SIZE_MAX == UINT32_MAX
|
|
return (size_t)(((uint32_t)num) ^ ((uint32_t)(num >> 32)));
|
|
#elif SIZE_MAX == UINT16_MAX
|
|
return (size_t)(((uint16_t)num) ^ ((uint16_t)(num >> 16)) ^ ((uint16_t)(num >> 32)) ^
|
|
((uint16_t)(num >> 48)));
|
|
#elif SIZE_MAX == UINT8_MAX
|
|
return (size_t)(((uint8_t)num) ^ ((uint8_t)(num >> 8)) ^ ((uint8_t)(num >> 16)) ^
|
|
((uint8_t)(num >> 24)) ^ ((uint8_t)(num >> 32)) ^ ((uint8_t)(num >> 40)) ^
|
|
((uint8_t)(num >> 48)) ^ ((uint8_t)(num >> 56)));
|
|
#else
|
|
# error "u64_to_hash_size: Unsupported size_t width"
|
|
#endif
|
|
}
|
|
|
|
uint64_t vs_fasthash(const void *src, size_t size) {
|
|
const uint8_t *data = (const uint8_t *)src;
|
|
uint64_t hash = 0;
|
|
|
|
for (size_t idx = 0; idx < size; ++idx) {
|
|
hash ^= data[idx];
|
|
hash *= ((uint64_t)0x2127599bf4325c37ULL);
|
|
hash ^= hash >> ((uint64_t)47);
|
|
}
|
|
|
|
return hash;
|
|
}
|
|
|
|
/* MurMurHash implementation */
|
|
|
|
uint64_t vs_murmurhash(const void *key, size_t size, uint64_t seed) {
|
|
const uint64_t const1 = 0x87c37b91114253d5;
|
|
const uint64_t const2 = 0x4cf5ad432745937f;
|
|
|
|
uint64_t hash = seed ^ ((uint64_t)size * const1);
|
|
const uint8_t *data = (const uint8_t *)key;
|
|
|
|
/* Handle 8 byte chunks */
|
|
|
|
for (size_t idx = 0; idx < size / 8; ++idx) {
|
|
uint64_t block = *(const uint64_t *)(data + (idx * 8));
|
|
block = VS_TO_ULE64(block);
|
|
|
|
block *= const1;
|
|
block = VS_ROTL64(block, 31);
|
|
block *= const2;
|
|
|
|
hash ^= block;
|
|
hash = VS_ROTL64(hash, 27);
|
|
hash = hash * 5 + 0x52dce729;
|
|
}
|
|
|
|
/* Handle remaining bytes */
|
|
|
|
const uint8_t *tail = data + ((size / 8) * 8);
|
|
uint64_t final = 0;
|
|
|
|
switch (size & ((uint64_t)7)) {
|
|
case 7:
|
|
final ^= ((uint64_t)(tail[6]) << ((uint64_t)48)); /* Fallthrough */
|
|
case 6:
|
|
final ^= ((uint64_t)(tail[5]) << ((uint64_t)40)); /* Fallthrough */
|
|
case 5:
|
|
final ^= ((uint64_t)(tail[4]) << ((uint64_t)32)); /* Fallthrough */
|
|
case 4:
|
|
final ^= ((uint64_t)(tail[3]) << ((uint64_t)24)); /* Fallthrough */
|
|
case 3:
|
|
final ^= ((uint64_t)(tail[2]) << ((uint64_t)16)); /* Fallthrough */
|
|
case 2:
|
|
final ^= ((uint64_t)(tail[1]) << ((uint64_t)8)); /* Fallthrough */
|
|
case 1: /* Fallthrough */
|
|
final ^= ((uint64_t)(tail[0]));
|
|
final *= const1;
|
|
final = VS_ROTL64(final, 31);
|
|
final *= const2;
|
|
hash ^= final;
|
|
break;
|
|
default:
|
|
/* No tail bytes to process, do nothing */
|
|
break;
|
|
}
|
|
|
|
/* Finalization */
|
|
|
|
hash ^= ((uint64_t)size);
|
|
hash ^= (hash >> ((uint64_t)33));
|
|
hash *= (uint64_t)0xff51afda721f0213ULL;
|
|
hash ^= (hash >> ((uint64_t)33));
|
|
hash *= (uint64_t)0xc4ceb9fe87b37cf9ULL;
|
|
hash ^= (hash >> ((uint64_t)33));
|
|
|
|
return hash;
|
|
}
|
|
|
|
uint64_t vs_fnv1a(const void *key, size_t size) {
|
|
uint64_t hash = (uint64_t)14695981039346656037ULL;
|
|
const uint8_t *data = (const uint8_t *)key;
|
|
|
|
for (size_t idx = 0; idx < size; ++idx) {
|
|
hash ^= data[idx];
|
|
hash *= 1099511628211ULL;
|
|
}
|
|
|
|
return hash;
|
|
}
|
|
|
|
uint64_t vs_djb2(const void *key, size_t size) {
|
|
uint64_t hash = (uint64_t)5381;
|
|
const uint8_t *data = (const uint8_t *)key;
|
|
|
|
for (size_t idx = 0; idx < size; ++idx) {
|
|
hash = ((hash << ((uint64_t)5)) + hash) + data[idx];
|
|
}
|
|
|
|
return hash;
|
|
}
|
|
|
|
/* xxHash implementation */
|
|
|
|
#define VS_XXH3_PRIME64_1 ((uint64_t)0x9E3779B185EBCA87ULL)
|
|
#define VS_XXH3_PRIME64_2 ((uint64_t)0xC2B2AE3D27D4EB4FULL)
|
|
#define VS_XXH3_PRIME64_3 ((uint64_t)0x165667B19E3779F9ULL)
|
|
#define VS_XXH3_PRIME64_4 ((uint64_t)0x85EBCA77C2B2AE63ULL)
|
|
#define VS_XXH3_PRIME64_5 ((uint64_t)0x27D4EB2F165667C5ULL)
|
|
|
|
#define VS_XXH3_AVALANCHE(hash) \
|
|
(hash) ^= (hash) >> ((uint64_t)37); \
|
|
(hash) *= VS_XXH3_PRIME64_3; \
|
|
(hash) ^= (hash) >> ((uint64_t)32)
|
|
|
|
#define VS_XXH3_MIX16(input, seed) \
|
|
(VS_TO_ULE64(*(const uint64_t *)(input)) + (seed)) * \
|
|
(VS_TO_ULE64(*(const uint64_t *)((input) + 8)) + (seed)) + \
|
|
VS_XXH3_PRIME64_1
|
|
|
|
uint64_t vs_xxhash3(const void *data, size_t size, uint64_t seed) {
|
|
uint64_t h64 = 0;
|
|
uint64_t block = 0;
|
|
|
|
if (!data || size == 0) {
|
|
return 0;
|
|
}
|
|
|
|
if (seed == 0) {
|
|
seed = (uint64_t)size;
|
|
}
|
|
|
|
const uint8_t *input = (const uint8_t *)data;
|
|
const uint8_t *end = input + size;
|
|
|
|
if (size >= 16) {
|
|
h64 = seed * VS_XXH3_PRIME64_1;
|
|
|
|
do {
|
|
h64 += VS_XXH3_MIX16(input, seed);
|
|
input += 16;
|
|
} while (input <= end - 16);
|
|
|
|
VS_XXH3_AVALANCHE(h64);
|
|
} else {
|
|
h64 = size + VS_XXH3_PRIME64_5;
|
|
}
|
|
|
|
h64 += size;
|
|
|
|
while (input + 8 <= end) {
|
|
block = *(const uint64_t *)input;
|
|
block = VS_TO_ULE64(block);
|
|
block *= VS_XXH3_PRIME64_2;
|
|
block = VS_ROTL64(block, 31);
|
|
block *= VS_XXH3_PRIME64_1;
|
|
h64 ^= block;
|
|
h64 = VS_ROTL64(h64, 27) * VS_XXH3_PRIME64_1 + VS_XXH3_PRIME64_4;
|
|
input += 8;
|
|
}
|
|
|
|
while (input < end) {
|
|
h64 ^= VS_TO_ULE64((uint64_t)(*input)) * VS_XXH3_PRIME64_5;
|
|
h64 = VS_ROTL64(h64, 11) * VS_XXH3_PRIME64_1;
|
|
++input;
|
|
}
|
|
|
|
VS_XXH3_AVALANCHE(h64);
|
|
|
|
return h64;
|
|
}
|
|
|
|
/* SipHash implementation */
|
|
|
|
#define VS_SIPHASH_DOUBLE_ROUND() \
|
|
do { \
|
|
state0 += state1; \
|
|
state2 += state3; \
|
|
state1 = VS_ROTL64(state1, 13); \
|
|
state3 = VS_ROTL64(state3, 16); \
|
|
state1 ^= state0; \
|
|
state3 ^= state2; \
|
|
state0 = VS_ROTL64(state0, 32); \
|
|
state2 += state1; \
|
|
state0 += state3; \
|
|
state1 = VS_ROTL64(state1, 17); \
|
|
state3 = VS_ROTL64(state3, 21); \
|
|
state1 ^= state2; \
|
|
state3 ^= state0; \
|
|
state2 = VS_ROTL64(state2, 32); \
|
|
} while (0)
|
|
|
|
uint64_t vs_siphash64(const void *data,
|
|
size_t size,
|
|
const uint64_t seed[2],
|
|
uint8_t compress_rounds,
|
|
uint8_t final_rounds) {
|
|
if (!data || size == 0 || !seed || compress_rounds < 1 || final_rounds < 1) {
|
|
return 0;
|
|
}
|
|
|
|
uint64_t idx = 0;
|
|
|
|
uint64_t state0 = 0x736f6d6570736575ULL ^ seed[0];
|
|
uint64_t state1 = 0x646f72616e646f6dULL ^ seed[1];
|
|
uint64_t state2 = 0x6c7967656e657261ULL ^ seed[0];
|
|
uint64_t state3 = 0x7465646279746573ULL ^ seed[1];
|
|
|
|
const uint8_t *input = (const uint8_t *)data;
|
|
|
|
const uint64_t *in_end = (const uint64_t *)(input + (((uint64_t)size) & ~(uint64_t)7));
|
|
const uint8_t *in_tail = (const uint8_t *)in_end;
|
|
|
|
uint64_t message = 0;
|
|
uint64_t final = ((uint64_t)size) << 56;
|
|
|
|
while (input != (const uint8_t *)in_end) {
|
|
message = *(const uint64_t *)(input);
|
|
message = VS_TO_ULE64(message);
|
|
input += sizeof(message);
|
|
state3 ^= message;
|
|
|
|
for (idx = 0; idx < compress_rounds; ++idx) {
|
|
VS_SIPHASH_DOUBLE_ROUND();
|
|
}
|
|
|
|
state0 ^= message;
|
|
}
|
|
|
|
for (idx = 0; idx < (((uint64_t)size) & ((uint64_t)7)); ++idx) {
|
|
final |= ((uint64_t)in_tail[idx]) << (8 * idx);
|
|
}
|
|
state3 ^= final;
|
|
|
|
for (idx = 0; idx < compress_rounds; ++idx) {
|
|
VS_SIPHASH_DOUBLE_ROUND();
|
|
}
|
|
state0 ^= final;
|
|
|
|
state2 ^= (uint64_t)0xff;
|
|
for (idx = 0; idx < final_rounds; ++idx) {
|
|
VS_SIPHASH_DOUBLE_ROUND();
|
|
}
|
|
|
|
return state0 ^ state1 ^ state2 ^ state3;
|
|
}
|
|
|
|
/* CRC64 implementation */
|
|
|
|
static const uint64_t vs_crc64_table[256] = {
|
|
0x0000000000000000, 0x42F0E1EBA9EA3693, 0x85E1C3D753D46D26, 0xC711223CFA3E5BB5,
|
|
0x493366450E42ECDF, 0x0BC387AEA7A8DA4C, 0xCCD2A5925D9681F9, 0x8E224479F47CB76A,
|
|
0x9266CC8A1C85D9BE, 0xD0962D61B56FEF2D, 0x17870F5D4F51B498, 0x5577EEB6E6BB820B,
|
|
0xDB55AACF12C73561, 0x99A54B24BB2D03F2, 0x5EB4691841135847, 0x1C4488F3E8F96ED4,
|
|
0x663D78FF90E185EF, 0x24CD9914390BB37C, 0xE3DCBB28C335E8C9, 0xA12C5AC36ADFDE5A,
|
|
0x2F0E1EBA9EA36930, 0x6DFEFF5137495FA3, 0xAAEFDD6DCD770416, 0xE81F3C86649D3285,
|
|
0xF45BB4758C645C51, 0xB6AB559E258E6AC2, 0x71BA77A2DFB03177, 0x334A9649765A07E4,
|
|
0xBD68D2308226B08E, 0xFF9833DB2BCC861D, 0x388911E7D1F2DDA8, 0x7A79F00C7818EB3B,
|
|
0xCC7AF1FF21C30BDE, 0x8E8A101488293D4D, 0x499B3228721766F8, 0x0B6BD3C3DBFD506B,
|
|
0x854997BA2F81E701, 0xC7B97651866BD192, 0x00A8546D7C558A27, 0x4258B586D5BFBCB4,
|
|
0x5E1C3D753D46D260, 0x1CECDC9E94ACE4F3, 0xDBFDFEA26E92BF46, 0x990D1F49C77889D5,
|
|
0x172F5B3033043EBF, 0x55DFBADB9AEE082C, 0x92CE98E760D05399, 0xD03E790CC93A650A,
|
|
0xAA478900B1228E31, 0xE8B768EB18C8B8A2, 0x2FA64AD7E2F6E317, 0x6D56AB3C4B1CD584,
|
|
0xE374EF45BF6062EE, 0xA1840EAE168A547D, 0x66952C92ECB40FC8, 0x2465CD79455E395B,
|
|
0x3821458AADA7578F, 0x7AD1A461044D611C, 0xBDC0865DFE733AA9, 0xFF3067B657990C3A,
|
|
0x711223CFA3E5BB50, 0x33E2C2240A0F8DC3, 0xF4F3E018F031D676, 0xB60301F359DBE0E5,
|
|
0xDA050215EA6C212F, 0x98F5E3FE438617BC, 0x5FE4C1C2B9B84C09, 0x1D14202910527A9A,
|
|
0x93366450E42ECDF0, 0xD1C685BB4DC4FB63, 0x16D7A787B7FAA0D6, 0x5427466C1E109645,
|
|
0x4863CE9FF6E9F891, 0x0A932F745F03CE02, 0xCD820D48A53D95B7, 0x8F72ECA30CD7A324,
|
|
0x0150A8DAF8AB144E, 0x43A04931514122DD, 0x84B16B0DAB7F7968, 0xC6418AE602954FFB,
|
|
0xBC387AEA7A8DA4C0, 0xFEC89B01D3679253, 0x39D9B93D2959C9E6, 0x7B2958D680B3FF75,
|
|
0xF50B1CAF74CF481F, 0xB7FBFD44DD257E8C, 0x70EADF78271B2539, 0x321A3E938EF113AA,
|
|
0x2E5EB66066087D7E, 0x6CAE578BCFE24BED, 0xABBF75B735DC1058, 0xE94F945C9C3626CB,
|
|
0x676DD025684A91A1, 0x259D31CEC1A0A732, 0xE28C13F23B9EFC87, 0xA07CF2199274CA14,
|
|
0x167FF3EACBAF2AF1, 0x548F120162451C62, 0x939E303D987B47D7, 0xD16ED1D631917144,
|
|
0x5F4C95AFC5EDC62E, 0x1DBC74446C07F0BD, 0xDAAD56789639AB08, 0x985DB7933FD39D9B,
|
|
0x84193F60D72AF34F, 0xC6E9DE8B7EC0C5DC, 0x01F8FCB784FE9E69, 0x43081D5C2D14A8FA,
|
|
0xCD2A5925D9681F90, 0x8FDAB8CE70822903, 0x48CB9AF28ABC72B6, 0x0A3B7B1923564425,
|
|
0x70428B155B4EAF1E, 0x32B26AFEF2A4998D, 0xF5A348C2089AC238, 0xB753A929A170F4AB,
|
|
0x3971ED50550C43C1, 0x7B810CBBFCE67552, 0xBC902E8706D82EE7, 0xFE60CF6CAF321874,
|
|
0xE224479F47CB76A0, 0xA0D4A674EE214033, 0x67C58448141F1B86, 0x253565A3BDF52D15,
|
|
0xAB1721DA49899A7F, 0xE9E7C031E063ACEC, 0x2EF6E20D1A5DF759, 0x6C0603E6B3B7C1CA,
|
|
0xF6FAE5C07D3274CD, 0xB40A042BD4D8425E, 0x731B26172EE619EB, 0x31EBC7FC870C2F78,
|
|
0xBFC9838573709812, 0xFD39626EDA9AAE81, 0x3A28405220A4F534, 0x78D8A1B9894EC3A7,
|
|
0x649C294A61B7AD73, 0x266CC8A1C85D9BE0, 0xE17DEA9D3263C055, 0xA38D0B769B89F6C6,
|
|
0x2DAF4F0F6FF541AC, 0x6F5FAEE4C61F773F, 0xA84E8CD83C212C8A, 0xEABE6D3395CB1A19,
|
|
0x90C79D3FEDD3F122, 0xD2377CD44439C7B1, 0x15265EE8BE079C04, 0x57D6BF0317EDAA97,
|
|
0xD9F4FB7AE3911DFD, 0x9B041A914A7B2B6E, 0x5C1538ADB04570DB, 0x1EE5D94619AF4648,
|
|
0x02A151B5F156289C, 0x4051B05E58BC1E0F, 0x87409262A28245BA, 0xC5B073890B687329,
|
|
0x4B9237F0FF14C443, 0x0962D61B56FEF2D0, 0xCE73F427ACC0A965, 0x8C8315CC052A9FF6,
|
|
0x3A80143F5CF17F13, 0x7870F5D4F51B4980, 0xBF61D7E80F251235, 0xFD913603A6CF24A6,
|
|
0x73B3727A52B393CC, 0x31439391FB59A55F, 0xF652B1AD0167FEEA, 0xB4A25046A88DC879,
|
|
0xA8E6D8B54074A6AD, 0xEA16395EE99E903E, 0x2D071B6213A0CB8B, 0x6FF7FA89BA4AFD18,
|
|
0xE1D5BEF04E364A72, 0xA3255F1BE7DC7CE1, 0x64347D271DE22754, 0x26C49CCCB40811C7,
|
|
0x5CBD6CC0CC10FAFC, 0x1E4D8D2B65FACC6F, 0xD95CAF179FC497DA, 0x9BAC4EFC362EA149,
|
|
0x158E0A85C2521623, 0x577EEB6E6BB820B0, 0x906FC95291867B05, 0xD29F28B9386C4D96,
|
|
0xCEDBA04AD0952342, 0x8C2B41A1797F15D1, 0x4B3A639D83414E64, 0x09CA82762AAB78F7,
|
|
0x87E8C60FDED7CF9D, 0xC51827E4773DF90E, 0x020905D88D03A2BB, 0x40F9E43324E99428,
|
|
0x2CFFE7D5975E55E2, 0x6E0F063E3EB46371, 0xA91E2402C48A38C4, 0xEBEEC5E96D600E57,
|
|
0x65CC8190991CB93D, 0x273C607B30F68FAE, 0xE02D4247CAC8D41B, 0xA2DDA3AC6322E288,
|
|
0xBE992B5F8BDB8C5C, 0xFC69CAB42231BACF, 0x3B78E888D80FE17A, 0x7988096371E5D7E9,
|
|
0xF7AA4D1A85996083, 0xB55AACF12C735610, 0x724B8ECDD64D0DA5, 0x30BB6F267FA73B36,
|
|
0x4AC29F2A07BFD00D, 0x08327EC1AE55E69E, 0xCF235CFD546BBD2B, 0x8DD3BD16FD818BB8,
|
|
0x03F1F96F09FD3CD2, 0x41011884A0170A41, 0x86103AB85A2951F4, 0xC4E0DB53F3C36767,
|
|
0xD8A453A01B3A09B3, 0x9A54B24BB2D03F20, 0x5D45907748EE6495, 0x1FB5719CE1045206,
|
|
0x919735E51578E56C, 0xD367D40EBC92D3FF, 0x1476F63246AC884A, 0x568617D9EF46BED9,
|
|
0xE085162AB69D5E3C, 0xA275F7C11F7768AF, 0x6564D5FDE549331A, 0x279434164CA30589,
|
|
0xA9B6706FB8DFB2E3, 0xEB46918411358470, 0x2C57B3B8EB0BDFC5, 0x6EA7525342E1E956,
|
|
0x72E3DAA0AA188782, 0x30133B4B03F2B111, 0xF7021977F9CCEAA4, 0xB5F2F89C5026DC37,
|
|
0x3BD0BCE5A45A6B5D, 0x79205D0E0DB05DCE, 0xBE317F32F78E067B, 0xFCC19ED95E6430E8,
|
|
0x86B86ED5267CDBD3, 0xC4488F3E8F96ED40, 0x0359AD0275A8B6F5, 0x41A94CE9DC428066,
|
|
0xCF8B0890283E370C, 0x8D7BE97B81D4019F, 0x4A6ACB477BEA5A2A, 0x089A2AACD2006CB9,
|
|
0x14DEA25F3AF9026D, 0x562E43B4931334FE, 0x913F6188692D6F4B, 0xD3CF8063C0C759D8,
|
|
0x5DEDC41A34BBEEB2, 0x1F1D25F19D51D821, 0xD80C07CD676F8394, 0x9AFCE626CE85B507
|
|
};
|
|
|
|
uint64_t vs_crc64(const void *data, size_t size, uint64_t previous_crc) {
|
|
const uint8_t *current = (const uint8_t *)data;
|
|
uint64_t crc = ~previous_crc;
|
|
|
|
while (size--) {
|
|
crc = (crc << ((uint64_t)8)) ^ vs_crc64_table[(crc >> ((uint64_t)56)) ^ *current++];
|
|
}
|
|
|
|
return ~crc;
|
|
}
|
|
|
|
/* BLAKE2s implementation */
|
|
|
|
#define VS_BLAKE2S_ROTR32(arg, rot) \
|
|
((((uint32_t)(arg)) >> ((uint32_t)(rot))) ^ \
|
|
(((uint32_t)(arg)) << (uint32_t)(((uint32_t)32) - ((uint32_t)(rot)))))
|
|
|
|
static const uint32_t vs_blake2s_iv[VS_BLAKE2S_STATE_SIZE] = { 0x6a09e667, 0xbb67ae85, 0x3c6ef372,
|
|
0xa54ff53a, 0x510e527f, 0x9b05688c,
|
|
0x1f83d9ab, 0x5be0cd19 };
|
|
|
|
static const uint8_t vs_blake2s_sigma[160] = {
|
|
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 14, 10, 4, 8, 9, 15, 13,
|
|
6, 1, 12, 0, 2, 11, 7, 5, 3, 11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1,
|
|
9, 4, 7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8, 9, 0, 5, 7, 2,
|
|
4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13, 2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5,
|
|
15, 14, 1, 9, 12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11, 13, 11, 7,
|
|
14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10, 6, 15, 14, 9, 11, 3, 0, 8, 12, 2,
|
|
13, 7, 1, 4, 10, 5, 10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0
|
|
};
|
|
|
|
static const uint8_t vs_blake2s_hex_digits[] = "0123456789abcdef";
|
|
|
|
static void vs_Blake2sCtx_mix(vs_Blake2sCtx *ctx,
|
|
uint8_t v_a,
|
|
uint8_t v_b,
|
|
uint8_t v_c,
|
|
uint8_t v_d,
|
|
uint8_t sigma_x,
|
|
uint8_t sigma_y) {
|
|
ctx->work[v_a] = ctx->work[v_a] + ctx->work[v_b] + ctx->message[vs_blake2s_sigma[sigma_x]];
|
|
ctx->work[v_d] = VS_BLAKE2S_ROTR32(ctx->work[v_d] ^ ctx->work[v_a], 16);
|
|
ctx->work[v_c] = ctx->work[v_c] + ctx->work[v_d];
|
|
ctx->work[v_b] = VS_BLAKE2S_ROTR32(ctx->work[v_b] ^ ctx->work[v_c], 12);
|
|
ctx->work[v_a] = ctx->work[v_a] + ctx->work[v_b] + ctx->message[vs_blake2s_sigma[sigma_y]];
|
|
ctx->work[v_d] = VS_BLAKE2S_ROTR32(ctx->work[v_d] ^ ctx->work[v_a], 8);
|
|
ctx->work[v_c] = ctx->work[v_c] + ctx->work[v_d];
|
|
ctx->work[v_b] = VS_BLAKE2S_ROTR32(ctx->work[v_b] ^ ctx->work[v_c], 7);
|
|
}
|
|
|
|
static void vs_Blake2sCtx_compress(vs_Blake2sCtx *ctx, bool is_last) {
|
|
uint8_t idx = 0;
|
|
|
|
for (idx = 0; idx < 8; ++idx) {
|
|
ctx->work[idx] = ctx->state[idx];
|
|
ctx->work[idx + 8] = vs_blake2s_iv[idx];
|
|
}
|
|
|
|
ctx->work[12] ^= (uint32_t)(ctx->inputs & (uint32_t)0xFFFFFFFF);
|
|
ctx->work[13] ^= (uint32_t)(ctx->inputs >> (uint32_t)32);
|
|
|
|
/* last block flag */
|
|
|
|
if (is_last) {
|
|
ctx->work[14] = ~ctx->work[14];
|
|
}
|
|
|
|
for (idx = 0; idx < 16; ++idx) {
|
|
const uint8_t pdx = idx * 4;
|
|
|
|
ctx->message[idx] = (uint32_t)ctx->input[pdx] ^
|
|
((uint32_t)ctx->input[pdx + 1] << (uint32_t)8) ^
|
|
((uint32_t)ctx->input[pdx + 2] << (uint32_t)16) ^
|
|
((uint32_t)ctx->input[pdx + 3] << (uint32_t)24);
|
|
}
|
|
|
|
/* 10 rounds of mixing */
|
|
|
|
for (idx = 0; idx < 10; ++idx) {
|
|
/* clang-format off */
|
|
vs_Blake2sCtx_mix(ctx, 0, 4, 8, 12, (uint8_t)((idx * 16) + 0), (uint8_t)((idx * 16) + 1));
|
|
vs_Blake2sCtx_mix(ctx, 1, 5, 9, 13, (uint8_t)((idx * 16) + 2), (uint8_t)((idx * 16) + 3));
|
|
vs_Blake2sCtx_mix(ctx, 2, 6, 10, 14, (uint8_t)((idx * 16) + 4), (uint8_t)((idx * 16) + 5));
|
|
vs_Blake2sCtx_mix(ctx, 3, 7, 11, 15, (uint8_t)((idx * 16) + 6), (uint8_t)((idx * 16) + 7));
|
|
vs_Blake2sCtx_mix(ctx, 0, 5, 10, 15, (uint8_t)((idx * 16) + 8), (uint8_t)((idx * 16) + 9));
|
|
vs_Blake2sCtx_mix(ctx, 1, 6, 11, 12, (uint8_t)((idx * 16) + 10), (uint8_t)((idx * 16) + 11));
|
|
vs_Blake2sCtx_mix(ctx, 2, 7, 8, 13, (uint8_t)((idx * 16) + 12), (uint8_t)((idx * 16) + 13));
|
|
vs_Blake2sCtx_mix(ctx, 3, 4, 9, 14, (uint8_t)((idx * 16) + 14), (uint8_t)((idx * 16) + 15));
|
|
/* clang-format on */
|
|
}
|
|
|
|
/* finalize the compression */
|
|
|
|
for (idx = 0; idx < 8; ++idx) {
|
|
ctx->state[idx] ^= ctx->work[idx] ^ ctx->work[idx + 8];
|
|
}
|
|
}
|
|
|
|
bool vs_Blake2sCtx_init(vs_Blake2sCtx *ctx, uint8_t outlen, const void *key, uint8_t keylen) {
|
|
uint8_t idx = 0;
|
|
|
|
if (!ctx || (key && (keylen < 1 || keylen > 32))) {
|
|
return false;
|
|
}
|
|
|
|
for (idx = 0; idx < VS_BLAKE2S_STATE_SIZE; ++idx) {
|
|
ctx->state[idx] = vs_blake2s_iv[idx];
|
|
}
|
|
|
|
for (idx = 0; idx < VS_BLAKE2S_INPUT_SIZE; ++idx) {
|
|
ctx->input[idx] = 0;
|
|
}
|
|
|
|
for (idx = 0; idx < 16; ++idx) {
|
|
ctx->work[idx] = ctx->message[idx] = 0;
|
|
}
|
|
|
|
ctx->idx = 0;
|
|
ctx->inputs = 0;
|
|
ctx->outlen = outlen;
|
|
|
|
ctx->state[0] ^= (uint32_t)0x01010000 ^ ((uint32_t)keylen << (uint32_t)8) ^ (uint32_t)outlen;
|
|
|
|
if (key && keylen != 0) {
|
|
vs_Blake2sCtx_update(ctx, key, keylen);
|
|
ctx->idx = VS_BLAKE2S_INPUT_SIZE;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool vs_Blake2sCtx_update(vs_Blake2sCtx *ctx, const void *data, size_t datalen) {
|
|
if (!ctx || !data || datalen < 1) {
|
|
return false;
|
|
}
|
|
|
|
for (size_t idx = 0; idx < datalen; ++idx) {
|
|
if (ctx->idx == VS_BLAKE2S_INPUT_SIZE) {
|
|
ctx->inputs += ctx->idx;
|
|
vs_Blake2sCtx_compress(ctx, false);
|
|
ctx->idx = 0;
|
|
}
|
|
|
|
ctx->input[ctx->idx++] = ((const uint8_t *)data)[idx];
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool vs_Blake2sCtx_final(vs_Blake2sCtx *ctx) {
|
|
if (!ctx) {
|
|
return false;
|
|
}
|
|
|
|
ctx->inputs += ctx->idx;
|
|
|
|
while (ctx->idx < 64) {
|
|
ctx->input[ctx->idx++] = 0;
|
|
}
|
|
|
|
vs_Blake2sCtx_compress(ctx, true);
|
|
|
|
for (uint8_t idx = 0; idx < ctx->outlen; ++idx) {
|
|
ctx->digest[idx] = (ctx->state[idx >> (uint8_t)2] >> ((uint32_t)(8 * (idx & (uint8_t)3))) &
|
|
(uint32_t)0xff);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool vs_Blake2sCtx_to_hex(vs_Blake2sCtx *ctx, void *out) {
|
|
if (!ctx || !out) {
|
|
return false;
|
|
}
|
|
|
|
size_t idx = 0;
|
|
uint8_t *data = (uint8_t *)out;
|
|
|
|
for (idx = 0; idx < ctx->outlen; ++idx) {
|
|
data[(idx * 2) + 0] = vs_blake2s_hex_digits[ctx->digest[idx] >> (uint8_t)0x4];
|
|
data[(idx * 2) + 1] = vs_blake2s_hex_digits[ctx->digest[idx] & (uint8_t)0xf];
|
|
}
|
|
|
|
data[idx * 2] = '\0';
|
|
|
|
return true;
|
|
}
|