int ratchet_identity_key_pair_serialize(signal_buffer **buffer, const ratchet_identity_key_pair *key_pair)
{
int result = 0;
size_t result_size = 0;
signal_buffer *result_buf = 0;
Textsecure__IdentityKeyPairStructure key_structure = TEXTSECURE__IDENTITY_KEY_PAIR_STRUCTURE__INIT;
size_t len = 0;
uint8_t *data = 0;
if(!key_pair) {
result = SG_ERR_INVAL;
goto complete;
}
result = ec_public_key_serialize_protobuf(&key_structure.publickey, key_pair->public_key);
if(result < 0) {
goto complete;
}
key_structure.has_publickey = 1;
result = ec_private_key_serialize_protobuf(&key_structure.privatekey, key_pair->private_key);
if(result < 0) {
goto complete;
}
key_structure.has_privatekey = 1;
len = textsecure__identity_key_pair_structure__get_packed_size(&key_structure);
result_buf = signal_buffer_alloc(len);
if(!result_buf) {
result = SG_ERR_NOMEM;
goto complete;
}
data = signal_buffer_data(result_buf);
result_size = textsecure__identity_key_pair_structure__pack(&key_structure, data);
if(result_size != len) {
signal_buffer_free(result_buf);
result = SG_ERR_INVALID_PROTO_BUF;
result_buf = 0;
goto complete;
}
complete:
if(key_structure.has_publickey) {
free(key_structure.publickey.data);
}
if(key_structure.has_privatekey) {
free(key_structure.privatekey.data);
}
if(result >= 0) {
result = 0;
*buffer = result_buf;
}
return result;
}
int ratchet_chain_key_get_key(const ratchet_chain_key *chain_key, signal_buffer **buffer)
{
signal_buffer *buf = 0;
uint8_t *data = 0;
buf = signal_buffer_alloc(chain_key->key_len);
if(!buf) {
return SG_ERR_NOMEM;
}
data = signal_buffer_data(buf);
memcpy(data, chain_key->key, chain_key->key_len);
*buffer = buf;
return 0;
}
int ratchet_root_key_get_key(ratchet_root_key *root_key, signal_buffer **buffer)
{
signal_buffer *buf = 0;
uint8_t *data = 0;
assert(root_key);
buf = signal_buffer_alloc(root_key->key_len);
if(!buf) {
return SG_ERR_NOMEM;
}
data = signal_buffer_data(buf);
memcpy(data, root_key->key, root_key->key_len);
*buffer = buf;
return 0;
}
int scannable_fingerprint_serialize(signal_buffer **buffer, const scannable_fingerprint *scannable)
{
int result = 0;
size_t result_size = 0;
signal_buffer *result_buf = 0;
Textsecure__CombinedFingerprint combined_fingerprint = TEXTSECURE__COMBINED_FINGERPRINT__INIT;
Textsecure__FingerprintData local_fingerprint = TEXTSECURE__FINGERPRINT_DATA__INIT;
Textsecure__FingerprintData remote_fingerprint = TEXTSECURE__FINGERPRINT_DATA__INIT;
size_t len = 0;
uint8_t *data = 0;
combined_fingerprint.version = scannable->version;
combined_fingerprint.has_version = 1;
if(scannable->local_stable_identifier && scannable->local_identity_key) {
signal_protocol_str_serialize_protobuf(&local_fingerprint.identifier, scannable->local_stable_identifier);
local_fingerprint.has_identifier = 1;
result = ec_public_key_serialize_protobuf(&local_fingerprint.publickey, scannable->local_identity_key);
if(result < 0) {
goto complete;
}
local_fingerprint.has_publickey = 1;
combined_fingerprint.localfingerprint = &local_fingerprint;
}
if(scannable->remote_stable_identifier && scannable->remote_identity_key) {
signal_protocol_str_serialize_protobuf(&remote_fingerprint.identifier, scannable->remote_stable_identifier);
remote_fingerprint.has_identifier = 1;
result = ec_public_key_serialize_protobuf(&remote_fingerprint.publickey, scannable->remote_identity_key);
if(result < 0) {
goto complete;
}
remote_fingerprint.has_publickey = 1;
combined_fingerprint.remotefingerprint = &remote_fingerprint;
}
len = textsecure__combined_fingerprint__get_packed_size(&combined_fingerprint);
result_buf = signal_buffer_alloc(len);
if(!result_buf) {
result = SG_ERR_NOMEM;
goto complete;
}
data = signal_buffer_data(result_buf);
result_size = textsecure__combined_fingerprint__pack(&combined_fingerprint, data);
if(result_size != len) {
signal_buffer_free(result_buf);
result = SG_ERR_INVALID_PROTO_BUF;
result_buf = 0;
goto complete;
}
complete:
if(local_fingerprint.publickey.data) {
free(local_fingerprint.publickey.data);
}
if(remote_fingerprint.publickey.data) {
free(remote_fingerprint.publickey.data);
}
if(result >= 0) {
*buffer = result_buf;
}
return result;
}
int fingerprint_generator_create_display_string(fingerprint_generator *generator, char **display_string,
const char *stable_identifier, ec_public_key *identity_key)
{
int result = 0;
char *result_string = 0;
signal_buffer *identity_buffer = 0;
signal_buffer *hash_buffer = 0;
signal_buffer *hash_in_buffer = 0;
signal_buffer *hash_out_buffer = 0;
uint8_t *data = 0;
size_t len = 0;
uint8_t *in_data = 0;
size_t in_len = 0;
int i = 0;
assert(generator);
assert(stable_identifier);
assert(identity_key);
assert(generator->global_context->crypto_provider.sha512_digest_func);
result = ec_public_key_serialize(&identity_buffer, identity_key);
if(result < 0) {
goto complete;
}
len = 2 + signal_buffer_len(identity_buffer) + strlen(stable_identifier);
hash_buffer = signal_buffer_alloc(len);
if(!hash_buffer) {
result = SG_ERR_NOMEM;
goto complete;
}
data = signal_buffer_data(hash_buffer);
memset(data, 0, len);
data[0] = 0;
data[1] = (uint8_t)VERSION;
memcpy(data + 2, signal_buffer_data(identity_buffer), signal_buffer_len(identity_buffer));
memcpy(data + 2 + signal_buffer_len(identity_buffer), stable_identifier, strlen(stable_identifier));
hash_in_buffer = signal_buffer_alloc(MAX(len, SHA512_DIGEST_LENGTH) + signal_buffer_len(identity_buffer));
if(!hash_in_buffer) {
result = SG_ERR_NOMEM;
goto complete;
}
in_data = signal_buffer_data(hash_in_buffer);
in_len = len + signal_buffer_len(identity_buffer);
for(i = 0; i < generator->iterations; i++) {
data = signal_buffer_data(hash_buffer);
len = signal_buffer_len(hash_buffer);
in_len = signal_buffer_len(hash_buffer) + signal_buffer_len(identity_buffer);
memcpy(in_data, data, len);
memcpy(in_data + len,
signal_buffer_data(identity_buffer),
signal_buffer_len(identity_buffer));
result = signal_sha512_digest(generator->global_context,
&hash_out_buffer, in_data, in_len);
if(result < 0) {
goto complete;
}
if(signal_buffer_len(hash_out_buffer) != SHA512_DIGEST_LENGTH) {
result = SG_ERR_INVAL;
goto complete;
}
signal_buffer_free(hash_buffer);
hash_buffer = hash_out_buffer;
hash_out_buffer = 0;
}
data = signal_buffer_data(hash_buffer);
len = signal_buffer_len(hash_buffer);
if(len < 30) {
result = SG_ERR_UNKNOWN;
goto complete;
}
result_string = malloc(31);
if(!result_string) {
result = SG_ERR_NOMEM;
goto complete;
}
for(i = 0; i < 30; i += 5) {
uint64_t chunk = ((uint64_t)data[i] & 0xFFL) << 32 |
((uint64_t)data[i + 1] & 0xFFL) << 24 |
((uint64_t)data[i + 2] & 0xFFL) << 16 |
((uint64_t)data[i + 3] & 0xFFL) << 8 |
((uint64_t)data[i + 4] & 0xFFL);
#if _WINDOWS
sprintf_s(result_string + i, 6, "%05d", (int)(chunk % 100000));
#else
snprintf(result_string + i, 6, "%05d", (int)(chunk % 100000));
#endif
}
complete:
signal_buffer_free(identity_buffer);
signal_buffer_free(hash_buffer);
signal_buffer_free(hash_in_buffer);
signal_buffer_free(hash_out_buffer);
if(result >= 0) {
*display_string = result_string;
}
return result;
}
int device_consistency_message_create_from_pair(device_consistency_message **message,
device_consistency_commitment *commitment,
ec_key_pair *identity_key_pair,
signal_context *global_context)
{
int result = 0;
device_consistency_message *result_message = 0;
signal_buffer *commitment_buffer = 0;
signal_buffer *signature_buffer = 0;
signal_buffer *vrf_output_buffer = 0;
signal_buffer *serialized_signature_buffer = 0;
Textsecure__DeviceConsistencyCodeMessage message_structure = TEXTSECURE__DEVICE_CONSISTENCY_CODE_MESSAGE__INIT;
size_t len = 0;
uint8_t *data = 0;
size_t result_size = 0;
/* Create message instance */
result = device_consistency_message_create(&result_message);
if(result < 0) {
goto complete;
}
/* Calculate VRF signature */
commitment_buffer = device_consistency_commitment_get_serialized(commitment);
result = curve_calculate_vrf_signature(global_context, &signature_buffer,
ec_key_pair_get_private(identity_key_pair),
signal_buffer_data(commitment_buffer), signal_buffer_len(commitment_buffer));
if(result < 0) {
goto complete;
}
/* Verify VRF signature */
result = curve_verify_vrf_signature(global_context, &vrf_output_buffer,
ec_key_pair_get_public(identity_key_pair),
signal_buffer_data(commitment_buffer), signal_buffer_len(commitment_buffer),
signal_buffer_data(signature_buffer), signal_buffer_len(signature_buffer));
if(result < 0) {
goto complete;
}
result_message->generation = device_consistency_commitment_get_generation(commitment);
/* Create and assign the signature */
result = device_consistency_signature_create(&result_message->signature,
signal_buffer_data(signature_buffer), signal_buffer_len(signature_buffer),
signal_buffer_data(vrf_output_buffer), signal_buffer_len(vrf_output_buffer));
if(result < 0) {
goto complete;
}
serialized_signature_buffer = device_consistency_signature_get_signature(result_message->signature);
/* Serialize the message */
message_structure.generation = device_consistency_commitment_get_generation(commitment);
message_structure.has_generation = 1;
message_structure.signature.data = signal_buffer_data(serialized_signature_buffer);
message_structure.signature.len = signal_buffer_len(serialized_signature_buffer);
message_structure.has_signature = 1;
len = textsecure__device_consistency_code_message__get_packed_size(&message_structure);
result_message->serialized = signal_buffer_alloc(len);
if(!result_message->serialized) {
result = SG_ERR_NOMEM;
goto complete;
}
data = signal_buffer_data(result_message->serialized);
result_size = textsecure__device_consistency_code_message__pack(&message_structure, data);
if(result_size != len) {
result = SG_ERR_INVALID_PROTO_BUF;
goto complete;
}
complete:
signal_buffer_free(signature_buffer);
signal_buffer_free(vrf_output_buffer);
if(result >= 0) {
*message = result_message;
}
else {
SIGNAL_UNREF(result_message);
}
if(result == SG_ERR_INVALID_KEY || result == SG_ERR_VRF_SIG_VERIF_FAILED) {
result = SG_ERR_UNKNOWN;
}
return result;
}
