return_status user_store_import(
user_store ** const store,
User ** users,
const size_t users_length) {
return_status status = return_status_init();
//check input
if ((store == NULL)
|| ((users_length == 0) && (users != NULL))
|| ((users_length > 0) && (users == NULL))) {
throw(INVALID_INPUT, "Invalid input to user_store_import.");
}
status = user_store_create(store);
throw_on_error(CREATION_ERROR, "Failed to create user store.");
size_t i = 0;
user_store_node *node = NULL;
for (i = 0; i < users_length; i++) {
status = user_store_node_import(&node, users[i]);
throw_on_error(IMPORT_ERROR, "Failed to import user store node.");
add_user_store_node(*store, node);
}
cleanup:
on_error {
if (store != NULL) {
user_store_destroy(*store);
}
}
return status;
}
int main(void) {
if (sodium_init() == -1) {
return -1;
}
return_status status = return_status_init();
//create buffers
buffer_t *master_key = buffer_create_on_heap(50, 50);
buffer_t *subkey1 = buffer_create_on_heap(60, 60);
buffer_t *subkey2 = buffer_create_on_heap(60, 60);
buffer_t *subkey1_copy = buffer_create_on_heap(60, 60);
int status_int = 0;
status_int = buffer_fill_random(master_key, master_key->buffer_length);
if (status_int != 0) {
throw(KEYDERIVATION_FAILED, "Failed to generate master key.");
}
printf("Master key:\n");
print_hex(master_key);
putchar('\n');
status = derive_key(subkey1, subkey1->buffer_length, master_key, 0);
throw_on_error(KEYDERIVATION_FAILED, "Failed to derive first subkey.");
printf("First subkey:\n");
print_hex(subkey1);
putchar('\n');
status = derive_key(subkey2, subkey2->buffer_length, master_key, 1);
throw_on_error(KEYDERIVATION_FAILED, "Failed to derive the second subkey.");
printf("Second subkey:\n");
print_hex(subkey2);
putchar('\n');
if (buffer_compare(subkey1, subkey2) == 0) {
throw(KEYGENERATION_FAILED, "Both subkeys are the same.");
}
status = derive_key(subkey1_copy, subkey1_copy->buffer_length, master_key, 0);
throw_on_error(KEYDERIVATION_FAILED, "Failed to derive copy of the first subkey.");
if (buffer_compare(subkey1, subkey1_copy) != 0) {
throw(INCORRECT_DATA, "Failed to reproduce subkey.");
}
cleanup:
buffer_destroy_from_heap_and_null_if_valid(master_key);
buffer_destroy_from_heap_and_null_if_valid(subkey1);
buffer_destroy_from_heap_and_null_if_valid(subkey2);
buffer_destroy_from_heap_and_null_if_valid(subkey1_copy);
on_error {
print_errors(&status);
}
return_status_destroy_errors(&status);
return status.status;
}
bool small_test() {
const int alphabet_size = 5;
const int T = 2;
std::vector<float> activations = {0.1, 0.6, 0.1, 0.1, 0.1,
0.1, 0.1, 0.6, 0.1, 0.1};
// Calculate the score analytically
float expected_score;
{
std::vector<float> probs(activations.size());
softmax(activations.data(), alphabet_size, T, probs.data());
// Score calculation is specific to the given activations above
expected_score = probs[1] * probs[7];
}
std::vector<int> labels = {1, 2};
std::vector<int> label_lengths = {2};
std::vector<int> lengths;
lengths.push_back(T);
float score;
ctcComputeInfo info;
info.loc = CTC_CPU;
info.num_threads = 1;
size_t cpu_alloc_bytes;
throw_on_error(get_workspace_size(label_lengths.data(), lengths.data(),
alphabet_size, lengths.size(), info,
&cpu_alloc_bytes),
"Error: get_workspace_size in small_test");
void* ctc_cpu_workspace = malloc(cpu_alloc_bytes);
throw_on_error(compute_ctc_loss(activations.data(), NULL,
labels.data(), label_lengths.data(),
lengths.data(),
alphabet_size,
lengths.size(),
&score,
ctc_cpu_workspace,
info),
"Error: compute_ctc_loss in small_test");
free(ctc_cpu_workspace);
score = std::exp(-score);
const float eps = 1e-6;
const float lb = expected_score - eps;
const float ub = expected_score + eps;
return (score > lb && score < ub);
}
return_status protobuf_no_deprecated_keys() {
return_status status = return_status_init();
printf("Testing im-/export of prekey store without deprecated keys.\n");
prekey_store *store = NULL;
Prekey **exported = NULL;
size_t exported_length = 0;
Prekey **deprecated = NULL;
size_t deprecated_length = 0;
status = prekey_store_create(&store);
throw_on_error(CREATION_ERROR, "Failed to create prekey store.");
//export it
status = prekey_store_export(
store,
&exported,
&exported_length,
&deprecated,
&deprecated_length);
throw_on_error(EXPORT_ERROR, "Failed to export prekey store without deprecated keys.");
if ((deprecated != NULL) || (deprecated_length != 0)) {
throw(INCORRECT_DATA, "Exported deprecated prekeys are not empty.");
}
//import it
status = prekey_store_import(
&store,
exported,
exported_length,
deprecated,
deprecated_length);
throw_on_error(IMPORT_ERROR, "Failed to import prekey store without deprecated prekeys.");
printf("Successful.\n");
cleanup:
if (exported != NULL) {
for (size_t i = 0; i < exported_length; i++) {
prekey__free_unpacked(exported[i], &protobuf_c_allocators);
exported[i] = 0;
}
zeroed_free_and_null_if_valid(exported);
}
if (store != NULL) {
prekey_store_destroy(store);
}
return status;
}
bool inf_test() {
const int alphabet_size = 15;
const int T = 50;
const int L = 10;
const int minibatch = 1;
std::vector<int> labels = genLabels(alphabet_size, L);
labels[0] = 2;
std::vector<int> label_lengths = {L};
std::vector<float> acts = genActs(alphabet_size * T * minibatch);
for (int i = 0; i < T; ++i)
acts[alphabet_size * i + 2] = -1e30;
std::vector<int> sizes;
sizes.push_back(T);
std::vector<float> grads(alphabet_size * T);
float cost;
ctcComputeInfo info;
info.loc = CTC_CPU;
info.num_threads = 1;
size_t cpu_alloc_bytes;
throw_on_error(get_workspace_size(label_lengths.data(), sizes.data(),
alphabet_size, sizes.size(), info,
&cpu_alloc_bytes),
"Error: get_workspace_size in inf_test");
void* ctc_cpu_workspace = malloc(cpu_alloc_bytes);
throw_on_error(compute_ctc_loss(acts.data(), grads.data(),
labels.data(), label_lengths.data(),
sizes.data(),
alphabet_size,
sizes.size(),
&cost,
ctc_cpu_workspace,
info),
"Error: compute_ctc_loss in inf_test");
free(ctc_cpu_workspace);
bool status = true;
status &= std::isinf(cost);
for (int i = 0; i < alphabet_size * T; ++i)
status &= !std::isnan(grads[i]);
return status;
}
/*
* Create a new user and add it to the user store.
*
* The seed is optional an can be used to add entropy in addition
* to the entropy provided by the OS. IMPORTANT: Don't put entropy in
* here, that was generated by the OSs CPRNG!
*/
return_status user_store_create_user(
user_store *store,
const buffer_t * const seed, //optional, can be NULL
buffer_t * const public_signing_key, //output, optional, can be NULL
buffer_t * const public_identity_key) { //output, optional, can be NULL
return_status status = return_status_init();
user_store_node *new_node = NULL;
status = create_user_store_node(&new_node);
throw_on_error(CREATION_ERROR, "Failed to create new user store node.");
//generate the master keys
status = master_keys_create(
&(new_node->master_keys),
seed,
new_node->public_signing_key,
public_identity_key);
throw_on_error(CREATION_ERROR, "Failed to create master keys.");
//prekeys
status = prekey_store_create(&(new_node->prekeys));
throw_on_error(CREATION_ERROR, "Failed to create prekey store.")
//copy the public signing key, if requested
if (public_signing_key != NULL) {
if (public_signing_key->buffer_length < PUBLIC_MASTER_KEY_SIZE) {
throw(INCORRECT_BUFFER_SIZE, "Invalidly sized buffer for public signing key.");
}
if (buffer_clone(public_signing_key, new_node->public_signing_key) != 0) {
throw(BUFFER_ERROR, "Failed to clone public signing key.");
}
}
add_user_store_node(store, new_node);
cleanup:
on_error {
if (new_node != NULL) {
if (new_node->prekeys != NULL) {
prekey_store_destroy(new_node->prekeys);
}
if (new_node->master_keys != NULL) {
sodium_free_and_null_if_valid(new_node->master_keys);
}
sodium_free_and_null_if_valid(new_node);
}
}
return status;
}
/**
* A commit can have multiple parents
* n specifies the nth commit, from 0 to `parentCount`
*/
Commit Commit::parent(unsigned int n) const {
git_commit* ret = nullptr;
int error = git_commit_parent(&ret, get(), n);
Commit comm(ret);
throw_on_error(error);
return comm;
}
std::vector<std::string> Commit::getAffectedFiles() const {
git_tree* tree = nullptr;
git_tree* tree2 = nullptr;
int error = git_commit_tree(&tree, get());
throw_on_error(error);
try {
error = git_commit_tree(&tree2, parent(0).get());
} catch (GitException e) {
tree2 = nullptr; // probably initial commit
}
git_diff* diff = nullptr;
git_diff_tree_to_tree(&diff, getRepo(), tree2, tree, 0);
std::vector<std::string> ret;
git_diff_foreach(diff,
[](const git_diff_delta* entry, float progress, void* payload) {
std::string str = entry->old_file.path;
((std::vector<std::string>*)payload)->push_back(str);
return 0;
}, nullptr, nullptr, &ret);
git_tree_free(tree);
git_tree_free(tree2);
git_diff_free(diff);
return ret;
}
Diff::Diff(const Commit& comm, const Commit& comm2) {
git_tree *commit_tree = nullptr, *parent_tree = nullptr;
int error = 0;
error = git_commit_tree(&commit_tree, comm.get());
throw_on_error(error);
error = git_commit_tree(&parent_tree, comm2.get());
throw_on_error(error);
git_diff *d = nullptr;
error = git_diff_tree_to_tree(
&d, comm.getRepo(), commit_tree, parent_tree, nullptr);
throw_on_error(error);
// TODO: Make this exception safe
git_tree_free(commit_tree);
git_tree_free(parent_tree);
diff = std::shared_ptr<git_diff>(d, git_diff_free);
}
return_status user_store_node_import(user_store_node ** const node, const User * const user) {
return_status status = return_status_init();
//check input
if ((node == NULL) || (user == NULL)) {
throw(INVALID_INPUT, "Invalid input to user_store_node_import.");
}
status = create_user_store_node(node);
throw_on_error(CREATION_ERROR, "Failed to create user store node.");
//master keys
status = master_keys_import(
&((*node)->master_keys),
user->public_signing_key,
user->private_signing_key,
user->public_identity_key,
user->private_identity_key);
throw_on_error(IMPORT_ERROR, "Failed to import master keys.");
//public signing key
if (user->public_signing_key == NULL) {
throw(PROTOBUF_MISSING_ERROR, "Missing public signing key in Protobuf-C struct.");
}
if (buffer_clone_from_raw((*node)->public_signing_key, user->public_signing_key->key.data, user->public_signing_key->key.len) != 0) {
throw(BUFFER_ERROR, "Failed to copy public signing key.");
}
status = conversation_store_import(
(*node)->conversations,
user->conversations,
user->n_conversations);
throw_on_error(IMPORT_ERROR, "Failed to import conversations.");
status = prekey_store_import(
&((*node)->prekeys),
user->prekeys,
user->n_prekeys,
user->deprecated_prekeys,
user->n_deprecated_prekeys);
throw_on_error(IMPORT_ERROR, "Failed to import prekeys.");
cleanup:
return status;
}
return_status first_level() {
return_status status = return_status_init();
status = second_level();
throw_on_error(GENERIC_ERROR, "Error on the first level!");
cleanup:
return status;
}
__host__ __device__
gpu_id current_gpu()
{
int result = -1;
#if __cuda_lib_has_cudart
throw_on_error(cudaGetDevice(&result), "cuda::detail::current_gpu(): cudaGetDevice()");
#endif
return gpu_id(result);
}
return_status protobuf_export(
prekey_store * const store,
Prekey *** const keypairs,
size_t * const keypairs_size,
buffer_t *** const key_buffers,
Prekey *** const deprecated_keypairs,
size_t * const deprecated_keypairs_size,
buffer_t *** const deprecated_key_buffers) {
return_status status = return_status_init();
status = prekey_store_export(
store,
keypairs,
keypairs_size,
deprecated_keypairs,
deprecated_keypairs_size);
throw_on_error(EXPORT_ERROR, "Failed to export prekeys.");
*key_buffers = zeroed_malloc((*keypairs_size) * sizeof(buffer_t*));
throw_on_failed_alloc(*key_buffers);
//initialize pointers with NULL
memset(*key_buffers, '\0', (*keypairs_size) * sizeof(buffer_t*));
*deprecated_key_buffers = zeroed_malloc((*deprecated_keypairs_size) * sizeof(buffer_t*));
throw_on_failed_alloc(*deprecated_key_buffers);
//initialize pointers with NULL
memset(*deprecated_key_buffers, '\0', (*deprecated_keypairs_size) * sizeof(buffer_t*));
//export all the keypairs
for (size_t i = 0; i < (*keypairs_size); i++) {
size_t export_size = prekey__get_packed_size((*keypairs)[i]);
(*key_buffers)[i] = buffer_create_on_heap(export_size, 0);
throw_on_failed_alloc((*key_buffers)[i]);
size_t packed_size = prekey__pack((*keypairs)[i], (*key_buffers)[i]->content);
(*key_buffers)[i]->content_length = packed_size;
}
//export all the deprecated keypairs
for (size_t i = 0; i < (*deprecated_keypairs_size); i++) {
size_t export_size = prekey__get_packed_size((*deprecated_keypairs)[i]);
(*deprecated_key_buffers)[i] = buffer_create_on_heap(export_size, 0);
throw_on_failed_alloc((*deprecated_key_buffers)[i]);
size_t packed_size = prekey__pack((*deprecated_keypairs)[i], (*deprecated_key_buffers)[i]->content);
(*deprecated_key_buffers)[i]->content_length = packed_size;
}
cleanup:
//cleanup is done in the main function
return status;
}
/*
* Remove a user from the user store.
*
* The user is identified by it's public signing key.
*/
return_status user_store_remove_by_key(user_store * const store, const buffer_t * const public_signing_key) {
return_status status = return_status_init();
user_store_node *node = NULL;
status = user_store_find_node(&node, store, public_signing_key);
throw_on_error(NOT_FOUND, "Failed to find user to remove.");
user_store_remove(store, node);
cleanup:
return status;
}
__host__ __device__
void checked_launch_kernel_after_event(void* kernel, ::dim3 grid_dim, ::dim3 block_dim, int shared_memory_size, cudaStream_t stream, cudaEvent_t event, const Args&... args)
{
#if __cuda_lib_has_cudart
if(event)
{
// make the next launch wait on the event
throw_on_error(cudaStreamWaitEvent(stream, event, 0), "cuda::detail::checked_launch_kernel_after_event(): cudaStreamWaitEvent()");
}
#else
// the error message we return depends on how the program was compiled
const char* error_message =
# ifndef __CUDA_ARCH__
"cuda::detail::checked_launch_kernel_after_event(): CUDA kernel launch from host requires nvcc"
# else
"cuda::detail::checked_launch_kernel_after_event(): CUDA kernel launch from device requires arch=sm_35 or better and rdc=true"
# endif
;
throw_on_error(cudaErrorNotSupported, error_message);
#endif // __cuda_lib_has_cudart
checked_launch_kernel(kernel, grid_dim, block_dim, shared_memory_size, stream, args...);
}
virtual void add(std::string ts, std::string id, double value) {
aku_Status status = AKU_EBUSY;
while(status == AKU_EBUSY) {
aku_Sample sample;
if (aku_parse_timestamp(ts.c_str(), &sample) != AKU_SUCCESS) {
std::runtime_error err("invalid timestamp");
BOOST_THROW_EXCEPTION(err);
}
if (aku_series_to_param_id(db_, id.data(), id.data() + id.size(), &sample) != AKU_SUCCESS) {
std::runtime_error err("invalid series name");
BOOST_THROW_EXCEPTION(err);
}
sample.payload.type = AKU_PAYLOAD_FLOAT;
sample.payload.float64 = value;
status = aku_write(db_, &sample);
}
throw_on_error(status);
}
virtual void open()
{
if (db_ != nullptr) {
std::logic_error err("Database allready opened");
BOOST_THROW_EXCEPTION(err);
}
aku_FineTuneParams params;
params.durability = durability_;
params.enable_huge_tlb = enable_huge_tlb_ ? 1 : 0;
params.logger = &aku_console_logger;
params.compression_threshold = compression_threshold_;
params.window_size = sliding_window_size_;
std::string path = get_db_file_path();
db_ = aku_open_database(path.c_str(), params);
auto status = aku_open_status(db_);
throw_on_error(status);
}
return_status user_store_export(
const user_store * const store,
User *** const users,
size_t * const users_length) {
return_status status = return_status_init();
//check input
if ((users == NULL) || (users == NULL) || (users_length == NULL)) {
throw(INVALID_INPUT, "Invalid input to user_store_export.");
}
if (store->length > 0) {
*users = zeroed_malloc(store->length * sizeof(User*));
throw_on_failed_alloc(*users);
memset(*users, '\0', store->length * sizeof(User*));
size_t i = 0;
user_store_node *node = NULL;
for (i = 0, node = store->head; (i < store->length) && (node != NULL); i++, node = node->next) {
status = user_store_node_export(node, &((*users)[i]));
throw_on_error(EXPORT_ERROR, "Failed to export user store node.");
}
} else {
*users = NULL;
}
*users_length = store->length;
cleanup:
on_error {
if ((users != NULL) && (*users != NULL) && (users_length != 0)) {
for (size_t i = 0; i < *users_length; i++) {
user__free_unpacked((*users)[i], &protobuf_c_allocators);
(*users)[i] = NULL;
}
zeroed_free_and_null_if_valid(*users);
}
}
return status;
}
__host__ __device__
void checked_launch_kernel(void* kernel, ::dim3 grid_dim, ::dim3 block_dim, int shared_memory_size, cudaStream_t stream, const Args&... args)
{
// the error message we return depends on how the program was compiled
const char* error_message =
#if __cuda_lib_has_cudart
// we have access to CUDART, so something went wrong during the kernel
# ifndef __CUDA_ARCH__
"cuda::detail::checked_launch_kernel(): CUDA error after cudaLaunch()"
# else
"cuda::detail::checked_launch_kernel(): CUDA error after cudaLaunchDevice()"
# endif // __CUDA_ARCH__
#else // __cuda_lib_has_cudart
// we don't have access to CUDART, so output a useful error message explaining why it's unsupported
# ifndef __CUDA_ARCH__
"cuda::detail::checked_launch_kernel(): CUDA kernel launch from host requires nvcc"
# else
"cuda::detail::checked_launch_kernel(): CUDA kernel launch from device requires arch=sm_35 or better and rdc=true"
# endif // __CUDA_ARCH__
#endif
;
throw_on_error(launch_kernel(kernel, grid_dim, block_dim, shared_memory_size, stream, args...), error_message);
}
__host__ __device__
void checked_launch_kernel_after_event_on_device(void* kernel, ::dim3 grid_dim, ::dim3 block_dim, int shared_memory_size, cudaStream_t stream, cudaEvent_t dependency, int device, const Args&... args)
{
#if __cuda_lib_has_cudart
// record the current device
int current_device = 0;
throw_on_error(cudaGetDevice(¤t_device), "cuda::detail::checked_launch_kernel_after_event_on_device(): cudaGetDevice()");
if(current_device != device)
{
# ifndef __CUDA_ARCH__
throw_on_error(cudaSetDevice(device), "cuda::detail::checked_launch_kernel_after_event_on_device(): cudaSetDevice()");
# else
throw_on_error(cudaErrorNotSupported, "cuda::detail::checked_launch_kernel_after_event_on_device(): CUDA kernel launch only allowed on the current device in __device__ code");
# endif // __CUDA_ARCH__
}
#else
// the error message we return depends on how the program was compiled
const char* error_message =
# ifndef __CUDA_ARCH__
"cuda::detail::checked_launch_kernel_on_device(): CUDA kernel launch from host requires nvcc"
# else
"cuda::detail::checked_launch_kernel_on_device(): CUDA kernel launch from device requires arch=sm_35 or better and rdc=true"
# endif
;
throw_on_error(cudaErrorNotSupported, error_message);
#endif // __cuda_lib_has_cudart
printf("about to call checked_launch_kernel_after_event\n");
checked_launch_kernel_after_event(kernel, grid_dim, block_dim, shared_memory_size, stream, dependency, args...);
#if __cuda_lib_has_cudart
// restore the device
# ifndef __CUDA_ARCH__
if(current_device != device)
{
throw_on_error(cudaSetDevice(current_device), "cuda::detail::checked_launch_kernel_after_event_on_device: cudaSetDevice()");
}
# endif // __CUDA_ARCH__
#else
throw_on_error(cudaErrorNotSupported, "cuda::detail::checked_launch_kernel_after_event_on_device(): cudaSetDevice requires CUDART");
#endif // __cuda_lib_has_cudart
}
int main(void) {
if (sodium_init() == -1) {
return -1;
}
return_status status = return_status_init();
//create buffers
buffer_t *alice_public_key = buffer_create_on_heap(crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
buffer_t *alice_private_key = buffer_create_on_heap(crypto_box_SECRETKEYBYTES, crypto_box_SECRETKEYBYTES);
buffer_t *alice_shared_secret = buffer_create_on_heap(crypto_generichash_BYTES, crypto_generichash_BYTES);
buffer_t *bob_public_key = buffer_create_on_heap(crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
buffer_t *bob_private_key = buffer_create_on_heap(crypto_box_SECRETKEYBYTES, crypto_box_SECRETKEYBYTES);
buffer_t *bob_shared_secret = buffer_create_on_heap(crypto_generichash_BYTES, crypto_generichash_BYTES);
int status_int = 0;
//create Alice's keypair
buffer_create_from_string(alice_string, "Alice");
buffer_create_from_string(empty_string, "");
status = generate_and_print_keypair(
alice_public_key,
alice_private_key,
alice_string,
empty_string);
throw_on_error(KEYGENERATION_FAILED, "Failed to generate and print Alice's keypair.");
//create Bob's keypair
buffer_create_from_string(bob_string, "Bob");
status = generate_and_print_keypair(
bob_public_key,
bob_private_key,
bob_string,
empty_string);
throw_on_error(KEYGENERATION_FAILED, "Failed to generate and print Bob's keypair.");
//Diffie Hellman on Alice's side
status = diffie_hellman(
alice_shared_secret,
alice_private_key,
alice_public_key,
bob_public_key,
true);
buffer_clear(alice_private_key);
throw_on_error(KEYGENERATION_FAILED, "Diffie Hellman with Alice's private key failed.");
//print Alice's shared secret
printf("Alice's shared secret ECDH(A_priv, B_pub) (%zu Bytes):\n", alice_shared_secret->content_length);
print_hex(alice_shared_secret);
putchar('\n');
//Diffie Hellman on Bob's side
status = diffie_hellman(
bob_shared_secret,
bob_private_key,
bob_public_key,
alice_public_key,
false);
buffer_clear(bob_private_key);
throw_on_error(KEYGENERATION_FAILED, "Diffie Hellman with Bob's private key failed.");
//print Bob's shared secret
printf("Bob's shared secret ECDH(B_priv, A_pub) (%zu Bytes):\n", bob_shared_secret->content_length);
print_hex(bob_shared_secret);
putchar('\n');
//compare both shared secrets
status_int = buffer_compare(alice_shared_secret, bob_shared_secret);
buffer_clear(alice_shared_secret);
buffer_clear(bob_shared_secret);
if (status_int != 0) {
throw(INCORRECT_DATA, "Diffie Hellman didn't produce the same shared secret.");
}
printf("Both shared secrets match!\n");
cleanup:
buffer_destroy_from_heap_and_null_if_valid(alice_public_key);
buffer_destroy_from_heap_and_null_if_valid(alice_private_key);
buffer_destroy_from_heap_and_null_if_valid(alice_shared_secret);
buffer_destroy_from_heap_and_null_if_valid(bob_public_key);
buffer_destroy_from_heap_and_null_if_valid(bob_private_key);
buffer_destroy_from_heap_and_null_if_valid(bob_shared_secret);
on_error {
print_errors(&status);
}
return_status_destroy_errors(&status);
return status.status;
}
int main(void) {
return_status status = return_status_init();
//generate keys
buffer_t *header_key = buffer_create_on_heap(crypto_aead_chacha20poly1305_KEYBYTES, crypto_aead_chacha20poly1305_KEYBYTES);
buffer_t *message_key = buffer_create_on_heap(crypto_secretbox_KEYBYTES, crypto_secretbox_KEYBYTES);
buffer_t *public_identity_key = buffer_create_on_heap(PUBLIC_KEY_SIZE, PUBLIC_KEY_SIZE);
buffer_t *public_ephemeral_key = buffer_create_on_heap(PUBLIC_KEY_SIZE, PUBLIC_KEY_SIZE);
buffer_t *public_prekey = buffer_create_on_heap(PUBLIC_KEY_SIZE, PUBLIC_KEY_SIZE);
buffer_t *header = buffer_create_on_heap(4, 4);
buffer_create_from_string(message, "Hello world!\n");
buffer_t *packet = NULL;
buffer_t *decrypted_header = NULL;
if(sodium_init() == -1) {
throw(INIT_ERROR, "Failed to initialize libsodium.");
}
//generate message
header->content[0] = 0x01;
header->content[1] = 0x02;
header->content[2] = 0x03;
header->content[3] = 0x04;
molch_message_type packet_type = 1;
printf("Packet type: %02x\n", packet_type);
putchar('\n');
//NORMAL MESSAGE
printf("NORMAL MESSAGE\n");
int status_int = 0;
status = create_and_print_message(
&packet,
header_key,
message_key,
packet_type,
header,
message,
NULL,
NULL,
NULL);
throw_on_error(GENERIC_ERROR, "Failed to create and print message.");
//now decrypt the header
status = packet_decrypt_header(
&decrypted_header,
packet,
header_key);
throw_on_error(DECRYPT_ERROR, "Failed to decrypt the header.");
if (decrypted_header->content_length != header->content_length) {
throw(INVALID_VALUE, "Decrypted header isn't of the same length.");
}
printf("Decrypted header has the same length.\n\n");
//compare headers
if (buffer_compare(header, decrypted_header) != 0) {
throw(INVALID_VALUE, "Decrypted header doesn't match.");
}
printf("Decrypted header matches.\n\n");
//check if it decrypts manipulated packets (manipulated metadata)
printf("Manipulating header length.\n");
packet->content[2]++;
status = packet_decrypt_header(
&decrypted_header,
packet,
header_key);
if (status.status == SUCCESS) {
throw(GENERIC_ERROR, "Manipulated packet was accepted.");
} else {
return_status_destroy_errors(&status);
}
printf("Header manipulation detected.\n\n");
//repair manipulation
packet->content[2]--;
//check if it decrypts manipulated packets (manipulated header)
printf("Manipulate header.\n");
packet->content[3 + crypto_aead_chacha20poly1305_NPUBBYTES + 1] ^= 0x12;
status = packet_decrypt_header(
&decrypted_header,
packet,
header_key);
if (status.status == SUCCESS) {
throw(GENERIC_ERROR, "Manipulated packet was accepted.");
} else {
return_status_destroy_errors(&status);
}
printf("Header manipulation detected!\n\n");
//undo header manipulation
packet->content[3 + crypto_aead_chacha20poly1305_NPUBBYTES + 1] ^= 0x12;
//PREKEY MESSAGE
printf("PREKEY_MESSAGE\n");
//create the public keys
status_int = buffer_fill_random(public_identity_key, PUBLIC_KEY_SIZE);
if (status_int != 0) {
throw(KEYGENERATION_FAILED, "Failed to generate public identity key.");
}
status_int = buffer_fill_random(public_ephemeral_key, PUBLIC_KEY_SIZE);
if (status_int != 0) {
throw(KEYGENERATION_FAILED, "Failed to generate public ephemeral key.");
}
status_int = buffer_fill_random(public_prekey, PUBLIC_KEY_SIZE);
if (status_int != 0) {
throw(KEYGENERATION_FAILED, "Failed to generate public prekey.");
}
buffer_destroy_from_heap_and_null_if_valid(packet);
packet_type = PREKEY_MESSAGE;
status = create_and_print_message(
&packet,
header_key,
message_key,
packet_type,
header,
message,
public_identity_key,
public_ephemeral_key,
public_prekey);
throw_on_error(GENERIC_ERROR, "Failed to crate and print message.");
//now decrypt the header
status = packet_decrypt_header(
&decrypted_header,
packet,
header_key);
throw_on_error(DECRYPT_ERROR, "Failed to decrypt the header.");
if (decrypted_header->content_length != header->content_length) {
throw(INVALID_VALUE, "Decrypted header isn't of the same length.");
}
printf("Decrypted header has the same length.\n\n");
//compare headers
if (buffer_compare(header, decrypted_header) != 0) {
throw(INVALID_VALUE, "Decrypted header doesn't match.");
}
printf("Decrypted header matches.\n");
cleanup:
buffer_destroy_from_heap_and_null_if_valid(header_key);
buffer_destroy_from_heap_and_null_if_valid(message_key);
buffer_destroy_from_heap_and_null_if_valid(header);
buffer_destroy_from_heap_and_null_if_valid(public_identity_key);
buffer_destroy_from_heap_and_null_if_valid(public_ephemeral_key);
buffer_destroy_from_heap_and_null_if_valid(public_prekey);
buffer_destroy_from_heap_and_null_if_valid(packet);
buffer_destroy_from_heap_and_null_if_valid(decrypted_header);
on_error {
print_errors(&status);
}
return_status_destroy_errors(&status);
return status.status;
}
int main(void) {
if (sodium_init() == -1) {
return -1;
}
return_status status = return_status_init();
//create buffers
//alice keys
buffer_t * const alice_public_identity = buffer_create_on_heap(crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
buffer_t * const alice_private_identity = buffer_create_on_heap(crypto_box_SECRETKEYBYTES, crypto_box_SECRETKEYBYTES);
buffer_t * const alice_public_ephemeral = buffer_create_on_heap(crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
buffer_t * const alice_private_ephemeral = buffer_create_on_heap(crypto_box_SECRETKEYBYTES, crypto_box_SECRETKEYBYTES);
buffer_t * const alice_shared_secret = buffer_create_on_heap(crypto_generichash_BYTES, crypto_generichash_BYTES);
//bobs keys
buffer_t * const bob_public_identity = buffer_create_on_heap(crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
buffer_t * const bob_private_identity = buffer_create_on_heap(crypto_box_SECRETKEYBYTES, crypto_box_SECRETKEYBYTES);
buffer_t * const bob_public_ephemeral = buffer_create_on_heap(crypto_box_PUBLICKEYBYTES, crypto_box_PUBLICKEYBYTES);
buffer_t * const bob_private_ephemeral = buffer_create_on_heap(crypto_box_SECRETKEYBYTES, crypto_box_SECRETKEYBYTES);
buffer_t * const bob_shared_secret = buffer_create_on_heap(crypto_generichash_BYTES, crypto_generichash_BYTES);
printf("Generate Alice's keys -------------------------------------------------------\n\n");
int status_int = 0;
//create Alice's identity keypair
buffer_create_from_string(alice_string, "Alice");
buffer_create_from_string(identity_string, "identity");
status = generate_and_print_keypair(
alice_public_identity,
alice_private_identity,
alice_string,
identity_string);
throw_on_error(KEYGENERATION_FAILED, "Failed to generate and print Alice' identity keypair.");
//create Alice's ephemeral keypair
buffer_create_from_string(ephemeral_string, "ephemeral");
status = generate_and_print_keypair(
alice_public_ephemeral,
alice_private_ephemeral,
alice_string,
ephemeral_string);
throw_on_error(KEYGENERATION_FAILED, "Failed to generate and print Alice' ephemeral keypair.");
printf("Generate Bob's keys ---------------------------------------------------------\n\n");
//create Bob's identity keypair
buffer_create_from_string(bob_string, "Bob");
status = generate_and_print_keypair(
bob_public_identity,
bob_private_identity,
bob_string,
identity_string);
throw_on_error(KEYGENERATION_FAILED, "Failed to generate and print Bob's identity keypair.");
//create Bob's ephemeral keypair
status = generate_and_print_keypair(
bob_public_ephemeral,
bob_private_ephemeral,
bob_string,
ephemeral_string);
throw_on_error(KEYGENERATION_FAILED, "Failed to generate and print Bob's ephemeral keypair.");
printf("Calculate shared secret via Triple Diffie Hellman ---------------------------\n\n");
//Triple Diffie Hellman on Alice's side
status = triple_diffie_hellman(
alice_shared_secret,
alice_private_identity,
alice_public_identity,
alice_private_ephemeral,
alice_public_ephemeral,
bob_public_identity,
bob_public_ephemeral,
true);
buffer_clear(alice_private_identity);
buffer_clear(alice_private_ephemeral);
throw_on_error(KEYGENERATION_FAILED, "Triple Diffie Hellman for Alice failed.");
//print Alice's shared secret
printf("Alice's shared secret H(DH(A_priv,B0_pub)||DH(A0_priv,B_pub)||DH(A0_priv,B0_pub)):\n");
print_hex(alice_shared_secret);
putchar('\n');
//Triple Diffie Hellman on Bob's side
status = triple_diffie_hellman(
bob_shared_secret,
bob_private_identity,
bob_public_identity,
bob_private_ephemeral,
bob_public_ephemeral,
alice_public_identity,
alice_public_ephemeral,
false);
buffer_clear(bob_private_identity);
buffer_clear(bob_private_ephemeral);
throw_on_error(KEYGENERATION_FAILED, "Triple Diffie Hellnan for Bob failed.");
//print Bob's shared secret
printf("Bob's shared secret H(DH(B0_priv, A_pub)||DH(B_priv, A0_pub)||DH(B0_priv, A0_pub)):\n");
print_hex(bob_shared_secret);
putchar('\n');
//compare both shared secrets
status_int = buffer_compare(alice_shared_secret, bob_shared_secret);
buffer_clear(alice_shared_secret);
buffer_clear(bob_shared_secret);
if (status_int != 0) {
throw(INCORRECT_DATA, "Triple Diffie Hellman didn't produce the same shared secret.");
}
printf("Both shared secrets match!\n");
cleanup:
//alice keys
buffer_destroy_from_heap(alice_public_identity);
buffer_destroy_from_heap(alice_private_identity);
buffer_destroy_from_heap(alice_public_ephemeral);
buffer_destroy_from_heap(alice_private_ephemeral);
buffer_destroy_from_heap(alice_shared_secret);
//bobs keys
buffer_destroy_from_heap(bob_public_identity);
buffer_destroy_from_heap(bob_private_identity);
buffer_destroy_from_heap(bob_public_ephemeral);
buffer_destroy_from_heap(bob_private_ephemeral);
buffer_destroy_from_heap(bob_shared_secret);
on_error {
print_errors(&status);
}
return_status_destroy_errors(&status);
return status.status;
}
std::shared_ptr<git_diff_stats> Diff::getStats() const {
git_diff_stats* stats = nullptr;
int error = git_diff_get_stats(&stats, get());
throw_on_error(error);
return std::shared_ptr<git_diff_stats>(stats, git_diff_stats_free);
}
/*
* Create a new set of master keys.
*
* Seed is optional, can be NULL. It can be of any length and doesn't
* require to have high entropy. It will be used as entropy source
* in addition to the OSs CPRNG.
*
* WARNING: Don't use Entropy from the OSs CPRNG as seed!
*/
return_status master_keys_create(
master_keys ** const keys, //output
const buffer_t * const seed,
buffer_t * const public_signing_key, //output, optional, can be NULL
buffer_t * const public_identity_key //output, optional, can be NULL
) {
return_status status = return_status_init();
//seeds
buffer_t *crypto_seeds = NULL;
if (keys == NULL) {
throw(INVALID_INPUT, "Invalid input for master_keys_create.");
}
*keys = sodium_malloc(sizeof(master_keys));
throw_on_failed_alloc(*keys);
//initialize the buffers
buffer_init_with_pointer((*keys)->public_signing_key, (*keys)->public_signing_key_storage, PUBLIC_MASTER_KEY_SIZE, PUBLIC_MASTER_KEY_SIZE);
buffer_init_with_pointer((*keys)->private_signing_key, (*keys)->private_signing_key_storage, PRIVATE_MASTER_KEY_SIZE, PRIVATE_MASTER_KEY_SIZE);
buffer_init_with_pointer((*keys)->public_identity_key, (*keys)->public_identity_key_storage, PUBLIC_KEY_SIZE, PUBLIC_KEY_SIZE);
buffer_init_with_pointer((*keys)->private_identity_key, (*keys)->private_identity_key_storage, PRIVATE_KEY_SIZE, PRIVATE_KEY_SIZE);
if (seed != NULL) { //use external seed
//create the seed buffer
crypto_seeds = buffer_create_with_custom_allocator(
crypto_sign_SEEDBYTES + crypto_box_SEEDBYTES,
crypto_sign_SEEDBYTES + crypto_box_SEEDBYTES,
sodium_malloc,
sodium_free);
throw_on_failed_alloc(crypto_seeds);
status = spiced_random(crypto_seeds, seed, crypto_seeds->buffer_length);
throw_on_error(GENERIC_ERROR, "Failed to create spiced random data.");
//generate the signing keypair
int status_int = 0;
status_int = crypto_sign_seed_keypair(
(*keys)->public_signing_key->content,
(*keys)->private_signing_key_storage,
crypto_seeds->content);
if (status_int != 0) {
throw(KEYGENERATION_FAILED, "Failed to generate signing keypair.");
}
//generate the identity keypair
status_int = crypto_box_seed_keypair(
(*keys)->public_identity_key->content,
(*keys)->private_identity_key->content,
crypto_seeds->content + crypto_sign_SEEDBYTES);
if (status_int != 0) {
throw(KEYGENERATION_FAILED, "Failed to generate encryption keypair.");
}
} else { //don't use external seed
//generate the signing keypair
int status_int = 0;
status_int = crypto_sign_keypair(
(*keys)->public_signing_key->content,
(*keys)->private_signing_key->content);
if (status_int != 0) {
throw(KEYGENERATION_FAILED, "Failed to generate signing keypair.");
}
//generate the identity keypair
status_int = crypto_box_keypair(
(*keys)->public_identity_key->content,
(*keys)->private_identity_key->content);
if (status_int != 0) {
throw(KEYGENERATION_FAILED, "Failed to generate encryption keypair.");
}
}
//copy the public keys if requested
if (public_signing_key != NULL) {
if (public_signing_key->buffer_length < PUBLIC_MASTER_KEY_SIZE) {
public_signing_key->content_length = 0;
throw(INCORRECT_BUFFER_SIZE, "Public master key buffer is too short.");
}
if (buffer_clone(public_signing_key, (*keys)->public_signing_key) != 0) {
throw(BUFFER_ERROR, "Failed to copy public signing key.");
}
}
if (public_identity_key != NULL) {
if (public_identity_key->buffer_length < PUBLIC_KEY_SIZE) {
public_identity_key->content_length = 0;
throw(INCORRECT_BUFFER_SIZE, "Public encryption key buffer is too short.");
}
if (buffer_clone(public_identity_key, (*keys)->public_identity_key) != 0) {
throw(BUFFER_ERROR, "Failed to copy public encryption key.");
}
}
cleanup:
buffer_destroy_with_custom_deallocator_and_null_if_valid(crypto_seeds, sodium_free);
on_error {
if (keys != NULL) {
sodium_free_and_null_if_valid(*keys);
}
return status;
}
if ((keys != NULL) && (*keys != NULL)) {
sodium_mprotect_noaccess(*keys);
}
return status;
}
int main(void) {
if (sodium_init() == -1) {
return -1;
}
return_status status = return_status_init();
buffer_t *public_prekey = buffer_create_on_heap(PUBLIC_KEY_SIZE, PUBLIC_KEY_SIZE);
buffer_t *private_prekey1 = buffer_create_on_heap(PRIVATE_KEY_SIZE, PRIVATE_KEY_SIZE);
buffer_t *private_prekey2 = buffer_create_on_heap(PRIVATE_KEY_SIZE, PRIVATE_KEY_SIZE);
buffer_t *prekey_list = buffer_create_on_heap(PREKEY_AMOUNT * PUBLIC_KEY_SIZE, PREKEY_AMOUNT * PUBLIC_KEY_SIZE);
Prekey **protobuf_export_prekeys = NULL;
buffer_t **protobuf_export_prekeys_buffers = NULL;
size_t protobuf_export_prekeys_size = 0;
Prekey **protobuf_export_deprecated_prekeys = NULL;
buffer_t **protobuf_export_deprecated_prekeys_buffers = NULL;
size_t protobuf_export_deprecated_prekeys_size = 0;
Prekey **protobuf_second_export_prekeys = NULL;
buffer_t **protobuf_second_export_prekeys_buffers = NULL;
size_t protobuf_second_export_prekeys_size = 0;
Prekey **protobuf_second_export_deprecated_prekeys = NULL;
buffer_t **protobuf_second_export_deprecated_prekeys_buffers = NULL;
size_t protobuf_second_export_deprecated_prekeys_size = 0;
prekey_store *store = NULL;
status = prekey_store_create(&store);
throw_on_error(CREATION_ERROR, "Failed to create a prekey store.");
status = prekey_store_list(store, prekey_list);
throw_on_error(DATA_FETCH_ERROR, "Failed to list prekeys.");
printf("Prekey list:\n");
print_hex(prekey_list);
putchar('\n');
//compare the public keys with the ones in the prekey store
for (size_t i = 0; i < PREKEY_AMOUNT; i++) {
if (buffer_compare_partial(prekey_list, PUBLIC_KEY_SIZE * i, store->prekeys[i].public_key, 0, PUBLIC_KEY_SIZE) != 0) {
throw(INCORRECT_DATA, "Key list doesn't match the prekey store.");
}
}
printf("Prekey list matches the prekey store!\n");
//get a private key
const size_t prekey_index = 10;
if (buffer_clone(public_prekey, store->prekeys[prekey_index].public_key) != 0) {
throw(BUFFER_ERROR, "Failed to clone public key.");
}
status = prekey_store_get_prekey(store, public_prekey, private_prekey1);
throw_on_error(DATA_FETCH_ERROR, "Failed to get prekey.")
printf("Get a Prekey:\n");
printf("Public key:\n");
print_hex(public_prekey);
printf("Private key:\n");
print_hex(private_prekey1);
putchar('\n');
if (store->deprecated_prekeys == NULL) {
throw(GENERIC_ERROR, "Failed to deprecate requested key.");
}
if ((buffer_compare(public_prekey, store->deprecated_prekeys->public_key) != 0)
|| (buffer_compare(private_prekey1, store->deprecated_prekeys->private_key) != 0)) {
throw(INCORRECT_DATA, "Deprecated key is incorrect.");
}
if (buffer_compare(store->prekeys[prekey_index].public_key, public_prekey) == 0) {
throw(KEYGENERATION_FAILED, "Failed to generate new key for deprecated one.");
}
printf("Successfully deprecated requested key!\n");
//check if the prekey can be obtained from the deprecated keys
status = prekey_store_get_prekey(store, public_prekey, private_prekey2);
throw_on_error(DATA_FETCH_ERROR, "Failed to get key from the deprecated area.");
if (buffer_compare(private_prekey1, private_prekey2) != 0) {
throw(INCORRECT_DATA, "Prekey from the deprecated area didn't match.");
}
printf("Successfully got prekey from the deprecated area!\n");
//try to get a nonexistent key
if (buffer_fill_random(public_prekey, PUBLIC_KEY_SIZE) != 0) {
throw(KEYGENERATION_FAILED, "Failed to generate invalid public prekey.");
}
status = prekey_store_get_prekey(store, public_prekey, private_prekey1);
if (status.status == SUCCESS) {
throw(GENERIC_ERROR, "Didn't complain about invalid public key.");
}
printf("Detected invalid public prekey!\n");
//reset return status
return_status_destroy_errors(&status);
status.status = SUCCESS;
//Protobuf-C export
printf("Protobuf-C export\n");
status = protobuf_export(
store,
&protobuf_export_prekeys,
&protobuf_export_prekeys_size,
&protobuf_export_prekeys_buffers,
&protobuf_export_deprecated_prekeys,
&protobuf_export_deprecated_prekeys_size,
&protobuf_export_deprecated_prekeys_buffers);
throw_on_error(EXPORT_ERROR, "Failed to export prekey store to protobuf.");
printf("Prekeys:\n");
puts("[\n");
for (size_t i = 0; i < protobuf_export_prekeys_size; i++) {
print_hex(protobuf_export_prekeys_buffers[i]);
puts(",\n");
}
puts("]\n\n");
printf("Deprecated Prekeys:\n");
puts("[\n");
for (size_t i = 0; i < protobuf_export_deprecated_prekeys_size; i++) {
print_hex(protobuf_export_deprecated_prekeys_buffers[i]);
puts(",\n");
}
puts("]\n\n");
prekey_store_destroy(store);
store = NULL;
printf("Import from Protobuf-C\n");
status = protobuf_import(
&store,
protobuf_export_prekeys_buffers,
protobuf_export_prekeys_size,
protobuf_export_deprecated_prekeys_buffers,
protobuf_export_deprecated_prekeys_size);
throw_on_error(IMPORT_ERROR, "Failed to import from protobuf.");
printf("Protobuf-C export again\n");
status = protobuf_export(
store,
&protobuf_second_export_prekeys,
&protobuf_second_export_prekeys_size,
&protobuf_second_export_prekeys_buffers,
&protobuf_second_export_deprecated_prekeys,
&protobuf_second_export_deprecated_prekeys_size,
&protobuf_second_export_deprecated_prekeys_buffers);
throw_on_error(EXPORT_ERROR, "Failed to export prekey store to protobuf.");
//compare both prekey lists
printf("Compare normal prekeys\n");
if (protobuf_export_prekeys_size != protobuf_second_export_prekeys_size) {
throw(INCORRECT_DATA, "Both prekey exports contain different amounts of keys.");
}
for (size_t i = 0; i < protobuf_export_prekeys_size; i++) {
if (buffer_compare(protobuf_export_prekeys_buffers[i], protobuf_second_export_prekeys_buffers[i]) != 0) {
throw(INCORRECT_DATA, "First and second prekey export are not identical.");
}
}
//compare both deprecated prekey lists
printf("Compare deprecated prekeys\n");
if (protobuf_export_deprecated_prekeys_size != protobuf_second_export_deprecated_prekeys_size) {
throw(INCORRECT_DATA, "Both depcated prekey exports contain different amounts of keys.");
}
for (size_t i = 0; i < protobuf_export_deprecated_prekeys_size; i++) {
if (buffer_compare(protobuf_export_deprecated_prekeys_buffers[i], protobuf_second_export_deprecated_prekeys_buffers[i]) != 0) {
throw(INCORRECT_DATA, "First and second deprecated prekey export are not identical.");
}
}
//test the automatic deprecation of old keys
if (buffer_clone(public_prekey, store->prekeys[PREKEY_AMOUNT-1].public_key) != 0) {
throw(BUFFER_ERROR, "Failed to clone public key.");
}
store->prekeys[PREKEY_AMOUNT-1].expiration_date -= 365 * 24 * 3600; //one year
store->oldest_expiration_date = store->prekeys[PREKEY_AMOUNT - 1].expiration_date;
status = prekey_store_rotate(store);
throw_on_error(GENERIC_ERROR, "Failed to rotate the prekeys.");
if (buffer_compare(store->deprecated_prekeys->public_key, public_prekey) != 0) {
throw(GENERIC_ERROR, "Failed to deprecate outdated key.");
}
printf("Successfully deprecated outdated key!\n");
//test the automatic removal of old deprecated keys!
if (buffer_clone(public_prekey, store->deprecated_prekeys->next->public_key) != 0) {
throw(BUFFER_ERROR, "Failed to clone public key.");
}
store->deprecated_prekeys->next->expiration_date -= 24 * 3600;
store->oldest_deprecated_expiration_date = store->deprecated_prekeys->next->expiration_date;
status = prekey_store_rotate(store);
throw_on_error(GENERIC_ERROR, "Failed to rotate the prekeys.");
if (store->deprecated_prekeys->next != NULL) {
throw(GENERIC_ERROR, "Failed to remove outdated key.");
}
printf("Successfully removed outdated deprecated key!\n");
status = protobuf_no_deprecated_keys();
throw_on_error(GENERIC_ERROR, "Failed to im-/export a prekey store without deprecated prekeys.");
cleanup:
buffer_destroy_from_heap_and_null_if_valid(public_prekey);
buffer_destroy_from_heap_and_null_if_valid(private_prekey1);
buffer_destroy_from_heap_and_null_if_valid(private_prekey2);
buffer_destroy_from_heap_and_null_if_valid(prekey_list);
prekey_store_destroy(store);
if (protobuf_export_prekeys != NULL) {
for (size_t i = 0; i < protobuf_export_prekeys_size; i++) {
if (protobuf_export_prekeys[i] != NULL) {
prekey__free_unpacked(protobuf_export_prekeys[i], &protobuf_c_allocators);
protobuf_export_prekeys[i] = NULL;
}
}
zeroed_free_and_null_if_valid(protobuf_export_prekeys);
}
if (protobuf_export_deprecated_prekeys != NULL) {
for (size_t i = 0; i < protobuf_export_deprecated_prekeys_size; i++) {
if (protobuf_export_deprecated_prekeys[i] != NULL) {
prekey__free_unpacked(protobuf_export_deprecated_prekeys[i], &protobuf_c_allocators);
protobuf_export_deprecated_prekeys[i] = NULL;
}
}
zeroed_free_and_null_if_valid(protobuf_export_deprecated_prekeys);
}
if (protobuf_export_prekeys_buffers != NULL) {
for (size_t i = 0; i < protobuf_export_prekeys_size; i++) {
buffer_destroy_from_heap_and_null_if_valid(protobuf_export_prekeys_buffers[i]);
}
zeroed_free_and_null_if_valid(protobuf_export_prekeys_buffers);
}
if (protobuf_export_deprecated_prekeys_buffers != NULL) {
for (size_t i = 0; i < protobuf_export_deprecated_prekeys_size; i++) {
buffer_destroy_from_heap_and_null_if_valid(protobuf_export_deprecated_prekeys_buffers[i]);
}
zeroed_free_and_null_if_valid(protobuf_export_deprecated_prekeys_buffers);
}
if (protobuf_second_export_prekeys != NULL) {
for (size_t i = 0; i < protobuf_second_export_prekeys_size; i++) {
if (protobuf_second_export_prekeys[i] != NULL) {
prekey__free_unpacked(protobuf_second_export_prekeys[i], &protobuf_c_allocators);
protobuf_second_export_prekeys[i] = NULL;
}
}
zeroed_free_and_null_if_valid(protobuf_second_export_prekeys);
}
if (protobuf_second_export_deprecated_prekeys != NULL) {
for (size_t i = 0; i < protobuf_second_export_deprecated_prekeys_size; i++) {
if (protobuf_second_export_deprecated_prekeys[i] != NULL) {
prekey__free_unpacked(protobuf_second_export_deprecated_prekeys[i], &protobuf_c_allocators);
protobuf_second_export_deprecated_prekeys[i] = NULL;
}
}
zeroed_free_and_null_if_valid(protobuf_second_export_deprecated_prekeys);
}
if (protobuf_second_export_prekeys_buffers != NULL) {
for (size_t i = 0; i < protobuf_second_export_prekeys_size; i++) {
buffer_destroy_from_heap_and_null_if_valid(protobuf_second_export_prekeys_buffers[i]);
}
zeroed_free_and_null_if_valid(protobuf_second_export_prekeys_buffers);
}
if (protobuf_second_export_deprecated_prekeys_buffers != NULL) {
for (size_t i = 0; i < protobuf_second_export_deprecated_prekeys_size; i++) {
buffer_destroy_from_heap_and_null_if_valid(protobuf_second_export_deprecated_prekeys_buffers[i]);
}
zeroed_free_and_null_if_valid(protobuf_second_export_deprecated_prekeys_buffers);
}
on_error {
print_errors(&status);
}
return_status_destroy_errors(&status);
return status.status;
}
winsock_init(bool allow_throw = true)
{
startup(data_, Major, Minor);
if (allow_throw)
throw_on_error(data_);
}
float grad_check(int T, int alphabet_size,
std::vector<float>& acts,
const std::vector<std::vector<int>>& labels,
const std::vector<int>& sizes) {
float epsilon = 1e-2;
const int minibatch = labels.size();
std::vector<int> flat_labels;
std::vector<int> label_lengths;
for (const auto& l : labels) {
flat_labels.insert(flat_labels.end(), l.begin(), l.end());
label_lengths.push_back(l.size());
}
std::vector<float> costs(minibatch);
std::vector<float> grads(acts.size());
ctcComputeInfo info;
info.loc = CTC_CPU;
info.num_threads = 1;
size_t cpu_alloc_bytes;
throw_on_error(get_workspace_size(label_lengths.data(), sizes.data(),
alphabet_size, sizes.size(), info,
&cpu_alloc_bytes),
"Error: get_workspace_size in grad_check");
void* ctc_cpu_workspace = malloc(cpu_alloc_bytes);
throw_on_error(compute_ctc_loss(acts.data(), grads.data(),
flat_labels.data(), label_lengths.data(),
sizes.data(),
alphabet_size,
minibatch,
costs.data(),
ctc_cpu_workspace,
info),
"Error: compute_ctc_loss (0) in grad_check");
float cost = std::accumulate(costs.begin(), costs.end(), 0.);
std::vector<float> num_grad(grads.size());
//perform 2nd order central differencing
for (int i = 0; i < T * alphabet_size * minibatch; ++i) {
std::vector<float> costsP1(minibatch);
std::vector<float> costsP2(minibatch);
acts[i] += epsilon;
throw_on_error(compute_ctc_loss(acts.data(), NULL,
flat_labels.data(), label_lengths.data(),
sizes.data(),
alphabet_size,
minibatch,
costsP1.data(),
ctc_cpu_workspace,
info),
"Error: compute_ctc_loss (1) in grad_check");
acts[i] -= 2 * epsilon;
throw_on_error(compute_ctc_loss(acts.data(), NULL,
flat_labels.data(), label_lengths.data(),
sizes.data(),
alphabet_size,
minibatch,
costsP2.data(),
ctc_cpu_workspace,
info),
"Error: compute_ctc_loss (2) in grad_check");
float costP1 = std::accumulate(costsP1.begin(), costsP1.end(), 0.);
float costP2 = std::accumulate(costsP2.begin(), costsP2.end(), 0.);
acts[i] += epsilon;
num_grad[i] = (costP1 - costP2) / (2 * epsilon);
}
free(ctc_cpu_workspace);
float diff = rel_diff(grads, num_grad);
return diff;
}
winsock_init(const winsock_init&)
{
startup(data_, Major, Minor);
throw_on_error(data_);
}
return_status protobuf_import(
prekey_store ** const store,
buffer_t ** const keypair_buffers,
const size_t keypair_buffers_size,
buffer_t ** const deprecated_keypair_buffers,
const size_t deprecated_keypair_buffers_size) {
return_status status = return_status_init();
Prekey ** keypairs = NULL;
Prekey ** deprecated_keypairs = NULL;
keypairs = zeroed_malloc(keypair_buffers_size * sizeof(Prekey*));
throw_on_failed_alloc(keypairs);
memset(keypairs, '\0', keypair_buffers_size * sizeof(Prekey*));
deprecated_keypairs = zeroed_malloc(deprecated_keypair_buffers_size * sizeof(Prekey*));
memset(deprecated_keypairs, '\0', deprecated_keypair_buffers_size * sizeof(Prekey*));
throw_on_failed_alloc(deprecated_keypairs);
//parse the normal prekey protobufs
for (size_t i = 0; i < keypair_buffers_size; i++) {
keypairs[i] = prekey__unpack(
&protobuf_c_allocators,
keypair_buffers[i]->content_length,
keypair_buffers[i]->content);
if (keypairs[i] == NULL) {
throw(PROTOBUF_UNPACK_ERROR, "Failed to unpack prekey from protobuf.");
}
}
//parse the deprecated prekey protobufs
for (size_t i = 0; i < deprecated_keypair_buffers_size; i++) {
deprecated_keypairs[i] = prekey__unpack(
&protobuf_c_allocators,
deprecated_keypair_buffers[i]->content_length,
deprecated_keypair_buffers[i]->content);
if (deprecated_keypairs[i] == NULL) {
throw(PROTOBUF_UNPACK_ERROR, "Failed to unpack deprecated prekey from protobuf.");
}
}
//now do the import
status = prekey_store_import(
store,
keypairs,
keypair_buffers_size,
deprecated_keypairs,
deprecated_keypair_buffers_size);
throw_on_error(IMPORT_ERROR, "Failed to import prekeys.");
cleanup:
if (keypairs != NULL) {
for (size_t i = 0; i < keypair_buffers_size; i++) {
prekey__free_unpacked(keypairs[i], &protobuf_c_allocators);
keypairs[i] = NULL;
}
zeroed_free_and_null_if_valid(keypairs);
}
if (deprecated_keypairs != NULL) {
for (size_t i = 0; i < deprecated_keypair_buffers_size; i++) {
prekey__free_unpacked(deprecated_keypairs[i], &protobuf_c_allocators);
deprecated_keypairs[i] = NULL;
}
zeroed_free_and_null_if_valid(deprecated_keypairs);
}
return status;
}
