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