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); } }