int main(void)
{
size_t clen;
for (clen = 0; clen < sizeof c; ++clen) {
randombytes_buf(key, sizeof key);
randombytes_buf(c, clen);
crypto_auth_hmacsha512(a, c, clen, key);
if (crypto_auth_hmacsha512_verify(a, c, clen, key) != 0) {
printf("fail %u\n", (unsigned int) clen);
return 100;
}
if (clen > 0) {
c[(size_t) rand() % clen] += 1 + (rand() % 255);
if (crypto_auth_hmacsha512_verify(a, c, clen, key) == 0) {
printf("forgery %u\n", (unsigned int) clen);
return 100;
}
a[rand() % sizeof a] += 1 + (rand() % 255);
if (crypto_auth_hmacsha512_verify(a, c, clen, key) == 0) {
printf("forgery %u\n", (unsigned int) clen);
return 100;
}
}
}
return 0;
}
int crypto_auth_hmacsha512_verify(const unsigned char *h, const unsigned char *in,
unsigned long long inlen, const unsigned char *k)
{
unsigned char correct[64];
crypto_auth_hmacsha512(correct,in,inlen,k);
return crypto_verify_64(h,correct) | (-(h == correct)) |
sodium_memcmp(correct,h,64);
}
int
main(void)
{
int i;
crypto_auth_hmacsha512(a, c, sizeof c - 1U, key);
for (i = 0; i < 64; ++i) {
printf(",0x%02x", (unsigned int) a[i]);
if (i % 8 == 7)
printf("\n");
}
return 0;
}
void c_rpc_server::c_session::execute_rpc_command(const std::string &input_message) {
try {
nlohmann::json j = nlohmann::json::parse(input_message);
const std::string cmd_name = j.begin().value();
_dbg("cmd name " << cmd_name);
// calling rpc function
const std::string response = m_rpc_server_ptr->m_rpc_functions_map.at(cmd_name)(input_message);
// serialize response
assert(response.size() <= std::numeric_limits<uint16_t>::max());
uint16_t size = static_cast<uint16_t>(response.size());
m_write_data.resize(size + 2); ///< 2 first bytes for size
m_write_data.at(0) = static_cast<char>(size >> 8);
m_write_data.at(1) = static_cast<char>(size & 0xFF);
for (size_t i = 0; i < response.size(); ++i)
m_write_data.at(i + 2) = response.at(i);
// send response
_dbg("send packet");
_dbg(m_write_data);
std::array<unsigned char, crypto_auth_hmacsha512_BYTES> hash;
int ret = crypto_auth_hmacsha512(hash.data(), reinterpret_cast<unsigned char *>(&m_write_data.at(2)), size, m_rpc_server_ptr->m_hmac_key.data());
if (ret != 0) _throw_error(std::runtime_error("crypto_auth_hmacsha512 error"));
_dbg("hmac");
//for (const auto & byte : hash) std::cout << std::hex << "0x" << static_cast<int>(byte) << " ";
//std::cout << std::dec << std::endl;
std::array<boost::asio::const_buffer, 2> buffers = {
{boost::asio::buffer(m_write_data.data(), m_write_data.size()),
boost::asio::buffer(hash.data(), hash.size())}
};
m_socket.async_write_some(buffers,
[this](const boost::system::error_code& error, std::size_t bytes_transferred) {
write_handler(error, bytes_transferred);
});
}
catch (const std::exception &e) {
_erro( "exception in execute_rpc_command " << e.what() );
_erro( "close connection\n" );
delete_me();
return;
}
}
static void
mm_hmacsha512(void)
{
crypto_auth_hmacsha512_state st;
unsigned char *h, *h2;
unsigned char *k;
unsigned char *m;
size_t mlen;
size_t l1, l2;
int i;
for (i = 0; i < MAX_ITER; i++) {
mlen = randombytes_uniform(MAXLEN);
m = (unsigned char *) sodium_malloc(mlen);
k = (unsigned char *) sodium_malloc(crypto_auth_hmacsha512_KEYBYTES);
h = (unsigned char *) sodium_malloc(crypto_auth_hmacsha512_BYTES);
h2 = (unsigned char *) sodium_malloc(crypto_auth_hmacsha512_BYTES);
crypto_auth_hmacsha512_keygen(k);
randombytes_buf(m, mlen);
crypto_auth_hmacsha512_init(&st, k, crypto_auth_hmacsha512_KEYBYTES);
l1 = randombytes_uniform(mlen);
l2 = randombytes_uniform(mlen - l1);
crypto_auth_hmacsha512_update(&st, m, l1);
crypto_auth_hmacsha512_update(&st, m + l1, l2);
crypto_auth_hmacsha512_update(&st, m + l1 + l2, mlen - l1 - l2);
crypto_auth_hmacsha512_final(&st, h);
crypto_auth_hmacsha512(h2, m, mlen, k);
assert(memcmp(h, h2, crypto_auth_hmacsha512_BYTES) == 0);
sodium_free(h2);
sodium_free(h);
sodium_free(k);
sodium_free(m);
}
}