/*
* Convert a uuid to a "double" value for estimating sizes of ranges.
*/
static double
uuid_2_double(const pg_uuid_t *u)
{
uint64 uu[2];
const double two64 = 18446744073709551616.0; /* 2^64 */
/* Source data may not be suitably aligned, so copy */
memcpy(uu, u->data, UUID_LEN);
/*
* uuid values should be considered as big-endian numbers, since that
* corresponds to how memcmp will compare them. On a little-endian
* machine, byte-swap each half so we can use native uint64 arithmetic.
*/
#ifndef WORDS_BIGENDIAN
uu[0] = BSWAP64(uu[0]);
uu[1] = BSWAP64(uu[1]);
#endif
/*
* 2^128 is about 3.4e38, which in theory could exceed the range of
* "double" (POSIX only requires 1e37). To avoid any risk of overflow,
* put the decimal point between the two halves rather than treating the
* uuid value as a 128-bit integer.
*/
return (double) uu[0] + (double) uu[1] / two64;
}
static void check_dtls_window_epoch_higher(void **glob_state)
{
struct record_parameters_st state;
uint64 t;
RESET_WINDOW;
SET_WINDOW_NEXT(LARGE_INT-1);
SET_WINDOW_LAST_RECV(LARGE_INT);
uint64_set(&t, BSWAP64(LARGE_INT));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64((LARGE_INT+8)|0x1000000000000LL));
assert_int_equal(_dtls_record_check(&state, &t), -1);
}
void StreamPeer::put_64(int64_t p_val) {
if (big_endian) {
p_val = BSWAP64(p_val);
}
uint8_t buf[8];
encode_uint64(p_val, buf);
put_data(buf, 8);
}
void StreamPeer::put_double(double p_val) {
uint8_t buf[8];
encode_double(p_val, buf);
if (big_endian) {
uint64_t *p64 = (uint64_t *)buf;
*p64 = BSWAP64(*p64);
}
put_data(buf, 8);
}
int64_t StreamPeer::get_64() {
uint8_t buf[8];
get_data(buf, 8);
uint64_t r = decode_uint64(buf);
if (big_endian) {
r = BSWAP64(r);
}
return r;
}
static void check_dtls_window_uninit_large(void **glob_state)
{
struct record_parameters_st state;
uint64 t;
RESET_WINDOW;
uint64_set(&t, BSWAP64(LARGE_INT+1+64));
assert_int_equal(_dtls_record_check(&state, &t), 0);
}
static void check_dtls_window_uninit_very_large(void **glob_state)
{
struct record_parameters_st state;
uint64 t;
RESET_WINDOW;
uint64_set(&t, BSWAP64(INT_OVER_32_BITS));
assert_int_equal(_dtls_record_check(&state, &t), 0);
}
float StreamPeer::get_double() {
uint8_t buf[8];
get_data(buf, 8);
if (big_endian) {
uint64_t *p64 = (uint64_t *)buf;
*p64 = BSWAP64(*p64);
}
return decode_double(buf);
}
static void check_dtls_window_epoch_lower(void **glob_state)
{
struct record_parameters_st state;
uint64 t;
RESET_WINDOW;
uint64_set(&t, BSWAP64(0x1000000000000LL));
state.epoch = 1;
SET_WINDOW_NEXT(0x1000000000000LL);
SET_WINDOW_LAST_RECV((0x1000000000000LL) + 1);
uint64_set(&t, BSWAP64(2 | 0x1000000000000LL));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(3 | 0x1000000000000LL));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(5));
assert_int_equal(_dtls_record_check(&state, &t), -1);
}
static void check_dtls_window_dup3(void **glob_state)
{
struct record_parameters_st state;
uint64 t;
RESET_WINDOW;
SET_WINDOW_NEXT(LARGE_INT-1);
SET_WINDOW_LAST_RECV(LARGE_INT);
uint64_set(&t, BSWAP64(LARGE_INT));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(LARGE_INT+16));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(LARGE_INT+15));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(LARGE_INT+14));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(LARGE_INT+5));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(LARGE_INT+5));
assert_int_equal(_dtls_record_check(&state, &t), -3);
}
static void check_dtls_window_91(void **glob_state)
{
struct record_parameters_st state;
uint64 t;
RESET_WINDOW;
SET_WINDOW_NEXT(0);
SET_WINDOW_LAST_RECV(9);
uint64_set(&t, BSWAP64(1));
assert_int_equal(_dtls_record_check(&state, &t), 0);
}
static void check_dtls_window_very_large_outside(void **glob_state)
{
struct record_parameters_st state;
uint64 t;
RESET_WINDOW;
SET_WINDOW_NEXT(INT_OVER_32_BITS);
SET_WINDOW_LAST_RECV(INT_OVER_32_BITS+1);
uint64_set(&t, BSWAP64(INT_OVER_32_BITS+1+64));
assert_int_equal(_dtls_record_check(&state, &t), 0);
}
static void check_dtls_window_out_of_order(void **glob_state)
{
struct record_parameters_st state;
uint64 t;
RESET_WINDOW;
SET_WINDOW_NEXT(LARGE_INT-1);
SET_WINDOW_LAST_RECV(LARGE_INT);
uint64_set(&t, BSWAP64(LARGE_INT));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(LARGE_INT+8));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(LARGE_INT+7));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(LARGE_INT+6));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(LARGE_INT+5));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(LARGE_INT+4));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(LARGE_INT+3));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(LARGE_INT+2));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(LARGE_INT+1));
assert_int_equal(_dtls_record_check(&state, &t), 0);
uint64_set(&t, BSWAP64(LARGE_INT+9));
assert_int_equal(_dtls_record_check(&state, &t), 0);
}
static void check_dtls_window_skip3(void **glob_state)
{
struct record_parameters_st state;
uint64 t;
unsigned i;
RESET_WINDOW;
SET_WINDOW_NEXT(0);
SET_WINDOW_LAST_RECV(1);
for (i=5;i<256;i+=2) {
uint64_set(&t, BSWAP64(i));
assert_int_equal(_dtls_record_check(&state, &t), 0);
}
}
static inline int blake512_compress( state * state, const u8 * datablock )
{
__m128i row1l;
__m128i row2l;
__m128i row3l;
__m128i row4l;
u64 row1hl, row1hh;
u64 row2hl, row2hh;
u64 row3hl, row3hh;
u64 row4hl, row4hh;
const __m128i r16 = _mm_setr_epi8(2,3,4,5,6,7,0,1,10,11,12,13,14,15,8,9);
const __m128i u8to64 = _mm_set_epi8(8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7);
union
{
__m128i u128[8];
u64 u64[16];
} m;
__m128i t0, t1, t2, t3, t4, t5, t6, t7;
u64 u0, u1, u2, u3;
__m128i b0;
u64 b1l, b1h;
m.u128[0] = _mm_loadu_si128((__m128i*)(datablock + 0));
m.u128[1] = _mm_loadu_si128((__m128i*)(datablock + 16));
m.u128[2] = _mm_loadu_si128((__m128i*)(datablock + 32));
m.u128[3] = _mm_loadu_si128((__m128i*)(datablock + 48));
m.u128[4] = _mm_loadu_si128((__m128i*)(datablock + 64));
m.u128[5] = _mm_loadu_si128((__m128i*)(datablock + 80));
m.u128[6] = _mm_loadu_si128((__m128i*)(datablock + 96));
m.u128[7] = _mm_loadu_si128((__m128i*)(datablock + 112));
m.u128[0] = BSWAP64(m.u128[0]);
m.u128[1] = BSWAP64(m.u128[1]);
m.u128[2] = BSWAP64(m.u128[2]);
m.u128[3] = BSWAP64(m.u128[3]);
m.u128[4] = BSWAP64(m.u128[4]);
m.u128[5] = BSWAP64(m.u128[5]);
m.u128[6] = BSWAP64(m.u128[6]);
m.u128[7] = BSWAP64(m.u128[7]);
row1l = _mm_load_si128((__m128i*)&state->h[0]);
row1hl = state->h[2];
row1hh = state->h[3];
row2l = _mm_load_si128((__m128i*)&state->h[4]);
row2hl = state->h[6];
row2hh = state->h[7];
row3l = _mm_set_epi64x(0x13198A2E03707344ULL, 0x243F6A8885A308D3ULL);
row3hl = 0xA4093822299F31D0ULL;
row3hh = 0x082EFA98EC4E6C89ULL;
row4l = _mm_set_epi64x(0xBE5466CF34E90C6CULL, 0x452821E638D01377ULL);
row4hl = 0xC0AC29B7C97C50DDULL;
row4hh = 0x3F84D5B5B5470917ULL;
if(!state->nullt)
{
row4l = _mm_xor_si128(row4l, _mm_set1_epi64x(state->t[0]));
row4hl ^= state->t[1];
row4hh ^= state->t[1];
}
ROUND( 0);
ROUND( 1);
ROUND( 2);
ROUND( 3);
ROUND( 4);
ROUND( 5);
ROUND( 6);
ROUND( 7);
ROUND( 8);
ROUND( 9);
ROUND(10);
ROUND(11);
ROUND(12);
ROUND(13);
ROUND(14);
ROUND(15);
row1l = _mm_xor_si128(row3l,row1l);
row1hl ^= row3hl;
row1hh ^= row3hh;
_mm_store_si128((__m128i*)&state->h[0], _mm_xor_si128(row1l, _mm_load_si128((__m128i*)&state->h[0])));
state->h[2] ^= row1hl;
state->h[3] ^= row1hh;
row2l = _mm_xor_si128(row4l,row2l);
row2hl ^= row4hl;
row2hh ^= row4hh;
_mm_store_si128((__m128i*)&state->h[4], _mm_xor_si128(row2l, _mm_load_si128((__m128i*)&state->h[4])));
state->h[6] ^= row2hl;
state->h[7] ^= row2hh;
return 0;
}
void PRESENT128table_core(const u8* plaintext, const u8* roundKeys128, u8* ciphertext)
{
u64 * state, * roundKeys;
/* cast variables */
*((u64*)ciphertext) = BSWAP64(*((u64*)plaintext));
state = (u64 *)ciphertext;
roundKeys = (u64 *)roundKeys128;
/* round 1 */
state[0] ^= roundKeys[0];
PRESENTROUND(state[0]);
/* round 2 */
state[0] ^= roundKeys[1];
PRESENTROUND(state[0]);
/* round 3 */
state[0] ^= roundKeys[2];
PRESENTROUND(state[0]);
/* round 4 */
state[0] ^= roundKeys[3];
PRESENTROUND(state[0]);
/* round 5 */
state[0] ^= roundKeys[4];
PRESENTROUND(state[0]);
/* round 6 */
state[0] ^= roundKeys[5];
PRESENTROUND(state[0]);
/* round 7 */
state[0] ^= roundKeys[6];
PRESENTROUND(state[0]);
/* round 8 */
state[0] ^= roundKeys[7];
PRESENTROUND(state[0]);
/* round 9 */
state[0] ^= roundKeys[8];
PRESENTROUND(state[0]);
/* round 10 */
state[0] ^= roundKeys[9];
PRESENTROUND(state[0]);
/* round 11 */
state[0] ^= roundKeys[10];
PRESENTROUND(state[0]);
/* round 12 */
state[0] ^= roundKeys[11];
PRESENTROUND(state[0]);
/* round 13 */
state[0] ^= roundKeys[12];
PRESENTROUND(state[0]);
/* round 14 */
state[0] ^= roundKeys[13];
PRESENTROUND(state[0]);
/* round 15 */
state[0] ^= roundKeys[14];
PRESENTROUND(state[0]);
/* round 16 */
state[0] ^= roundKeys[15];
PRESENTROUND(state[0]);
/* round 17 */
state[0] ^= roundKeys[16];
PRESENTROUND(state[0]);
/* round 18 */
state[0] ^= roundKeys[17];
PRESENTROUND(state[0]);
/* round 19 */
state[0] ^= roundKeys[18];
PRESENTROUND(state[0]);
/* round 20 */
state[0] ^= roundKeys[19];
PRESENTROUND(state[0]);
/* round 21 */
state[0] ^= roundKeys[20];
PRESENTROUND(state[0]);
/* round 22 */
state[0] ^= roundKeys[21];
PRESENTROUND(state[0]);
/* round 23 */
state[0] ^= roundKeys[22];
PRESENTROUND(state[0]);
/* round 24 */
state[0] ^= roundKeys[23];
PRESENTROUND(state[0]);
/* round 25 */
state[0] ^= roundKeys[24];
PRESENTROUND(state[0]);
/* round 26 */
state[0] ^= roundKeys[25];
PRESENTROUND(state[0]);
/* round 27 */
state[0] ^= roundKeys[26];
PRESENTROUND(state[0]);
/* round 28 */
state[0] ^= roundKeys[27];
PRESENTROUND(state[0]);
/* round 29 */
state[0] ^= roundKeys[28];
PRESENTROUND(state[0]);
/* round 30 */
state[0] ^= roundKeys[29];
PRESENTROUND(state[0]);
/* round 31 */
state[0] ^= roundKeys[30];
PRESENTROUND(state[0]);
/* last addRoundKey */
state[0] ^= roundKeys[31];
/* endianness handling */
state[0] = BSWAP64(state[0]);
return;
}
void PRESENT128table_key_schedule(const u8* masterKey128, u8* roundKeys128)
{
u64 currentKeyLow, currentKeyHigh;
/* get low and high parts of master key */
currentKeyHigh = BSWAP64(((u64 *)masterKey128)[0]);
currentKeyLow = BSWAP64(((u64 *)masterKey128)[1]);
/* get round key 0 and compute round key 1 */
((u64 *)roundKeys128)[0] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 0);
/* get round key 1 and compute round key 2 */
((u64 *)roundKeys128)[1] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 1);
/* get round key 2 and compute round key 3 */
((u64 *)roundKeys128)[2] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 2);
/* get round key 3 and compute round key 4 */
((u64 *)roundKeys128)[3] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 3);
/* get round key 4 and compute round key 5 */
((u64 *)roundKeys128)[4] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 4);
/* get round key 5 and compute round key 6 */
((u64 *)roundKeys128)[5] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 5);
/* get round key 6 and compute round key 7 */
((u64 *)roundKeys128)[6] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 6);
/* get round key 7 and compute round key 8 */
((u64 *)roundKeys128)[7] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 7);
/* get round key 8 and compute round key 9 */
((u64 *)roundKeys128)[8] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 8);
/* get round key 9 and compute round key 10 */
((u64 *)roundKeys128)[9] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 9);
/* get round key 10 and compute round key 11 */
((u64 *)roundKeys128)[10] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 10);
/* get round key 11 and compute round key 12 */
((u64 *)roundKeys128)[11] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 11);
/* get round key 12 and compute round key 13 */
((u64 *)roundKeys128)[12] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 12);
/* get round key 13 and compute round key 14 */
((u64 *)roundKeys128)[13] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 13);
/* get round key 14 and compute round key 15 */
((u64 *)roundKeys128)[14] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 14);
/* get round key 15 and compute round key 16 */
((u64 *)roundKeys128)[15] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 15);
/* get round key 16 and compute round key 17 */
((u64 *)roundKeys128)[16] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 16);
/* get round key 17 and compute round key 18 */
((u64 *)roundKeys128)[17] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 17);
/* get round key 18 and compute round key 19 */
((u64 *)roundKeys128)[18] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 18);
/* get round key 19 and compute round key 20 */
((u64 *)roundKeys128)[19] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 19);
/* get round key 20 and compute round key 21 */
((u64 *)roundKeys128)[20] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 20);
/* get round key 21 and compute round key 22 */
((u64 *)roundKeys128)[21] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 21);
/* get round key 22 and compute round key 23 */
((u64 *)roundKeys128)[22] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 22);
/* get round key 23 and compute round key 24 */
((u64 *)roundKeys128)[23] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 23);
/* get round key 24 and compute round key 25 */
((u64 *)roundKeys128)[24] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 24);
/* get round key 25 and compute round key 26 */
((u64 *)roundKeys128)[25] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 25);
/* get round key 26 and compute round key 27 */
((u64 *)roundKeys128)[26] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 26);
/* get round key 27 and compute round key 28 */
((u64 *)roundKeys128)[27] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 27);
/* get round key 28 and compute round key 29 */
((u64 *)roundKeys128)[28] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 28);
/* get round key 29 and compute round key 30 */
((u64 *)roundKeys128)[29] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 29);
/* get round key 30 and compute round key 31 */
((u64 *)roundKeys128)[30] = currentKeyHigh;
PRESENTKS128(currentKeyLow, currentKeyHigh, 30);
/* get round key 31 */
((u64 *)roundKeys128)[31] = currentKeyHigh;
return;
}
