static void
blake64_close(sph_blake_big_context *sc,
unsigned ub, unsigned n, void *dst, size_t out_size_w64)
{
union {
unsigned char buf[128];
sph_u64 dummy;
} u;
size_t ptr, k;
unsigned bit_len;
unsigned z;
sph_u64 th, tl;
unsigned char *out;
ptr = sc->ptr;
bit_len = ((unsigned)ptr << 3) + n;
z = 0x80 >> n;
u.buf[ptr] = ((ub & -z) | z) & 0xFF;
tl = sc->T0 + bit_len;
th = sc->T1;
if (ptr == 0 && n == 0) {
sc->T0 = SPH_C64(0xFFFFFFFFFFFFFC00);
sc->T1 = SPH_C64(0xFFFFFFFFFFFFFFFF);
} else if (sc->T0 == 0) {
sc->T0 = SPH_C64(0xFFFFFFFFFFFFFC00) + bit_len;
sc->T1 = SPH_T64(sc->T1 - 1);
} else {
sc->T0 -= 1024 - bit_len;
}
if (bit_len <= 894) {
memset(u.buf + ptr + 1, 0, 111 - ptr);
if (out_size_w64 == 8)
u.buf[111] |= 1;
sph_enc64be_aligned(u.buf + 112, th);
sph_enc64be_aligned(u.buf + 120, tl);
blake64(sc, u.buf + ptr, 128 - ptr);
} else {
memset(u.buf + ptr + 1, 0, 127 - ptr);
blake64(sc, u.buf + ptr, 128 - ptr);
sc->T0 = SPH_C64(0xFFFFFFFFFFFFFC00);
sc->T1 = SPH_C64(0xFFFFFFFFFFFFFFFF);
memset(u.buf, 0, 112);
if (out_size_w64 == 8)
u.buf[111] = 1;
sph_enc64be_aligned(u.buf + 112, th);
sph_enc64be_aligned(u.buf + 120, tl);
blake64(sc, u.buf, 128);
}
out = dst;
for (k = 0; k < out_size_w64; k ++)
sph_enc64be(out + (k << 3), sc->H[k]);
}
void CBLAKE512::Finalize(unsigned char hash[OUTPUT_SIZE])
{
union {
unsigned char buf[128];
sph_u64 dummy;
} u;
size_t ptr, k;
unsigned bit_len;
unsigned z;
sph_u64 th, tl;
ptr = s.ptr;
bit_len = ((unsigned)ptr << 3);
z = 0x80 >> 0;
u.buf[ptr] = ((0 & -z) | z) & 0xFF;
tl = s.T0 + bit_len;
th = s.T1;
if (ptr == 0) {
s.T0 = SPH_C64(0xFFFFFFFFFFFFFC00);
s.T1 = SPH_C64(0xFFFFFFFFFFFFFFFF);
} else if (s.T0 == 0) {
s.T0 = SPH_C64(0xFFFFFFFFFFFFFC00) + bit_len;
s.T1 = SPH_T64(s.T1 - 1);
} else {
s.T0 -= 1024 - bit_len;
}
if (bit_len <= 894) {
memset(u.buf + ptr + 1, 0, 111 - ptr);
u.buf[111] |= 1;
sph_enc64be_aligned(u.buf + 112, th);
sph_enc64be_aligned(u.buf + 120, tl);
Write(u.buf + ptr, 128 - ptr);
} else {
memset(u.buf + ptr + 1, 0, 127 - ptr);
Write(u.buf + ptr, 128 - ptr);
s.T0 = SPH_C64(0xFFFFFFFFFFFFFC00);
s.T1 = SPH_C64(0xFFFFFFFFFFFFFFFF);
memset(u.buf, 0, 112);
u.buf[111] = 1;
sph_enc64be_aligned(u.buf + 112, th);
sph_enc64be_aligned(u.buf + 120, tl);
Write(u.buf, 128);
}
for (k = 0; k < 8; k ++)
sph_enc64be(hash + (k << 3), s.H[k]);
Reset();
}
static void
test_types64(void)
{
unsigned i;
union {
unsigned char bytes[64];
sph_u64 v64;
} u;
#if SPH_LITTLE_ENDIAN || SPH_BIG_ENDIAN
ASSERT(sizeof(sph_u64) == 8);
#else
ASSERT(sizeof(sph_u64) >= 8);
#endif
for (i = 0; i < sizeof u.bytes; i ++)
u.bytes[i] = i;
for (i = 0; (i + 7) < sizeof u.bytes; i ++) {
sph_u64 v, w;
v = ((sph_u64)i << 56)
| ((sph_u64)(i + 1) << 48)
| ((sph_u64)(i + 2) << 40)
| ((sph_u64)(i + 3) << 32)
| ((sph_u64)(i + 4) << 24)
| ((sph_u64)(i + 5) << 16)
| ((sph_u64)(i + 6) << 8)
| (sph_u64)(i + 7);
w = ((sph_u64)(i + 7) << 56)
| ((sph_u64)(i + 6) << 48)
| ((sph_u64)(i + 5) << 40)
| ((sph_u64)(i + 4) << 32)
| ((sph_u64)(i + 3) << 24)
| ((sph_u64)(i + 2) << 16)
| ((sph_u64)(i + 1) << 8)
| (sph_u64)i;
ASSERT(sph_dec64be(u.bytes + i) == v);
ASSERT(sph_dec64le(u.bytes + i) == w);
if (i % 8 == 0) {
ASSERT(sph_dec64be_aligned(u.bytes + i) == v);
ASSERT(sph_dec64le_aligned(u.bytes + i) == w);
}
}
memset(u.bytes, 0, sizeof u.bytes);
for (i = 0; (i + 7) < sizeof u.bytes; i ++) {
sph_u64 v, w;
v = ((sph_u64)i << 56)
| ((sph_u64)(i + 1) << 48)
| ((sph_u64)(i + 2) << 40)
| ((sph_u64)(i + 3) << 32)
| ((sph_u64)(i + 4) << 24)
| ((sph_u64)(i + 5) << 16)
| ((sph_u64)(i + 6) << 8)
| (sph_u64)(i + 7);
w = ((sph_u64)(i + 7) << 56)
| ((sph_u64)(i + 6) << 48)
| ((sph_u64)(i + 5) << 40)
| ((sph_u64)(i + 4) << 32)
| ((sph_u64)(i + 3) << 24)
| ((sph_u64)(i + 2) << 16)
| ((sph_u64)(i + 1) << 8)
| (sph_u64)i;
if (i % 8 == 0) {
sph_enc64be_aligned(u.bytes + i, v);
} else {
sph_enc64be(u.bytes + i, v);
}
ASSERT(u.bytes[i + 0] == i + 0);
ASSERT(u.bytes[i + 1] == i + 1);
ASSERT(u.bytes[i + 2] == i + 2);
ASSERT(u.bytes[i + 3] == i + 3);
ASSERT(u.bytes[i + 4] == i + 4);
ASSERT(u.bytes[i + 5] == i + 5);
ASSERT(u.bytes[i + 6] == i + 6);
ASSERT(u.bytes[i + 7] == i + 7);
memset(u.bytes, 0, sizeof u.bytes);
if (i % 8 == 0) {
sph_enc64le_aligned(u.bytes + i, w);
} else {
sph_enc64le(u.bytes + i, w);
}
ASSERT(u.bytes[i + 0] == i + 0);
ASSERT(u.bytes[i + 1] == i + 1);
ASSERT(u.bytes[i + 2] == i + 2);
ASSERT(u.bytes[i + 3] == i + 3);
ASSERT(u.bytes[i + 4] == i + 4);
ASSERT(u.bytes[i + 5] == i + 5);
ASSERT(u.bytes[i + 6] == i + 6);
ASSERT(u.bytes[i + 7] == i + 7);
}
}
