Datasets:
aandvalenzuela
/
RRTcodebaseC

Dataset card Data Studio Files
xet
 Community
1
text
stringlengths
0
357
}
clock_t start = clock();
pgp_memory_t* outmem = pgp_encrypt_buf(&s_io, signed_text, signed_bytes, public_keys, use_armor, NULL/*cipher*/, encrypt_raw_packet);
encrypt_clocks = clock()-start;
dc_log_info(context, 0, "Message signed in %.3f ms and encrypted in %.3f ms.", (double)(sign_clocks)*1000.0/CLOCKS_PER_SEC, (double)(encrypt_clocks)*1000.0/CLOCKS_PER_SEC);
if (outmem==NULL) {
dc_log_warning(context, 0, "Encryption failed.");
goto cleanup;
}
*ret_ctext = outmem->buf;
*ret_ctext_bytes = outmem->length;
free(outmem); /* do not use pgp_memory_free() as we took ownership of the buffer */
}
success = 1;
cleanup:
if (keysmem) { pgp_memory_free(keysmem); }
if (signedmem) { pgp_memory_free(signedmem); }
if (public_keys) { pgp_keyring_purge(public_keys); free(public_keys); } /*pgp_keyring_free() frees the content, not the pointer itself*/
if (private_keys) { pgp_keyring_purge(private_keys); free(private_keys); }
if (dummy_keys) { pgp_keyring_purge(dummy_keys); free(dummy_keys); }
return success;
}
#endif // !DC_USE_RPGP
#ifdef DC_USE_RPGP
int dc_pgp_pk_decrypt( dc_context_t* context,
const void* ctext,
size_t ctext_bytes,
const dc_keyring_t* raw_private_keys_for_decryption,
const dc_keyring_t* raw_public_keys_for_validation,
int use_armor,
void** ret_plain,
size_t* ret_plain_bytes,
dc_hash_t* ret_signature_fingerprints)
{
int i = 0;
int success = 0;
rpgp_message* encrypted = NULL;
rpgp_message_decrypt_result* decrypted = NULL;
int private_keys_len = 0;
int public_keys_len = 0;
rpgp_signed_secret_key* *private_keys = NULL;
rpgp_signed_public_key* *public_keys = NULL;
if (context==NULL || ctext==NULL || ctext_bytes==0 || ret_plain==NULL
|| ret_plain_bytes==NULL || raw_private_keys_for_decryption==NULL
|| raw_private_keys_for_decryption->count<=0
|| use_armor==0 /* only support use_armor=1 */) {
goto cleanup;
}
*ret_plain = NULL;
*ret_plain_bytes = 0;
private_keys_len = raw_private_keys_for_decryption->count;
private_keys = malloc(sizeof(rpgp_signed_secret_key*) * private_keys_len);
if (raw_public_keys_for_validation) {
public_keys_len = raw_public_keys_for_validation->count;
public_keys = malloc(sizeof(rpgp_signed_public_key*) * public_keys_len);
}
/* setup secret keys for decryption */
for (i = 0; i < raw_private_keys_for_decryption->count; i++) {
private_keys[i] = rpgp_skey_from_bytes(raw_private_keys_for_decryption->keys[i]->binary,
raw_private_keys_for_decryption->keys[i]->bytes);
if (dc_pgp_handle_rpgp_error(context)) {
goto cleanup;
}
}
/* setup public keys for validation */
if (raw_public_keys_for_validation) {
for (i = 0; i < raw_public_keys_for_validation->count; i++) {
public_keys[i] = rpgp_pkey_from_bytes(raw_public_keys_for_validation->keys[i]->binary,
raw_public_keys_for_validation->keys[i]->bytes);
if (dc_pgp_handle_rpgp_error(context)) {
goto cleanup;
}
}
}
/* decrypt */
{
encrypted = rpgp_msg_from_armor(ctext, ctext_bytes);
if (dc_pgp_handle_rpgp_error(context)) {
goto cleanup;
}
decrypted = rpgp_msg_decrypt_no_pw(encrypted,
(const rpgp_signed_secret_key* const*)private_keys, private_keys_len,