int device_consistency_commitment_create(device_consistency_commitment **commitment,
uint32_t generation, ec_public_key_list *identity_key_list,
signal_context *global_context)
{
static const char version[] = "DeviceConsistencyCommitment_V0";
int result = 0;
void *digest_context = 0;
device_consistency_commitment *result_commitment = 0;
ec_public_key_list *sorted_list = 0;
uint8_t gen_data[4];
unsigned int list_size;
unsigned int i;
result_commitment = malloc(sizeof(device_consistency_commitment));
if(!result_commitment) {
result = SG_ERR_NOMEM;
goto complete;
}
memset(result_commitment, 0, sizeof(device_consistency_commitment));
SIGNAL_INIT(result_commitment, device_consistency_commitment_destroy);
sorted_list = ec_public_key_list_copy(identity_key_list);
if(!sorted_list) {
result = SG_ERR_NOMEM;
goto complete;
}
ec_public_key_list_sort(sorted_list);
result = signal_sha512_digest_init(global_context, &digest_context);
if(result < 0) {
goto complete;
}
result = signal_sha512_digest_update(global_context, digest_context,
(uint8_t *)version, sizeof(version) - 1);
if(result < 0) {
goto complete;
}
gen_data[3] = (uint8_t)(generation);
gen_data[2] = (uint8_t)(generation >> 8);
gen_data[1] = (uint8_t)(generation >> 16);
gen_data[0] = (uint8_t)(generation >> 24);
result = signal_sha512_digest_update(global_context, digest_context,
gen_data, sizeof(gen_data));
if(result < 0) {
goto complete;
}
list_size = ec_public_key_list_size(sorted_list);
for(i = 0; i < list_size; i++) {
signal_buffer *key_buffer = 0;
ec_public_key *key = ec_public_key_list_at(sorted_list, i);
result = ec_public_key_serialize(&key_buffer, key);
if(result < 0) {
goto complete;
}
result = signal_sha512_digest_update(global_context, digest_context,
signal_buffer_data(key_buffer), signal_buffer_len(key_buffer));
signal_buffer_free(key_buffer);
if(result < 0) {
goto complete;
}
}
result_commitment->generation = generation;
result = signal_sha512_digest_final(global_context, digest_context, &result_commitment->serialized);
complete:
if(sorted_list) {
ec_public_key_list_free(sorted_list);
}
if(digest_context) {
signal_sha512_digest_cleanup(global_context, digest_context);
}
if(result >= 0) {
*commitment = result_commitment;
}
else {
SIGNAL_UNREF(result_commitment);
}
return result;
}
int device_consistency_code_generate_for(device_consistency_commitment *commitment,
device_consistency_signature_list *signatures,
char **code_string,
signal_context *global_context)
{
int result = 0;
char *result_string = 0;
void *digest_context = 0;
device_consistency_signature_list *sorted_list = 0;
uint8_t version_data[2];
signal_buffer *commitment_buffer;
unsigned int list_size;
unsigned int i;
signal_buffer *hash_buffer = 0;
uint8_t *data = 0;
size_t len = 0;
char *encoded_string = 0;
sorted_list = device_consistency_signature_list_copy(signatures);
if(!sorted_list) {
result = SG_ERR_NOMEM;
goto complete;
}
device_consistency_signature_list_sort(sorted_list);
result = signal_sha512_digest_init(global_context, &digest_context);
if(result < 0) {
goto complete;
}
version_data[1] = (uint8_t)(CODE_VERSION);
version_data[0] = (uint8_t)(CODE_VERSION >> 8);
result = signal_sha512_digest_update(global_context, digest_context,
version_data, sizeof(version_data));
if(result < 0) {
goto complete;
}
commitment_buffer = device_consistency_commitment_get_serialized(commitment);
result = signal_sha512_digest_update(global_context, digest_context,
signal_buffer_data(commitment_buffer),
signal_buffer_len(commitment_buffer));
if(result < 0) {
goto complete;
}
list_size = device_consistency_signature_list_size(sorted_list);
for(i = 0; i < list_size; i++) {
device_consistency_signature *signature = device_consistency_signature_list_at(sorted_list, i);
signal_buffer *vrf_output = device_consistency_signature_get_vrf_output(signature);
result = signal_sha512_digest_update(global_context, digest_context,
signal_buffer_data(vrf_output),
signal_buffer_len(vrf_output));
if(result < 0) {
goto complete;
}
}
result = signal_sha512_digest_final(global_context, digest_context, &hash_buffer);
if(result < 0) {
goto complete;
}
data = signal_buffer_data(hash_buffer);
len = signal_buffer_len(hash_buffer);
if(len < 10) {
result = SG_ERR_UNKNOWN;
goto complete;
}
encoded_string = malloc(11);
if(!encoded_string) {
result = SG_ERR_NOMEM;
goto complete;
}
for(i = 0; i < 10; 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(encoded_string + i, 6, "%05d", (int)(chunk % 100000));
#else
snprintf(encoded_string + i, 6, "%05d", (int)(chunk % 100000));
#endif
}
result_string = malloc(7);
if(!result_string) {
result = SG_ERR_NOMEM;
goto complete;
}
memcpy(result_string, encoded_string, 6);
result_string[6] = '\0';
complete:
if(sorted_list) {
device_consistency_signature_list_free(sorted_list);
}
if(digest_context) {
signal_sha512_digest_cleanup(global_context, digest_context);
}
signal_buffer_free(hash_buffer);
free(encoded_string);
if(result >= 0) {
*code_string = result_string;
}
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;
void *digest_context = 0;
signal_buffer *identity_buffer = 0;
signal_buffer *hash_buffer = 0;
signal_buffer *hash_out_buffer = 0;
uint8_t *data = 0;
size_t len = 0;
int i = 0;
assert(generator);
assert(stable_identifier);
assert(identity_key);
result = signal_sha512_digest_init(generator->global_context, &digest_context);
if(result < 0) {
goto complete;
}
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));
for(i = 0; i < generator->iterations; i++) {
data = signal_buffer_data(hash_buffer);
len = signal_buffer_len(hash_buffer);
result = signal_sha512_digest_update(generator->global_context,
digest_context, data, len);
if(result < 0) {
goto complete;
}
result = signal_sha512_digest_update(generator->global_context,
digest_context,
signal_buffer_data(identity_buffer),
signal_buffer_len(identity_buffer));
if(result < 0) {
goto complete;
}
result = signal_sha512_digest_final(generator->global_context,
digest_context, &hash_out_buffer);
if(result < 0) {
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:
if(digest_context) {
signal_sha512_digest_cleanup(generator->global_context, digest_context);
}
signal_buffer_free(identity_buffer);
signal_buffer_free(hash_buffer);
signal_buffer_free(hash_out_buffer);
if(result >= 0) {
*display_string = result_string;
}
return result;
}
