/* inlen, at least, should be uint64_t. Others can be size_t. */
int blake2b( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen )
{
blake2b_state S[1];
/* Verify parameters */
if ( NULL == in && inlen > 0 ) return -1;
if ( NULL == out ) return -1;
if( NULL == key && keylen > 0 ) return -1;
if( !outlen || outlen > BLAKE2B_OUTBYTES ) return -1;
if( keylen > BLAKE2B_KEYBYTES ) return -1;
if( keylen > 0 )
{
if( blake2b_init_key( S, outlen, key, keylen ) < 0 ) return -1;
}
else
{
if( blake2b_init( S, outlen ) < 0 ) return -1;
}
blake2b_update( S, ( const uint8_t * )in, inlen );
blake2b_final( S, out, outlen );
return 0;
}
/* inlen, at least, should be word64. Others can be size_t. */
int blake2b( byte *out, const void *in, const void *key, const byte outlen,
const word64 inlen, byte keylen )
{
blake2b_state S[1];
/* Verify parameters */
if ( NULL == in ) return -1;
if ( NULL == out ) return -1;
if( NULL == key ) keylen = 0;
if( keylen > 0 )
{
if( blake2b_init_key( S, outlen, key, keylen ) < 0 ) return -1;
}
else
{
if( blake2b_init( S, outlen ) < 0 ) return -1;
}
if ( blake2b_update( S, ( byte * )in, inlen ) < 0) return -1;
return blake2b_final( S, out, outlen );
}
int svi_encfile(const char* outfn,
const char* tagfn,
const char* headerfn,
const char* infn,
const uint8_t* gkn) {
int err = 0;
mmfile inmf;
err = mmfile_open(&inmf, infn, O_RDONLY);
if (err != 0) { E(done, "mmfile_open %s", infn); }
uint64_t outlen = svi_buflen(inmf.length);
uint64_t numblocks = outlen / 65536;
uint64_t taglen = numblocks * 64;
mmfile outmf;
err = mmfile_create(&outmf, outfn, outlen);
if (err != 0) { E(cleanup_inmf, "mmfile_create %s", infn); }
mmfile tagsmf;
err = mmfile_create(&tagsmf, tagfn, taglen);
if (err != 0) { E(cleanup_outmf, "mmfile_create %s", tagfn); }
mmfile headermf;
err = mmfile_create(&headermf, headerfn, 4096);
if (err != 0) { E(cleanup_tagsmf, "mmfile_create %s", headerfn); }
memset_s(headermf.mem, headermf.length, 0, headermf.length);
err = svi_encrypt(outmf.mem, tagsmf.mem, headermf.mem, inmf.mem);
if (err != 0) {
// Something really bad happened. We can't assess what went
// wrong, so we sanitize all of the output files.
memset_s(outmf.mem, outmf.length, 0, outmf.length);
memset_s(tagsmf.mem, tagsmf.length, 0, tagsmf.length);
memset_s(headermf.mem, headermf.length, 0, headermf.length);
E(cleanup_headermf, "svi_inplace %u", err);
}
uint8_t headertag[64] = {0};
blake2b_state s;
blake2b_init_key(&s, 64, gkn, 64);
blake2b_update(&s, header, HEADERLEN);
blake2b_final(&s, headertag, 64);
// Clean up the blake2b state.
memset_s(&s, sizeof(blake2b_state), 0, sizeof(blake2b_state));
cleanup_headermf: mmfile_close(&headermf);
cleanup_tagsmf: mmfile_close(&tagsmf);
cleanup_outmf: mmfile_close(&outmf);
cleanup_inmf: mmfile_close(&inmf);
done: return err;
}
MUtils::Hash::Blake2::Blake2(const char *const key)
:
m_context(new Blake2_Context()),
m_finalized(false)
{
if(key && key[0])
{
blake2b_init_key(m_context->state, HASH_SIZE, key, (uint8_t)strlen(key));
}
else
{
blake2b_init(m_context->state, HASH_SIZE);
}
}
int
crypto_generichash_blake2b_init(crypto_generichash_blake2b_state *state,
const unsigned char *key, const size_t keylen,
const size_t outlen)
{
if (outlen <= 0U || outlen > BLAKE2B_OUTBYTES ||
keylen > BLAKE2B_KEYBYTES) {
return -1;
}
assert(outlen <= UINT8_MAX);
assert(keylen <= UINT8_MAX);
COMPILER_ASSERT(sizeof(blake2b_state) <= sizeof *state);
if (key == NULL || keylen <= 0U) {
if (blake2b_init((blake2b_state *) (void *) state, (uint8_t) outlen) != 0) {
return -1; /* LCOV_EXCL_LINE */
}
} else if (blake2b_init_key((blake2b_state *) (void *) state, (uint8_t) outlen, key,
(uint8_t) keylen) != 0) {
return -1; /* LCOV_EXCL_LINE */
}
return 0;
}
int blake2b( uint8_t *out, const void *in, const void *key, size_t outlen, size_t inlen, size_t keylen )
{
blake2b_state S[1];
/* Verify parameters */
if ( NULL == in ) return -1;
if ( NULL == out ) return -1;
if( NULL == key && key > 0 ) return -1;
if( keylen > 0 )
{
if( blake2b_init_key( S, outlen, key, keylen ) < 0 ) return -1;
}
else
{
if( blake2b_init( S, outlen ) < 0 ) return -1;
}
if( blake2b_update( S, ( uint8_t * )in, inlen ) < 0 ) return -1;
return blake2b_final( S, out, outlen );
}
int blake2b(void *out, size_t outlen, const void *in, size_t inlen,
const void *key, size_t keylen) {
blake2b_state S;
int ret = -1;
/* Verify parameters */
if (NULL == in && inlen > 0) {
goto fail;
}
if (NULL == out || outlen == 0 || outlen > BLAKE2B_OUTBYTES) {
goto fail;
}
if ((NULL == key && keylen > 0) || keylen > BLAKE2B_KEYBYTES) {
goto fail;
}
if (keylen > 0) {
if (blake2b_init_key(&S, outlen, key, keylen) < 0) {
goto fail;
}
} else {
if (blake2b_init(&S, outlen) < 0) {
goto fail;
}
}
if (blake2b_update(&S, in, inlen) < 0) {
goto fail;
}
ret = blake2b_final(&S, out, outlen);
fail:
burn(&S, sizeof(S));
return ret;
}
int blake2b( uint8_t *out, const void *in, const void *key, const uint8_t outlen, const uint64_t inlen, uint8_t keylen )
{
blake2b_state S[1];
/* Verify parameters */
if ( NULL == in ) return -1;
if ( NULL == out ) return -1;
if( NULL == key ) keylen = 0;
if( keylen )
{
if( blake2b_init_key( S, outlen, key, keylen ) < 0 ) return -1;
}
else
{
if( blake2b_init( S, outlen ) < 0 ) return -1;
}
blake2b_update( S, ( const uint8_t * )in, inlen );
blake2b_final( S, out, outlen );
return 0;
}
static
NAN_METHOD(New) {
if(!info.IsConstructCall()) {
return Nan::ThrowError("Constructor must be called with new");
}
Hash *obj = new Hash();
obj->Wrap(info.This());
if(info.Length() < 1 || !info[0]->IsString()) {
return Nan::ThrowError(v8::Exception::TypeError(Nan::New<v8::String>("First argument must be a string with algorithm name").ToLocalChecked()));
}
std::string algo = std::string(*v8::String::Utf8Value(info[0]->ToString()));
const char *key_data = nullptr;
size_t key_length;
if(algo != "bypass" && info.Length() >= 2) {
if(!node::Buffer::HasInstance(info[1])) {
return Nan::ThrowError(v8::Exception::TypeError(Nan::New<v8::String>("If key argument is given, it must be a Buffer").ToLocalChecked()));
}
key_data = node::Buffer::Data(info[1]);
key_length = node::Buffer::Length(info[1]);
}
if(algo == "bypass") {
// Initialize nothing - .copy() will set up all the state
} else if(algo == "blake2b") {
if(!key_data) {
if(blake2b_init(reinterpret_cast<blake2b_state*>(&obj->state), BLAKE2B_OUTBYTES) != 0) {
return Nan::ThrowError("blake2b_init failure");
}
} else {
if(key_length > BLAKE2B_KEYBYTES) {
return Nan::ThrowError("Key must be 64 bytes or smaller");
}
if(blake2b_init_key(reinterpret_cast<blake2b_state*>(&obj->state), BLAKE2B_OUTBYTES, key_data, key_length) != 0) {
return Nan::ThrowError("blake2b_init_key failure");
}
}
obj->outbytes = 512 / 8;
obj->any_blake2_update = BLAKE_FN_CAST(blake2b_update);
obj->any_blake2_final = BLAKE_FN_CAST(blake2b_final);
obj->initialized_ = true;
} else if(algo == "blake2bp") {
if(!key_data) {
if(blake2bp_init(reinterpret_cast<blake2bp_state*>(&obj->state), BLAKE2B_OUTBYTES) != 0) {
return Nan::ThrowError("blake2bp_init failure");
}
} else {
if(key_length > BLAKE2B_KEYBYTES) {
return Nan::ThrowError("Key must be 64 bytes or smaller");
}
if(blake2bp_init_key(reinterpret_cast<blake2bp_state*>(&obj->state), BLAKE2B_OUTBYTES, key_data, key_length) != 0) {
return Nan::ThrowError("blake2bp_init_key failure");
}
}
obj->outbytes = 512 / 8;
obj->any_blake2_update = BLAKE_FN_CAST(blake2bp_update);
obj->any_blake2_final = BLAKE_FN_CAST(blake2bp_final);
obj->initialized_ = true;
} else if(algo == "blake2s") {
if(!key_data) {
if(blake2s_init(reinterpret_cast<blake2s_state*>(&obj->state), BLAKE2S_OUTBYTES) != 0) {
return Nan::ThrowError("blake2bs_init failure");
}
} else {
if(key_length > BLAKE2S_KEYBYTES) {
return Nan::ThrowError("Key must be 32 bytes or smaller");
}
if(blake2s_init_key(reinterpret_cast<blake2s_state*>(&obj->state), BLAKE2S_OUTBYTES, key_data, key_length) != 0) {
return Nan::ThrowError("blake2s_init_key failure");
}
}
obj->outbytes = 256 / 8;
obj->any_blake2_update = BLAKE_FN_CAST(blake2s_update);
obj->any_blake2_final = BLAKE_FN_CAST(blake2s_final);
obj->initialized_ = true;
} else if(algo == "blake2sp") {
if(!key_data) {
if(blake2sp_init(reinterpret_cast<blake2sp_state*>(&obj->state), BLAKE2S_OUTBYTES) != 0) {
return Nan::ThrowError("blake2sp_init failure");
}
} else {
if(key_length > BLAKE2S_KEYBYTES) {
return Nan::ThrowError("Key must be 32 bytes or smaller");
}
if(blake2sp_init_key(reinterpret_cast<blake2sp_state*>(&obj->state), BLAKE2S_OUTBYTES, key_data, key_length) != 0) {
return Nan::ThrowError("blake2sp_init_key failure");
}
}
obj->outbytes = 256 / 8;
obj->any_blake2_update = BLAKE_FN_CAST(blake2sp_update);
obj->any_blake2_final = BLAKE_FN_CAST(blake2sp_final);
obj->initialized_ = true;
} else {
return Nan::ThrowError("Algorithm must be blake2b, blake2s, blake2bp, or blake2sp");
}
info.GetReturnValue().Set(info.This());
}
int blake2b_low_init_key(blake2b_state *context, const unsigned char *key, size_t key_len) {
return blake2b_init_key(context, BLAKE2B_OUTBYTES, key, key_len);
}
int main( void )
{
uint8_t key[BLAKE2B_KEYBYTES];
uint8_t buf[BLAKE2_KAT_LENGTH];
size_t i, step;
for( i = 0; i < BLAKE2B_KEYBYTES; ++i )
key[i] = ( uint8_t )i;
for( i = 0; i < BLAKE2_KAT_LENGTH; ++i )
buf[i] = ( uint8_t )i;
/* Test simple API */
for( i = 0; i < BLAKE2_KAT_LENGTH; ++i )
{
uint8_t hash[BLAKE2B_OUTBYTES];
blake2b( hash, BLAKE2B_OUTBYTES, buf, i, key, BLAKE2B_KEYBYTES );
if( 0 != memcmp( hash, blake2b_keyed_kat[i], BLAKE2B_OUTBYTES ) )
{
goto fail;
}
}
/* Test streaming API */
for(step = 1; step < BLAKE2B_BLOCKBYTES; ++step) {
for (i = 0; i < BLAKE2_KAT_LENGTH; ++i) {
uint8_t hash[BLAKE2B_OUTBYTES];
blake2b_state S;
uint8_t * p = buf;
size_t mlen = i;
int err = 0;
if( (err = blake2b_init_key(&S, BLAKE2B_OUTBYTES, key, BLAKE2B_KEYBYTES)) < 0 ) {
goto fail;
}
while (mlen >= step) {
if ( (err = blake2b_update(&S, p, step)) < 0 ) {
goto fail;
}
mlen -= step;
p += step;
}
if ( (err = blake2b_update(&S, p, mlen)) < 0) {
goto fail;
}
if ( (err = blake2b_final(&S, hash, BLAKE2B_OUTBYTES)) < 0) {
goto fail;
}
if (0 != memcmp(hash, blake2b_keyed_kat[i], BLAKE2B_OUTBYTES)) {
goto fail;
}
}
}
puts( "ok" );
return 0;
fail:
puts("error");
return -1;
}
