static corto_int16 json_deserCollection(void* p, corto_type t, JSON_Value *v)
{
corto_assert(t->kind == CORTO_COLLECTION, "not deserializing composite");
corto_type elementType = corto_collection(t)->elementType;
/* Deserialize elements */
JSON_Array* a = json_value_get_array(v);
if (!a) {
corto_seterr("invalid array");
goto error;
}
size_t count = json_array_get_count(a);
size_t i;
for (i = 0; i < count; i++) {
void *elementPtr = json_deser_allocElem(p, corto_collection(t), i);
JSON_Value *elem = json_array_get_value(a, i);
if (json_deserType(elementPtr, elementType, elem)) {
goto error;
}
}
return 0;
error:
return -1;
}
static EJSBool
json_value_to_ejsval(JSON_Value *v, ejsval *rv)
{
switch (json_value_get_type (v)) {
case JSONNull:
*rv = _ejs_null;
return EJS_TRUE;
case JSONString:
*rv = _ejs_string_new_utf8 (json_value_get_string(v));
return EJS_TRUE;
case JSONNumber:
*rv = NUMBER_TO_EJSVAL(json_value_get_number(v));
return EJS_TRUE;
case JSONObject: {
JSON_Object *obj = json_value_get_object (v);
*rv = _ejs_object_create (_ejs_null);
int count = json_object_get_count (obj);
for (int i = 0; i < count; i ++) {
const char *propkey = json_object_get_name (obj, i);
ejsval propval;
if (!json_value_to_ejsval (json_object_get_value (obj, propkey), &propval))
return EJS_FALSE;
_ejs_object_setprop_utf8 (*rv, propkey, propval);
}
return EJS_TRUE;
}
case JSONArray: {
JSON_Array *arr = json_value_get_array (v);
int count = json_array_get_count (arr);
*rv = _ejs_array_new (count, EJS_FALSE);
for (int i = 0; i < count; i ++) {
ejsval propkey = _ejs_number_new (i);
ejsval propval;
if (!json_value_to_ejsval (json_array_get_value (arr, i), &propval))
return EJS_FALSE;
_ejs_object_setprop (*rv, propkey, propval);
}
return EJS_TRUE;
}
case JSONBoolean:
*rv = BOOLEAN_TO_EJSVAL(json_value_get_boolean(v));
return EJS_TRUE;
case JSONError:
EJS_NOT_IMPLEMENTED();
return EJS_FALSE;
}
}
static void GenStat(Stat* s, JSON_Value* v) {
switch (json_value_get_type(v)) {
case JSONObject:
{
JSON_Object* o = json_value_get_object(v);
size_t count = json_object_get_count(o);
for (size_t i = 0; i < count; i++) {
const char* name = json_object_get_name(o, i);
GenStat(s, json_object_get_value(o, name));
s->stringLength += strlen(name);
}
s->objectCount++;
s->memberCount += count;
s->stringCount += count;
}
break;
case JSONArray:
{
JSON_Array* a = json_value_get_array(v);
size_t count = json_array_get_count(a);
for (int i = 0; i < count; i++)
GenStat(s, json_array_get_value(a, i));
s->arrayCount++;
s->elementCount += count;
}
break;
case JSONString:
s->stringCount++;
s->stringLength += strlen(json_value_get_string(v));
break;
case JSONNumber:
s->numberCount++;
break;
case JSONBoolean:
if (json_value_get_boolean(v))
s->trueCount++;
else
s->falseCount++;
break;
case JSONNull:
s->nullCount++;
break;
}
}
bud_error_t bud_config_verify_npn(const JSON_Array* npn) {
int i;
int npn_count;
if (npn == NULL)
return bud_ok();
npn_count = json_array_get_count(npn);
for (i = 0; i < npn_count; i++) {
if (json_value_get_type(json_array_get_value(npn, i)) == JSONString)
continue;
return bud_error(kBudErrNPNNonString);
}
return bud_ok();
}
static mrb_value
json_value_to_mrb_value(mrb_state* mrb, JSON_Value* value) {
ARENA_SAVE;
switch (json_value_get_type(value)) {
case JSONError:
case JSONNull:
return mrb_nil_value();
case JSONString:
return mrb_str_new_cstr(mrb, json_value_get_string(value));
case JSONNumber:
return mrb_float_value(json_value_get_number(value));
case JSONObject:
{
mrb_value hash = mrb_hash_new(mrb);
JSON_Object* object = json_value_get_object(value);
size_t count = json_object_get_count(object);
int n;
for (n = 0; n < count; n++) {
const char* name = json_object_get_name(object, n);
mrb_hash_set(mrb, hash, mrb_str_new_cstr(mrb, name),
json_value_to_mrb_value(mrb, json_object_get_value(object, name)));
}
return hash;
}
case JSONArray:
{
mrb_value ary;
ary = mrb_ary_new(mrb);
JSON_Array* array = json_value_get_array(value);
size_t count = json_array_get_count(array);
int n;
for (n = 0; n < count; n++) {
JSON_Value* elem = json_array_get_value(array, n);
mrb_ary_push(mrb, ary, json_value_to_mrb_value(mrb, elem));
}
return ary;
}
case JSONBoolean:
if (json_value_get_boolean(value)) {
return mrb_true_value();
}
return mrb_false_value();
default:
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
return mrb_nil_value();
}
bud_error_t bud_config_verify_all_strings(const JSON_Array* arr,
const char* name) {
int i;
int count;
if (arr == NULL)
return bud_ok();
count = json_array_get_count(arr);
for (i = 0; i < count; i++) {
if (json_value_get_type(json_array_get_value(arr, i)) == JSONString)
continue;
return bud_error_dstr(kBudErrNonString, name);
}
return bud_ok();
}
ACVP_RESULT acvp_kdf135_ssh_kat_handler(ACVP_CTX *ctx, JSON_Object *obj) {
unsigned int tc_id;
JSON_Value *groupval;
JSON_Object *groupobj = NULL;
JSON_Value *testval;
JSON_Object *testobj = NULL;
JSON_Array *groups;
JSON_Array *tests;
JSON_Value *reg_arry_val = NULL;
JSON_Object *reg_obj = NULL;
JSON_Array *reg_arry = NULL;
int i, g_cnt;
int j, t_cnt;
JSON_Value *r_vs_val = NULL;
JSON_Object *r_vs = NULL;
JSON_Array *r_tarr = NULL, *r_garr = NULL; /* Response testarray, grouparray */
JSON_Value *r_tval = NULL, *r_gval = NULL; /* Response testval, groupval */
JSON_Object *r_tobj = NULL, *r_gobj = NULL; /* Response testobj, groupobj */
ACVP_CAPS_LIST *cap;
ACVP_KDF135_SSH_TC stc;
ACVP_TEST_CASE tc;
ACVP_RESULT rv;
ACVP_CIPHER alg_id;
const char *alg_str = NULL;
const char *mode_str = NULL;
const char *cipher_str = NULL;
const char *shared_secret_str = NULL;
const char *session_id_str = NULL;
const char *hash_str = NULL;
char *json_result;
if (!ctx) {
ACVP_LOG_ERR("No ctx for handler operation");
return ACVP_NO_CTX;
}
if (!obj) {
ACVP_LOG_ERR("No obj for handler operation");
return ACVP_MALFORMED_JSON;
}
alg_str = json_object_get_string(obj, "algorithm");
if (!alg_str) {
ACVP_LOG_ERR("unable to parse 'algorithm' from JSON");
return ACVP_MALFORMED_JSON;
}
mode_str = json_object_get_string(obj, "mode");
if (!mode_str) {
ACVP_LOG_ERR("unable to parse 'mode' from JSON");
return ACVP_MALFORMED_JSON;
}
alg_id = acvp_lookup_cipher_w_mode_index(alg_str, mode_str);
if (alg_id != ACVP_KDF135_SSH) {
ACVP_LOG_ERR("Server JSON invalid 'algorithm' or 'mode'");
return ACVP_INVALID_ARG;
}
/*
* Get a reference to the abstracted test case
*/
tc.tc.kdf135_ssh = &stc;
/*
* Get the crypto module handler for this hash algorithm
*/
cap = acvp_locate_cap_entry(ctx, alg_id);
if (!cap) {
ACVP_LOG_ERR("ACVP server requesting unsupported capability %s : %d.", alg_str, alg_id);
return ACVP_UNSUPPORTED_OP;
}
/*
* Create ACVP array for response
*/
rv = acvp_create_array(®_obj, ®_arry_val, ®_arry);
if (rv != ACVP_SUCCESS) {
ACVP_LOG_ERR("Failed to create JSON response struct. ");
return rv;
}
/*
* Start to build the JSON response
*/
rv = acvp_setup_json_rsp_group(&ctx, ®_arry_val, &r_vs_val, &r_vs, alg_str, &r_garr);
if (rv != ACVP_SUCCESS) {
ACVP_LOG_ERR("Failed to setup json response");
return rv;
}
groups = json_object_get_array(obj, "testGroups");
if (!groups) {
ACVP_LOG_ERR("Failed to include testGroups. ");
rv = ACVP_MISSING_ARG;
goto err;
}
g_cnt = json_array_get_count(groups);
for (i = 0; i < g_cnt; i++) {
int tgId = 0;
int diff = 1;
unsigned int e_key_len = 0, i_key_len = 0,
hash_len = 0, iv_len = 0;
ACVP_HASH_ALG sha_type = 0;
const char *sha_str = NULL;
groupval = json_array_get_value(groups, i);
groupobj = json_value_get_object(groupval);
/*
* Create a new group in the response with the tgid
* and an array of tests
*/
r_gval = json_value_init_object();
r_gobj = json_value_get_object(r_gval);
tgId = json_object_get_number(groupobj, "tgId");
if (!tgId) {
ACVP_LOG_ERR("Missing tgid from server JSON groub obj");
rv = ACVP_MALFORMED_JSON;
goto err;
}
json_object_set_number(r_gobj, "tgId", tgId);
json_object_set_value(r_gobj, "tests", json_value_init_array());
r_tarr = json_object_get_array(r_gobj, "tests");
// Get the expected (user will generate) key and iv lengths
cipher_str = json_object_get_string(groupobj, "cipher");
if (!cipher_str) {
ACVP_LOG_ERR("Failed to include cipher. ");
rv = ACVP_MISSING_ARG;
goto err;
}
sha_str = json_object_get_string(groupobj, "hashAlg");
if (!sha_str) {
ACVP_LOG_ERR("Failed to include hashAlg. ");
rv = ACVP_MISSING_ARG;
goto err;
}
sha_type = acvp_lookup_hash_alg(sha_str);
if (sha_type == ACVP_SHA1) {
i_key_len = hash_len = ACVP_SHA1_BYTE_LEN;
} else if (sha_type == ACVP_SHA224) {
i_key_len = hash_len = ACVP_SHA224_BYTE_LEN;
} else if (sha_type == ACVP_SHA256) {
i_key_len = hash_len = ACVP_SHA256_BYTE_LEN;
} else if (sha_type == ACVP_SHA384) {
i_key_len = hash_len = ACVP_SHA384_BYTE_LEN;
} else if (sha_type == ACVP_SHA512) {
i_key_len = hash_len = ACVP_SHA512_BYTE_LEN;
} else {
ACVP_LOG_ERR("ACVP server requesting invalid hashAlg");
rv = ACVP_NO_CAP;
goto err;
}
/*
* Determine the encrypt key_len, inferred from cipher.
*/
strcmp_s(ACVP_MODE_TDES, 4, cipher_str, &diff);
if (!diff) {
e_key_len = ACVP_KEY_LEN_TDES;
iv_len = ACVP_BLOCK_LEN_TDES;
}
strcmp_s(ACVP_MODE_AES_128, 7, cipher_str, &diff);
if (!diff) {
e_key_len = ACVP_KEY_LEN_AES128;
iv_len = ACVP_BLOCK_LEN_AES128;
}
strcmp_s(ACVP_MODE_AES_192, 7, cipher_str, &diff);
if (!diff) {
e_key_len = ACVP_KEY_LEN_AES192;
iv_len = ACVP_BLOCK_LEN_AES192;
}
strcmp_s(ACVP_MODE_AES_256, 7, cipher_str, &diff);
if (!diff) {
e_key_len = ACVP_KEY_LEN_AES256;
iv_len = ACVP_BLOCK_LEN_AES256;
}
if (!e_key_len || !iv_len) {
ACVP_LOG_ERR("Unsupported cipher type");
rv = ACVP_NO_CAP;
goto err;
}
/*
* Log Test Group information...
*/
ACVP_LOG_INFO(" Test group: %d", i);
ACVP_LOG_INFO(" cipher: %s", cipher_str);
ACVP_LOG_INFO(" hashAlg: %s", sha_str);
tests = json_object_get_array(groupobj, "tests");
if (!tests) {
ACVP_LOG_ERR("Failed to include tests. ");
rv = ACVP_MISSING_ARG;
goto err;
}
t_cnt = json_array_get_count(tests);
if (!t_cnt) {
ACVP_LOG_ERR("Failed to include tests in array. ");
rv = ACVP_MISSING_ARG;
goto err;
}
for (j = 0; j < t_cnt; j++) {
ACVP_LOG_INFO("Found new KDF SSH test vector...");
testval = json_array_get_value(tests, j);
testobj = json_value_get_object(testval);
tc_id = (unsigned int)json_object_get_number(testobj, "tcId");
if (!tc_id) {
ACVP_LOG_ERR("Failed to include tc_id. ");
rv = ACVP_MISSING_ARG;
goto err;
}
shared_secret_str = json_object_get_string(testobj, "k");
if (!shared_secret_str) {
ACVP_LOG_ERR("Failed to include k. ");
rv = ACVP_MISSING_ARG;
goto err;
}
hash_str = json_object_get_string(testobj, "h");
if (!hash_str) {
ACVP_LOG_ERR("Failed to include h. ");
rv = ACVP_MISSING_ARG;
goto err;
}
session_id_str = json_object_get_string(testobj, "sessionId");
if (!session_id_str) {
ACVP_LOG_ERR("Failed to include sessionId. ");
rv = ACVP_MISSING_ARG;
goto err;
}
ACVP_LOG_INFO(" Test case: %d", j);
ACVP_LOG_INFO(" tcId: %d", tc_id);
ACVP_LOG_INFO(" k: %s", shared_secret_str);
ACVP_LOG_INFO(" h: %s", hash_str);
ACVP_LOG_INFO(" session_id: %s", session_id_str);
/*
* Create a new test case in the response
*/
r_tval = json_value_init_object();
r_tobj = json_value_get_object(r_tval);
json_object_set_number(r_tobj, "tcId", tc_id);
/*
* Setup the test case data that will be passed down to
* the crypto module.
*/
rv = acvp_kdf135_ssh_init_tc(ctx, &stc, tc_id, alg_id,
sha_type, e_key_len, i_key_len, iv_len, hash_len,
shared_secret_str, hash_str, session_id_str);
if (rv != ACVP_SUCCESS) {
acvp_kdf135_ssh_release_tc(&stc);
json_value_free(r_tval);
goto err;
}
/* Process the current test vector... */
if ((cap->crypto_handler)(&tc)) {
ACVP_LOG_ERR("crypto module failed the KDF SSH operation");
acvp_kdf135_ssh_release_tc(&stc);
rv = ACVP_CRYPTO_MODULE_FAIL;
json_value_free(r_tval);
goto err;
}
/*
* Output the test case results using JSON
*/
rv = acvp_kdf135_ssh_output_tc(ctx, &stc, r_tobj);
if (rv != ACVP_SUCCESS) {
ACVP_LOG_ERR("JSON output failure in hash module");
acvp_kdf135_ssh_release_tc(&stc);
json_value_free(r_tval);
goto err;
}
/*
* Release all the memory associated with the test case
*/
acvp_kdf135_ssh_release_tc(&stc);
/* Append the test response value to array */
json_array_append_value(r_tarr, r_tval);
}
json_array_append_value(r_garr, r_gval);
}
json_array_append_value(reg_arry, r_vs_val);
json_result = json_serialize_to_string_pretty(ctx->kat_resp, NULL);
if (ctx->debug == ACVP_LOG_LVL_VERBOSE) {
printf("\n\n%s\n\n", json_result);
} else {
ACVP_LOG_INFO("\n\n%s\n\n", json_result);
}
json_free_serialized_string(json_result);
rv = ACVP_SUCCESS;
err:
if (rv != ACVP_SUCCESS) {
acvp_release_json(r_vs_val, r_gval);
}
return rv;
}
ACVP_RESULT acvp_kdf135_ikev1_kat_handler(ACVP_CTX *ctx, JSON_Object *obj) {
unsigned int tc_id;
JSON_Value *groupval;
JSON_Object *groupobj = NULL;
JSON_Value *testval;
JSON_Object *testobj = NULL;
JSON_Array *groups;
JSON_Array *tests;
JSON_Value *reg_arry_val = NULL;
JSON_Object *reg_obj = NULL;
JSON_Array *reg_arry = NULL;
int i, g_cnt;
int j, t_cnt;
JSON_Value *r_vs_val = NULL;
JSON_Object *r_vs = NULL;
JSON_Array *r_tarr = NULL, *r_garr = NULL; /* Response testarray, grouparray */
JSON_Value *r_tval = NULL, *r_gval = NULL; /* Response testval, groupval */
JSON_Object *r_tobj = NULL, *r_gobj = NULL; /* Response testobj, groupobj */
ACVP_CAPS_LIST *cap;
ACVP_KDF135_IKEV1_TC stc;
ACVP_TEST_CASE tc;
ACVP_RESULT rv;
const char *alg_str = json_object_get_string(obj, "algorithm");
const char *mode_str = NULL;
ACVP_CIPHER alg_id;
char *json_result;
ACVP_HASH_ALG hash_alg = 0;
ACVP_KDF135_IKEV1_AUTH_METHOD auth_method = 0;
const char *hash_alg_str = NULL, *auth_method_str = NULL;
char *init_ckey = NULL, *resp_ckey = NULL, *gxy = NULL, *psk = NULL, *init_nonce = NULL, *resp_nonce = NULL;
int init_nonce_len = 0, resp_nonce_len = 0, dh_secret_len = 0, psk_len = 0;
if (!ctx) {
ACVP_LOG_ERR("No ctx for handler operation");
return ACVP_NO_CTX;
}
if (!alg_str) {
ACVP_LOG_ERR("unable to parse 'algorithm' from JSON.");
return ACVP_MALFORMED_JSON;
}
mode_str = json_object_get_string(obj, "mode");
if (!mode_str) {
ACVP_LOG_ERR("unable to parse 'mode' from JSON.");
return ACVP_MALFORMED_JSON;
}
alg_id = acvp_lookup_cipher_w_mode_index(alg_str, mode_str);
if (alg_id != ACVP_KDF135_IKEV1) {
ACVP_LOG_ERR("Server JSON invalid 'algorithm' or 'mode'");
return ACVP_INVALID_ARG;
}
/*
* Get a reference to the abstracted test case
*/
tc.tc.kdf135_ikev1 = &stc;
stc.cipher = alg_id;
cap = acvp_locate_cap_entry(ctx, alg_id);
if (!cap) {
ACVP_LOG_ERR("ACVP server requesting unsupported capability %s : %d.", alg_str, alg_id);
return ACVP_UNSUPPORTED_OP;
}
/*
* Create ACVP array for response
*/
rv = acvp_create_array(®_obj, ®_arry_val, ®_arry);
if (rv != ACVP_SUCCESS) {
ACVP_LOG_ERR("Failed to create JSON response struct. ");
return rv;
}
/*
* Start to build the JSON response
*/
rv = acvp_setup_json_rsp_group(&ctx, ®_arry_val, &r_vs_val, &r_vs, alg_str, &r_garr);
if (rv != ACVP_SUCCESS) {
ACVP_LOG_ERR("Failed to setup json response");
return rv;
}
groups = json_object_get_array(obj, "testGroups");
g_cnt = json_array_get_count(groups);
for (i = 0; i < g_cnt; i++) {
int tgId = 0;
groupval = json_array_get_value(groups, i);
groupobj = json_value_get_object(groupval);
/*
* Create a new group in the response with the tgid
* and an array of tests
*/
r_gval = json_value_init_object();
r_gobj = json_value_get_object(r_gval);
tgId = json_object_get_number(groupobj, "tgId");
if (!tgId) {
ACVP_LOG_ERR("Missing tgid from server JSON groub obj");
rv = ACVP_MALFORMED_JSON;
goto err;
}
json_object_set_number(r_gobj, "tgId", tgId);
json_object_set_value(r_gobj, "tests", json_value_init_array());
r_tarr = json_object_get_array(r_gobj, "tests");
hash_alg_str = json_object_get_string(groupobj, "hashAlg");
if (!hash_alg_str) {
ACVP_LOG_ERR("Failed to include hashAlg");
rv = ACVP_MISSING_ARG;
goto err;
}
hash_alg = acvp_lookup_hash_alg(hash_alg_str);
if (hash_alg != ACVP_SHA1 && hash_alg != ACVP_SHA224 &&
hash_alg != ACVP_SHA256 && hash_alg != ACVP_SHA384 &&
hash_alg != ACVP_SHA512) {
ACVP_LOG_ERR("ACVP server requesting invalid hashAlg");
rv = ACVP_INVALID_ARG;
goto err;
}
auth_method_str = json_object_get_string(groupobj, "authenticationMethod");
if (!auth_method_str) {
ACVP_LOG_ERR("Failed to include authenticationMethod");
rv = ACVP_MISSING_ARG;
goto err;
}
auth_method = read_auth_method(auth_method_str);
if (!auth_method) {
ACVP_LOG_ERR("ACVP server requesting invalid authenticationMethod");
rv = ACVP_INVALID_ARG;
goto err;
}
init_nonce_len = json_object_get_number(groupobj, "nInitLength");
if (!(init_nonce_len >= ACVP_KDF135_IKEV1_INIT_NONCE_BIT_MIN &&
init_nonce_len <= ACVP_KDF135_IKEV1_INIT_NONCE_BIT_MAX)) {
ACVP_LOG_ERR("nInitLength incorrect, %d", init_nonce_len);
rv = ACVP_INVALID_ARG;
goto err;
}
resp_nonce_len = json_object_get_number(groupobj, "nRespLength");
if (!(resp_nonce_len >= ACVP_KDF135_IKEV1_RESP_NONCE_BIT_MIN &&
resp_nonce_len <= ACVP_KDF135_IKEV1_RESP_NONCE_BIT_MAX)) {
ACVP_LOG_ERR("nRespLength incorrect, %d", resp_nonce_len);
rv = ACVP_INVALID_ARG;
goto err;
}
dh_secret_len = json_object_get_number(groupobj, "dhLength");
if (!(dh_secret_len >= ACVP_KDF135_IKEV1_DH_SHARED_SECRET_BIT_MIN &&
dh_secret_len <= ACVP_KDF135_IKEV1_DH_SHARED_SECRET_BIT_MAX)) {
ACVP_LOG_ERR("dhLength incorrect, %d", dh_secret_len);
rv = ACVP_INVALID_ARG;
goto err;
}
if (auth_method == ACVP_KDF135_IKEV1_AMETH_PSK) {
/* Only for PSK authentication method */
psk_len = json_object_get_number(groupobj, "preSharedKeyLength");
if (!(psk_len >= ACVP_KDF135_IKEV1_PSK_BIT_MIN &&
psk_len <= ACVP_KDF135_IKEV1_PSK_BIT_MAX)) {
ACVP_LOG_ERR("preSharedKeyLength incorrect, %d", psk_len);
rv = ACVP_INVALID_ARG;
goto err;
}
}
ACVP_LOG_INFO("\n Test group: %d", i);
ACVP_LOG_INFO(" hash alg: %s", hash_alg_str);
ACVP_LOG_INFO(" auth method: %s", auth_method_str);
ACVP_LOG_INFO(" init nonce len: %d", init_nonce_len);
ACVP_LOG_INFO(" resp nonce len: %d", resp_nonce_len);
ACVP_LOG_INFO(" dh secret len: %d", dh_secret_len);
ACVP_LOG_INFO(" psk len: %d", psk_len);
tests = json_object_get_array(groupobj, "tests");
t_cnt = json_array_get_count(tests);
for (j = 0; j < t_cnt; j++) {
ACVP_LOG_INFO("Found new KDF IKEv1 test vector...");
testval = json_array_get_value(tests, j);
testobj = json_value_get_object(testval);
tc_id = (unsigned int)json_object_get_number(testobj, "tcId");
init_nonce = (char *)json_object_get_string(testobj, "nInit");
if (!init_nonce) {
ACVP_LOG_ERR("Failed to include nInit");
rv = ACVP_MISSING_ARG;
goto err;
}
if (strnlen_s((char *)init_nonce,
ACVP_KDF135_IKEV1_INIT_NONCE_STR_MAX + 1) != ((init_nonce_len + 7) / 8) * 2) {
ACVP_LOG_ERR("nInit length(%d) incorrect, expected(%d)",
strnlen_s((char *)init_nonce,
ACVP_KDF135_IKEV1_INIT_NONCE_STR_MAX + 1),
((init_nonce_len + 7) / 8) * 2);
rv = ACVP_INVALID_ARG;
goto err;
}
resp_nonce = (char *)json_object_get_string(testobj, "nResp");
if (!resp_nonce) {
ACVP_LOG_ERR("Failed to include nResp");
rv = ACVP_MISSING_ARG;
goto err;
}
if (strnlen_s((char *)resp_nonce,
ACVP_KDF135_IKEV1_RESP_NONCE_STR_MAX + 1) != ((resp_nonce_len + 7) / 8) * 2) {
ACVP_LOG_ERR("nResp length(%d) incorrect, expected(%d)",
strnlen_s((char *)resp_nonce,
ACVP_KDF135_IKEV1_RESP_NONCE_STR_MAX + 1),
((resp_nonce_len + 7) / 8) * 2);
rv = ACVP_INVALID_ARG;
goto err;
}
init_ckey = (char *)json_object_get_string(testobj, "ckyInit");
if (!init_ckey) {
ACVP_LOG_ERR("Failed to include ckyInit");
rv = ACVP_MISSING_ARG;
goto err;
}
if (strnlen_s((char *)init_ckey, ACVP_KDF135_IKEV1_COOKIE_STR_MAX + 1)
> ACVP_KDF135_IKEV1_COOKIE_STR_MAX) {
ACVP_LOG_ERR("ckyInit too long, max allowed=(%d)",
ACVP_KDF135_IKEV1_COOKIE_STR_MAX);
rv = ACVP_INVALID_ARG;
goto err;
}
resp_ckey = (char *)json_object_get_string(testobj, "ckyResp");
if (!resp_ckey) {
ACVP_LOG_ERR("Failed to include ckyResp");
rv = ACVP_MISSING_ARG;
goto err;
}
if (strnlen_s((char *)resp_ckey, ACVP_KDF135_IKEV1_COOKIE_STR_MAX + 1)
> ACVP_KDF135_IKEV1_COOKIE_STR_MAX) {
ACVP_LOG_ERR("ckyResp too long, max allowed=(%d)",
ACVP_KDF135_IKEV1_COOKIE_STR_MAX);
rv = ACVP_INVALID_ARG;
goto err;
}
gxy = (char *)json_object_get_string(testobj, "gxy");
if (!gxy) {
ACVP_LOG_ERR("Failed to include gxy");
rv = ACVP_MISSING_ARG;
goto err;
}
if (strnlen_s((char *)gxy, ACVP_KDF135_IKEV1_DH_SHARED_SECRET_STR_MAX + 1)
> ACVP_KDF135_IKEV1_DH_SHARED_SECRET_STR_MAX) {
ACVP_LOG_ERR("gxy too long, max allowed=(%d)",
ACVP_KDF135_IKEV1_DH_SHARED_SECRET_STR_MAX);
rv = ACVP_INVALID_ARG;
goto err;
}
if (auth_method == ACVP_KDF135_IKEV1_AMETH_PSK) {
/* Only for PSK authentication method */
psk = (char *)json_object_get_string(testobj, "preSharedKey");
if (!psk) {
ACVP_LOG_ERR("Failed to include preSharedKey");
rv = ACVP_MISSING_ARG;
goto err;
}
if (strnlen_s((char *)psk, ACVP_KDF135_IKEV1_PSK_STR_MAX + 1)
> ACVP_KDF135_IKEV1_PSK_STR_MAX) {
ACVP_LOG_ERR("preSharedKey too long, max allowed=(%d)",
ACVP_KDF135_IKEV1_PSK_STR_MAX);
rv = ACVP_INVALID_ARG;
goto err;
}
}
ACVP_LOG_INFO(" Test case: %d", j);
ACVP_LOG_INFO(" tcId: %d", tc_id);
/*
* Create a new test case in the response
*/
r_tval = json_value_init_object();
r_tobj = json_value_get_object(r_tval);
json_object_set_number(r_tobj, "tcId", tc_id);
/*
* Setup the test case data that will be passed down to
* the crypto module2
*/
rv = acvp_kdf135_ikev1_init_tc(ctx, &stc, tc_id, hash_alg, auth_method,
init_nonce_len, resp_nonce_len,
dh_secret_len, psk_len,
init_nonce, resp_nonce,
init_ckey, resp_ckey,
gxy, psk);
if (rv != ACVP_SUCCESS) {
acvp_kdf135_ikev1_release_tc(&stc);
json_value_free(r_tval);
goto err;
}
/* Process the current test vector... */
if ((cap->crypto_handler)(&tc)) {
ACVP_LOG_ERR("crypto module failed the KDF IKEv1 operation");
acvp_kdf135_ikev1_release_tc(&stc);
rv = ACVP_CRYPTO_MODULE_FAIL;
json_value_free(r_tval);
goto err;
}
/*
* Output the test case results using JSON
*/
rv = acvp_kdf135_ikev1_output_tc(ctx, &stc, r_tobj);
if (rv != ACVP_SUCCESS) {
ACVP_LOG_ERR("JSON output failure in hash module");
acvp_kdf135_ikev1_release_tc(&stc);
json_value_free(r_tval);
goto err;
}
/*
* Release all the memory associated with the test case
*/
acvp_kdf135_ikev1_release_tc(&stc);
/* Append the test response value to array */
json_array_append_value(r_tarr, r_tval);
}
json_array_append_value(r_garr, r_gval);
}
json_array_append_value(reg_arry, r_vs_val);
json_result = json_serialize_to_string_pretty(ctx->kat_resp, NULL);
if (ctx->debug == ACVP_LOG_LVL_VERBOSE) {
printf("\n\n%s\n\n", json_result);
} else {
ACVP_LOG_INFO("\n\n%s\n\n", json_result);
}
json_free_serialized_string(json_result);
rv = ACVP_SUCCESS;
err:
if (rv != ACVP_SUCCESS) {
acvp_release_json(r_vs_val, r_gval);
}
return rv;
}
ACVP_RESULT acvp_kdf135_srtp_kat_handler(ACVP_CTX *ctx, JSON_Object *obj) {
unsigned int tc_id;
JSON_Value *groupval;
JSON_Object *groupobj = NULL;
JSON_Value *testval;
JSON_Object *testobj = NULL;
JSON_Array *groups;
JSON_Array *tests;
JSON_Value *reg_arry_val = NULL;
JSON_Object *reg_obj = NULL;
JSON_Array *reg_arry = NULL;
int i, g_cnt;
int j, t_cnt;
JSON_Value *r_vs_val = NULL;
JSON_Object *r_vs = NULL;
JSON_Array *r_tarr = NULL, *r_garr = NULL; /* Response testarray, grouparray */
JSON_Value *r_tval = NULL, *r_gval = NULL; /* Response testval, groupval */
JSON_Object *r_tobj = NULL, *r_gobj = NULL; /* Response testobj, groupobj */
ACVP_CAPS_LIST *cap;
ACVP_KDF135_SRTP_TC stc;
ACVP_TEST_CASE tc;
ACVP_RESULT rv;
const char *alg_str = json_object_get_string(obj, "algorithm");
const char *mode_str = NULL;
ACVP_CIPHER alg_id;
char *json_result;
int aes_key_length;
char *kdr = NULL, *master_key = NULL, *master_salt = NULL, *index = NULL, *srtcp_index = NULL;
if (!ctx) {
ACVP_LOG_ERR("No ctx for handler operation");
return ACVP_NO_CTX;
}
if (!alg_str) {
ACVP_LOG_ERR("unable to parse 'algorithm' from JSON.");
return ACVP_MALFORMED_JSON;
}
mode_str = json_object_get_string(obj, "mode");
if (!mode_str) {
ACVP_LOG_ERR("unable to parse 'mode' from JSON.");
return ACVP_MALFORMED_JSON;
}
alg_id = acvp_lookup_cipher_w_mode_index(alg_str, mode_str);
if (alg_id != ACVP_KDF135_SRTP) {
ACVP_LOG_ERR("Server JSON invalid 'algorithm' or 'mode'");
return ACVP_INVALID_ARG;
}
/*
* Get a reference to the abstracted test case
*/
tc.tc.kdf135_srtp = &stc;
stc.cipher = alg_id;
cap = acvp_locate_cap_entry(ctx, alg_id);
if (!cap) {
ACVP_LOG_ERR("ACVP server requesting unsupported capability %s : %d.", alg_str, alg_id);
return ACVP_UNSUPPORTED_OP;
}
/*
* Create ACVP array for response
*/
rv = acvp_create_array(®_obj, ®_arry_val, ®_arry);
if (rv != ACVP_SUCCESS) {
ACVP_LOG_ERR("Failed to create JSON response struct. ");
return rv;
}
/*
* Start to build the JSON response
*/
rv = acvp_setup_json_rsp_group(&ctx, ®_arry_val, &r_vs_val, &r_vs, alg_str, &r_garr);
if (rv != ACVP_SUCCESS) {
ACVP_LOG_ERR("Failed to setup json response");
goto err;
}
groups = json_object_get_array(obj, "testGroups");
g_cnt = json_array_get_count(groups);
for (i = 0; i < g_cnt; i++) {
int tgId = 0;
groupval = json_array_get_value(groups, i);
groupobj = json_value_get_object(groupval);
/*
* Create a new group in the response with the tgid
* and an array of tests
*/
r_gval = json_value_init_object();
r_gobj = json_value_get_object(r_gval);
tgId = json_object_get_number(groupobj, "tgId");
if (!tgId) {
ACVP_LOG_ERR("Missing tgid from server JSON groub obj");
rv = ACVP_MALFORMED_JSON;
goto err;
}
json_object_set_number(r_gobj, "tgId", tgId);
json_object_set_value(r_gobj, "tests", json_value_init_array());
r_tarr = json_object_get_array(r_gobj, "tests");
aes_key_length = (unsigned int)json_object_get_number(groupobj, "aesKeyLength");
if (!aes_key_length) {
ACVP_LOG_ERR("aesKeyLength incorrect, %d", aes_key_length);
rv = ACVP_INVALID_ARG;
goto err;
}
kdr = (char *)json_object_get_string(groupobj, "kdr");
if (!kdr) {
ACVP_LOG_ERR("Failed to include kdr");
rv = ACVP_MISSING_ARG;
goto err;
}
ACVP_LOG_INFO("\n Test group: %d", i);
ACVP_LOG_INFO(" kdr: %s", kdr);
ACVP_LOG_INFO(" key length: %d", aes_key_length);
tests = json_object_get_array(groupobj, "tests");
t_cnt = json_array_get_count(tests);
for (j = 0; j < t_cnt; j++) {
ACVP_LOG_INFO("Found new KDF SRTP test vector...");
testval = json_array_get_value(tests, j);
testobj = json_value_get_object(testval);
tc_id = (unsigned int)json_object_get_number(testobj, "tcId");
master_key = (char *)json_object_get_string(testobj, "masterKey");
if (!master_key) {
ACVP_LOG_ERR("Failed to include JSON key:\"masterKey\"");
rv = ACVP_MISSING_ARG;
goto err;
}
master_salt = (char *)json_object_get_string(testobj, "masterSalt");
if (!master_salt) {
ACVP_LOG_ERR("Failed to include JSON key:\"masterSalt\"");
rv = ACVP_MISSING_ARG;
goto err;
}
index = (char *)json_object_get_string(testobj, "index");
if (!index) {
ACVP_LOG_ERR("Failed to include JSON key:\"index\"");
rv = ACVP_MISSING_ARG;
goto err;
}
srtcp_index = (char *)json_object_get_string(testobj, "srtcpIndex");
if (!srtcp_index) {
ACVP_LOG_ERR("Failed to include JSON key:\"srtcpIndex\"");
rv = ACVP_MISSING_ARG;
goto err;
}
ACVP_LOG_INFO(" Test case: %d", j);
ACVP_LOG_INFO(" tcId: %d", tc_id);
ACVP_LOG_INFO(" masterKey: %s", master_key);
ACVP_LOG_INFO(" masterSalt: %s", master_salt);
ACVP_LOG_INFO(" index: %s", index);
ACVP_LOG_INFO(" srtcpIndex: %s", srtcp_index);
/*
* Create a new test case in the response
*/
r_tval = json_value_init_object();
r_tobj = json_value_get_object(r_tval);
json_object_set_number(r_tobj, "tcId", tc_id);
/*
* Setup the test case data that will be passed down to
* the crypto module.
*/
rv = acvp_kdf135_srtp_init_tc(ctx, &stc, tc_id, aes_key_length, kdr, master_key, master_salt, index, srtcp_index);
if (rv != ACVP_SUCCESS) {
acvp_kdf135_srtp_release_tc(&stc);
json_value_free(r_tval);
goto err;
}
/* Process the current test vector... */
if ((cap->crypto_handler)(&tc)) {
ACVP_LOG_ERR("crypto module failed");
acvp_kdf135_srtp_release_tc(&stc);
rv = ACVP_CRYPTO_MODULE_FAIL;
json_value_free(r_tval);
goto err;
}
/*
* Output the test case results using JSON
*/
rv = acvp_kdf135_srtp_output_tc(ctx, &stc, r_tobj);
if (rv != ACVP_SUCCESS) {
ACVP_LOG_ERR("JSON output failure");
acvp_kdf135_srtp_release_tc(&stc);
json_value_free(r_tval);
goto err;
}
/*
* Release all the memory associated with the test case
*/
acvp_kdf135_srtp_release_tc(&stc);
/* Append the test response value to array */
json_array_append_value(r_tarr, r_tval);
}
json_array_append_value(r_garr, r_gval);
}
json_array_append_value(reg_arry, r_vs_val);
json_result = json_serialize_to_string_pretty(ctx->kat_resp, NULL);
if (ctx->debug == ACVP_LOG_LVL_VERBOSE) {
printf("\n\n%s\n\n", json_result);
} else {
ACVP_LOG_INFO("\n\n%s\n\n", json_result);
}
json_free_serialized_string(json_result);
rv = ACVP_SUCCESS;
err:
if (rv != ACVP_SUCCESS) {
acvp_release_json(r_vs_val, r_gval);
}
return rv;
}
// updates the planes map, planes not seen for a defined intervall are removed from the map and only planes within a defined distance from the given latitude and longited
static void UpdatePlanes(char *balancerUrl, char *zoneName, double latitude, double longitude)
{
time_t currentTime = time(NULL);
if (currentTime != ((time_t) -1))
{
pthread_mutex_lock(&planesMutex);
for (std::map<std::string, Plane*>::iterator p = planes.begin(); p != planes.end(); ++p)
{
Plane *plane = p->second;
if (currentTime - plane->lastSeen > PLANE_TIMEOUT)
{
//printf("Removing: %s - CurrentTime = %d - LastSeen = %d\n", p->first.c_str(), (int) currentTime, (int) plane->lastSeen);
free(plane);
plane = NULL;
planes.erase(p->first);
}
}
pthread_mutex_unlock(&planesMutex);
char url[strlen(balancerUrl) + strlen(URL_ZONE_INFIX) + strlen(zoneName) + strlen(URL_ZONE_SUFFIX)];
sprintf(url, "%s%s%s%s", balancerUrl, URL_ZONE_INFIX, zoneName, URL_ZONE_SUFFIX);
char *zone = GetUrl(url);
if (zone != NULL)
{
int cmp = 1;
if (lastZone != NULL)
cmp = strcmp(zone, lastZone);
if (cmp != 0)
{
JSON_Value *rootJson = json_parse_string(zone);
lastZone = zone;
if (rootJson != NULL)
{
if (rootJson->type == JSONObject)
{
JSON_Object *aircraftJson = json_value_get_object(rootJson);
if (aircraftJson != NULL)
{
size_t aircraftCount = json_object_get_count(aircraftJson);
for (int i = 0; i < aircraftCount; i++)
{
const char *id = json_object_get_name(aircraftJson, i);
if (id != NULL)
{
JSON_Value *value = json_object_get_value(aircraftJson, id);
if (value != NULL && value->type == JSONArray)
{
JSON_Array *propertiesJson = json_value_get_array(value);
if (propertiesJson != NULL)
{
const char *registration = NULL, *icaoId = NULL, *icaoType = NULL, *squawk = NULL;
double latitudePlane = 0.0, longitudePlane = 0.0, altitude = 0.0;
float heading = 0.0f;
int speed = 0, verticalSpeed = 0;
int propertyCount = json_array_get_count(propertiesJson);
for (int k = 0; k < propertyCount; k++)
{
JSON_Value *valueJson = json_array_get_value(propertiesJson, k);
if (valueJson != NULL)
{
switch (k)
{
case ARRAY_INDEX_LATITUDE:
latitudePlane = json_value_get_number(valueJson);
break;
case ARRAY_INDEX_LONGITUDE:
longitudePlane = json_value_get_number(valueJson);
break;
case ARRAY_INDEX_ALTITUDE:
altitude = json_value_get_number(valueJson);
break;
case ARRAY_INDEX_HEADING:
heading = (float) json_value_get_number(valueJson);
break;
case ARRAY_INDEX_SPEED:
speed = (int) json_value_get_number(valueJson);
break;
case ARRAY_INDEX_SQUAWK:
squawk = json_value_get_string(valueJson);
break;
case ARRAY_INDEX_ICAO_TYPE:
icaoType = json_value_get_string(valueJson);
break;
case ARRAY_INDEX_REGISTRATION:
registration = json_value_get_string(valueJson);
break;
case ARRAY_INDEX_VERTICAL_SPEED:
verticalSpeed = (int) json_value_get_number(valueJson);
break;
case ARRAY_INDEX_ICAO_ID:
icaoId = json_value_get_string(valueJson);
break;
}
}
}
if (latitudePlane != 0.0 && longitudePlane != 0.0 && GetDistance(latitude, longitude, latitudePlane, longitudePlane) <= MAX_DISTANCE)
{
Plane *plane = NULL;
pthread_mutex_lock(&planesMutex);
std::map<std::string, Plane*>::iterator p = planes.find(id);
if (p != planes.end())
plane = p->second;
else
{
plane = (Plane*) malloc(sizeof(*plane));
if (plane != NULL)
planes[std::string(id)] = plane;
}
if (plane != NULL)
{
if (registration == NULL || strlen(registration) == 0)
registration = "Unknown";
if (icaoId == NULL || strlen(icaoId) == 0)
icaoId = "Unknown";
if (icaoType == NULL || strlen(icaoType) == 0)
icaoType = "UKN";
if (squawk == NULL || strlen(squawk) == 0)
squawk = "0000";
strncpy(plane->registration, registration, sizeof(plane->registration) / sizeof(char));
strncpy(plane->icaoId, icaoId, sizeof(plane->icaoId) / sizeof(char));
strncpy(plane->icaoType, icaoType, sizeof(plane->icaoType) / sizeof(char));
strncpy(plane->squawk, squawk, sizeof(plane->squawk) / sizeof(char));
if (plane->latitude != latitudePlane)
{
plane->latitude = latitudePlane;
plane->interpolatedLatitude = 0.0;
}
if (plane->longitude != longitudePlane)
{
plane->longitude = longitudePlane;
plane->interpolatedLongitude = 0.0;
}
if (plane->altitude != altitude)
{
plane->altitude = altitude;
plane->interpolatedAltitude = -1000.0;
}
plane->pitch = 0.0f;
plane->roll = 0.0f;
plane->heading = heading;
plane->speed = speed;
plane->verticalSpeed = verticalSpeed;
plane->lastSeen = currentTime;
}
pthread_mutex_unlock(&planesMutex);
}
}
}
}
}
}
json_value_free(rootJson);
rootJson = NULL;
}
}
}
}
}
}
int parse_blueprint_json(JSON_Object *blueprint, blueprint_t *bp)
{
bstring Name, bp_name, name, game_version;
uint32_t resource_cost[5];
bp->revision = json_object_get_number(blueprint, "blueprintVersion");
bp_name = bfromcstr(json_object_get_string(blueprint, "blueprintName"));
name = bfromcstr(json_object_get_string(blueprint, "Name"));
game_version = bfromcstr(json_object_get_string(blueprint, "GameVersion"));
bstring param1 = bfromcstr(json_object_get_string(blueprint, "Parameter1"));
bstring param2 = bfromcstr(json_object_get_string(blueprint, "Parameter2"));
bstring lpos = bfromcstr(json_object_get_string(blueprint, "LocalPosition"));
bstring lrot = bfromcstr(json_object_get_string(blueprint, "LocalRotation"));
bp->name = name;
bp->blueprint_name = bp_name;
bp->Name = Name;
bp->game_version = game_version;
const char* cpos = json_object_get_string(blueprint, "LocalPosition");
bstring pos = bfromcstr(cpos);
struct bstrList *pval = bsplit(pos, ',');
for (int i = 0; i < 3; i++)
{
char *ptr;
char *str = bstr2cstr(pval->entry[i], '0');
uint32_t n = strtol(str, &ptr, 10);
}
const char* crot = json_object_get_string(blueprint, "LocalRotation");
bstring rot = bfromcstr(crot);
struct bstrList *rval = bsplit(rot, ',');
for (int i = 0; i < 4; i++)
{
char *ptr;
char *str = bstr2cstr(rval->entry[i], '0');
double dbl = strtod(str, &ptr);
free(str);
bp->local_rotation[i] = dbl;
}
bp->parameter1 = param1;
bp->parameter2 = param2;
bp->design_changed = json_object_get_boolean(blueprint, "designChanged");
bp->id = json_object_get_number(blueprint, "Id");
bp->force_id = json_object_get_number(blueprint, "ForceId");
bp->item_number = json_object_get_number(blueprint, "ItemNumber");
JSON_Array *jresource_cost = json_object_get_array(blueprint, "ResourceCost");
for (int i = 0; i < 5; i++)
bp->resource_cost[i] = (uint32_t) json_array_get_number(jresource_cost, i);
JSON_Array *min_coords = json_object_get_array(blueprint, "MinCords");
for (int i = 0; i < 3; i++)
bp->min_coords[i] = (int32_t) json_array_get_number(min_coords, i);
JSON_Array *max_coords = json_object_get_array(blueprint, "MaxCords");
for (int i = 0; i < 3; i++)
bp->max_coords[i] = (int32_t) json_array_get_number(max_coords, i);
JSON_Array *csi = json_object_get_array(blueprint, "CSI");
for (int i = 0; i < 40; i++)
bp->constructable_special_info[i] = json_array_get_number(csi, i);
bp->last_alive_block = (uint32_t) json_object_get_number(blueprint, "LastAliveBlock");
JSON_Array *palette = json_object_get_array(blueprint, "COL");
for(int i = 0; i < 32; i++)
{
uint32_t rbga = 0;
const char* ccolor = json_array_get_string(palette, i);
bstring color = bfromcstr(ccolor);
// Create array of substrings
struct bstrList *values = bsplit(color, ',');
for (int n = 0; n < 4; n++)
{
char *ptr;
char *str = bstr2cstr(values->entry[n], '0');
double dbl = strtod(str, &ptr);
free(str);
bp->color_palette[i].array[n] = round(dbl * 255.0);
}
bstrListDestroy(values);
bdestroy(color);
}
JSON_Array *material = json_object_get_array(blueprint, "BlockIds");
JSON_Array *position = json_object_get_array(blueprint, "BLP");
JSON_Array *rotation = json_object_get_array(blueprint, "BLR");
JSON_Array *color = json_object_get_array(blueprint, "BCI");
JSON_Array *bp1 = json_object_get_array(blueprint, "BP1");
JSON_Array *bp2 = json_object_get_array(blueprint, "BP2");
JSON_Array *block_string_ids = json_object_get_array(blueprint, "BlockStringDataIds");
JSON_Array *block_data = json_object_get_array(blueprint, "BlockStringData");
bp->total_block_count = (uint32_t) json_object_get_number(blueprint, "TotalBlockCount");
bp->main_block_count = (uint32_t) json_object_get_number(blueprint, "BlockCount");
bp->blocks = calloc(bp->main_block_count, sizeof(block_t));
for (int i = 0; i < bp->main_block_count; i++)
{
block_t *act = &bp->blocks[i];
act->material = (uint32_t) json_array_get_number(material, i);
act->rotation = (uint32_t) json_array_get_number(rotation, i);
act->color = (uint32_t) json_array_get_number(color, i);
bstring pos_string = bfromcstr(json_array_get_string(position, i));
struct bstrList *pos_list = bsplit(pos_string, ',');
for (int n = 0; n < 3; n++)
{
char *ptr;
char *str = bstr2cstr(pos_list->entry[n], '0');
double dbl = strtod(str, &ptr);
uint32_t val = round(dbl);
act->position.array[n] = val;
free(str);
}
bstrListDestroy(pos_list);
bdestroy(pos_string);
bstring bp1_string = bfromcstr(json_array_get_string(bp1, i));
struct bstrList *bp1_values = bsplit(bp1_string, ',');
for (int n = 0; n < 4; n++)
{
char *ptr;
char *str = bstr2cstr(bp1_values->entry[n], '0');
double dbl = strtod(str, &ptr);
act->bp1[n] = dbl;
}
bstring bp2_string = bfromcstr(json_array_get_string(bp2, i));
struct bstrList *bp2_values = bsplit(bp2_string, ',');
for (int n = 0; n < 4; n++)
{
char *ptr;
char *str = bstr2cstr(bp2_values->entry[n], '0');
double dbl = strtod(str, &ptr);
uint32_t val = round(dbl);
act->bp2[n] = val;
}
// Only used for lookup, not saved after that since it has no further semantic value
const char *cb1 = json_array_get_string(bp1, i);
if (act->bp1[3] != 0)
{
for (int n = 0; n < json_array_get_count(block_string_ids); n++)
{
uint32_t test_id = json_array_get_number(block_string_ids, n);
if (test_id == 0)
{
break;
}
if (test_id == act->bp1[3])
{
// BlockStringData at index n is the one we want
act->string_data = bfromcstr(json_array_get_string(block_data, n));
}
}
}
}
JSON_Array *subconstructables = json_object_get_array(blueprint, "SCs");
bp->num_sc = json_array_get_count(subconstructables);
bp->SCs = calloc(bp->num_sc, sizeof(blueprint_t));
for (int i = 0; i < bp->num_sc; i++)
{
JSON_Value *sc_json = json_array_get_value(subconstructables, i);
JSON_Object *sc_obj = json_value_get_object(sc_json);
int retval = parse_blueprint_json(sc_obj, &bp->SCs[i]);
if (retval != 0)
return retval;
}
return 0;
}
ACVP_RESULT acvp_cmac_kat_handler(ACVP_CTX *ctx, JSON_Object *obj) {
unsigned int tc_id, msglen, keyLen = 0, keyingOption = 0, maclen, verify = 0;
char *msg = NULL, *key1 = NULL, *key2 = NULL, *key3 = NULL, *mac = NULL;
JSON_Value *groupval;
JSON_Object *groupobj = NULL;
JSON_Value *testval;
JSON_Object *testobj = NULL;
JSON_Array *groups;
JSON_Array *tests;
JSON_Value *reg_arry_val = NULL;
JSON_Object *reg_obj = NULL;
JSON_Array *reg_arry = NULL;
int i, g_cnt;
int j, t_cnt;
JSON_Value *r_vs_val = NULL;
JSON_Object *r_vs = NULL;
JSON_Array *r_tarr = NULL, *r_garr = NULL; /* Response testarray, grouparray */
JSON_Value *r_tval = NULL, *r_gval = NULL; /* Response testval, groupval */
JSON_Object *r_tobj = NULL, *r_gobj = NULL; /* Response testobj, groupobj */
ACVP_CAPS_LIST *cap;
ACVP_CMAC_TC stc;
ACVP_TEST_CASE tc;
ACVP_RESULT rv;
const char *alg_str = json_object_get_string(obj, "algorithm");
ACVP_CIPHER alg_id;
char *json_result, *direction = NULL;
int key1_len, key2_len, key3_len, json_msglen;
if (!ctx) {
ACVP_LOG_ERR("No ctx for handler operation");
return ACVP_NO_CTX;
}
if (!obj) {
ACVP_LOG_ERR("No obj for handler operation");
return ACVP_MALFORMED_JSON;
}
if (!alg_str) {
ACVP_LOG_ERR("ERROR: unable to parse 'algorithm' from JSON");
return ACVP_MALFORMED_JSON;
}
/*
* Get a reference to the abstracted test case
*/
tc.tc.cmac = &stc;
/*
* Get the crypto module handler for this hash algorithm
*/
alg_id = acvp_lookup_cipher_index(alg_str);
if (alg_id < ACVP_CIPHER_START) {
ACVP_LOG_ERR("ERROR: unsupported algorithm (%s)", alg_str);
return ACVP_UNSUPPORTED_OP;
}
cap = acvp_locate_cap_entry(ctx, alg_id);
if (!cap) {
ACVP_LOG_ERR("ERROR: ACVP server requesting unsupported capability");
return ACVP_UNSUPPORTED_OP;
}
/*
* Create ACVP array for response
*/
rv = acvp_create_array(®_obj, ®_arry_val, ®_arry);
if (rv != ACVP_SUCCESS) {
ACVP_LOG_ERR("ERROR: Failed to create JSON response struct. ");
return rv;
}
/*
* Start to build the JSON response
*/
rv = acvp_setup_json_rsp_group(&ctx, ®_arry_val, &r_vs_val, &r_vs, alg_str, &r_garr);
if (rv != ACVP_SUCCESS) {
ACVP_LOG_ERR("Failed to setup json response");
return rv;
}
groups = json_object_get_array(obj, "testGroups");
g_cnt = json_array_get_count(groups);
for (i = 0; i < g_cnt; i++) {
int tgId = 0;
int diff = 0;
groupval = json_array_get_value(groups, i);
groupobj = json_value_get_object(groupval);
/*
* Create a new group in the response with the tgid
* and an array of tests
*/
r_gval = json_value_init_object();
r_gobj = json_value_get_object(r_gval);
tgId = json_object_get_number(groupobj, "tgId");
if (!tgId) {
ACVP_LOG_ERR("Missing tgid from server JSON groub obj");
rv = ACVP_MALFORMED_JSON;
goto err;
}
json_object_set_number(r_gobj, "tgId", tgId);
json_object_set_value(r_gobj, "tests", json_value_init_array());
r_tarr = json_object_get_array(r_gobj, "tests");
if (alg_id == ACVP_CMAC_AES) {
keyLen = (unsigned int)json_object_get_number(groupobj, "keyLen");
if (!keyLen) {
ACVP_LOG_ERR("keylen missing from cmac aes json");
rv = ACVP_MISSING_ARG;
goto err;
}
} else if (alg_id == ACVP_CMAC_TDES) {
keyingOption = (unsigned int)json_object_get_number(groupobj, "keyingOption");
if (keyingOption <= ACVP_CMAC_TDES_KEYING_OPTION_MIN ||
keyingOption >= ACVP_CMAC_TDES_KEYING_OPTION_MAX) {
ACVP_LOG_ERR("keyingOption missing or wrong from cmac tdes json");
rv = ACVP_INVALID_ARG;
goto err;
}
}
direction = (char *)json_object_get_string(groupobj, "direction");
if (!direction) {
ACVP_LOG_ERR("Unable to parse 'direction' from JSON.");
rv = ACVP_MALFORMED_JSON;
goto err;
}
strcmp_s("ver", 3, direction, &diff);
if (!diff) {
verify = 1;
} else {
strcmp_s("gen", 3, direction, &diff);
if (diff) {
ACVP_LOG_ERR("'direction' should be 'gen' or 'ver'");
rv = ACVP_UNSUPPORTED_OP;
goto err;
}
}
msglen = (unsigned int)json_object_get_number(groupobj, "msgLen") / 8;
maclen = (unsigned int)json_object_get_number(groupobj, "macLen") / 8;
if (!maclen) {
ACVP_LOG_ERR("Server JSON missing 'macLen'");
rv = ACVP_MISSING_ARG;
goto err;
}
ACVP_LOG_INFO("\n\n Test group: %d", i);
tests = json_object_get_array(groupobj, "tests");
t_cnt = json_array_get_count(tests);
for (j = 0; j < t_cnt; j++) {
ACVP_LOG_INFO("Found new cmac test vector...");
testval = json_array_get_value(tests, j);
testobj = json_value_get_object(testval);
tc_id = (unsigned int)json_object_get_number(testobj, "tcId");
msg = (char *)json_object_get_string(testobj, "message");
/* msg can be null if msglen is 0 */
if (msg) {
json_msglen = strnlen_s(msg, ACVP_CMAC_MSGLEN_MAX_STR + 1);
if (json_msglen > ACVP_CMAC_MSGLEN_MAX_STR) {
ACVP_LOG_ERR("'msg' too long");
rv = ACVP_INVALID_ARG;
goto err;
}
if (!msglen && json_msglen > 0) {
ACVP_LOG_ERR("Server JSON missing 'msgLen'");
rv = ACVP_MISSING_ARG;
goto err;
}
} else if (msglen) {
ACVP_LOG_ERR("msglen is nonzero, expected 'msg' in json");
rv = ACVP_MISSING_ARG;
goto err;
}
if (alg_id == ACVP_CMAC_AES) {
key1 = (char *)json_object_get_string(testobj, "key");
if (!key1) {
ACVP_LOG_ERR("Server JSON missing 'key'");
rv = ACVP_MISSING_ARG;
goto err;
}
key1_len = strnlen_s(key1, ACVP_CMAC_KEY_MAX + 1);
if (key1_len > ACVP_CMAC_KEY_MAX) {
ACVP_LOG_ERR("Invalid length for 'key' attribute in CMAC-AES test");
rv = ACVP_INVALID_ARG;
goto err;
}
} else if (alg_id == ACVP_CMAC_TDES) {
key1 = (char *)json_object_get_string(testobj, "key1");
key2 = (char *)json_object_get_string(testobj, "key2");
key3 = (char *)json_object_get_string(testobj, "key3");
if (!key1 || !key2 || !key3) {
ACVP_LOG_ERR("Server JSON missing 'key(1,2,3)' value");
rv = ACVP_MISSING_ARG;
goto err;
}
key1_len = strnlen_s(key1, ACVP_CMAC_KEY_MAX + 1);
key2_len = strnlen_s(key2, ACVP_CMAC_KEY_MAX + 1);
key3_len = strnlen_s(key3, ACVP_CMAC_KEY_MAX + 1);
if (key1_len > ACVP_CMAC_KEY_MAX ||
key2_len > ACVP_CMAC_KEY_MAX ||
key3_len > ACVP_CMAC_KEY_MAX) {
ACVP_LOG_ERR("Invalid length for 'key(1|2|3)' attribute in CMAC-TDES test");
rv = ACVP_INVALID_ARG;
goto err;
}
}
if (verify) {
mac = (char *)json_object_get_string(testobj, "mac");
if (!mac) {
ACVP_LOG_ERR("Server JSON missing 'mac'");
rv = ACVP_MISSING_ARG;
goto err;
}
}
ACVP_LOG_INFO("\n Test case: %d", j);
ACVP_LOG_INFO(" tcId: %d", tc_id);
ACVP_LOG_INFO(" direction: %s", direction);
ACVP_LOG_INFO(" msgLen: %d", msglen);
ACVP_LOG_INFO(" msg: %s", msg);
if (alg_id == ACVP_CMAC_AES) {
ACVP_LOG_INFO(" keyLen: %d", keyLen);
ACVP_LOG_INFO(" key: %s", key1);
} else if (alg_id == ACVP_CMAC_TDES) {
ACVP_LOG_INFO(" keyingOption: %d", keyingOption);
ACVP_LOG_INFO(" key1: %s", key1);
ACVP_LOG_INFO(" key2: %s", key2);
ACVP_LOG_INFO(" key3: %s", key3);
}
if (verify) {
ACVP_LOG_INFO(" mac: %s", mac);
}
/*
* Create a new test case in the response
*/
r_tval = json_value_init_object();
r_tobj = json_value_get_object(r_tval);
json_object_set_number(r_tobj, "tcId", tc_id);
/*
* Setup the test case data that will be passed down to
* the crypto module.
*/
rv = acvp_cmac_init_tc(ctx, &stc, tc_id, msg, msglen, keyLen, key1, key2, key3,
verify, mac, maclen, alg_id);
if (rv != ACVP_SUCCESS) {
acvp_cmac_release_tc(&stc);
json_value_free(r_tval);
goto err;
}
/* Process the current test vector... */
if ((cap->crypto_handler)(&tc)) {
ACVP_LOG_ERR("ERROR: crypto module failed the operation");
acvp_cmac_release_tc(&stc);
rv = ACVP_CRYPTO_MODULE_FAIL;
json_value_free(r_tval);
goto err;
}
/*
* Output the test case results using JSON
*/
rv = acvp_cmac_output_tc(ctx, &stc, r_tobj);
if (rv != ACVP_SUCCESS) {
ACVP_LOG_ERR("ERROR: JSON output failure in hash module");
acvp_cmac_release_tc(&stc);
json_value_free(r_tval);
goto err;
}
/*
* Release all the memory associated with the test case
*/
acvp_cmac_release_tc(&stc);
/* Append the test response value to array */
json_array_append_value(r_tarr, r_tval);
}
json_array_append_value(r_garr, r_gval);
}
json_array_append_value(reg_arry, r_vs_val);
json_result = json_serialize_to_string_pretty(ctx->kat_resp, NULL);
if (ctx->debug == ACVP_LOG_LVL_VERBOSE) {
printf("\n\n%s\n\n", json_result);
} else {
ACVP_LOG_INFO("\n\n%s\n\n", json_result);
}
json_free_serialized_string(json_result);
rv = ACVP_SUCCESS;
err:
if (rv != ACVP_SUCCESS) {
acvp_release_json(r_vs_val, r_gval);
}
return rv;
}
MODULE_LOADER_RESULT ModuleLoader_InitializeFromJson(const JSON_Value* loaders)
{
MODULE_LOADER_RESULT result;
if (loaders == NULL)
{
LogError("loaders is NULL");
/*Codes_SRS_MODULE_LOADER_13_062: [ ModuleLoader_InitializeFromJson shall return MODULE_LOADER_ERROR if loaders is NULL. ]*/
result = MODULE_LOADER_ERROR;
}
else
{
if (json_value_get_type(loaders) != JSONArray)
{
LogError("loaders is not a JSON array");
/*Codes_SRS_MODULE_LOADER_13_063: [ ModuleLoader_InitializeFromJson shall return MODULE_LOADER_ERROR if loaders is not a JSON array. ]*/
result = MODULE_LOADER_ERROR;
}
else
{
JSON_Array* loaders_array = json_value_get_array(loaders);
if (loaders_array == NULL)
{
LogError("json_value_get_array failed");
/*Codes_SRS_MODULE_LOADER_13_064: [ ModuleLoader_InitializeFromJson shall return MODULE_LOADER_ERROR if an underlying platform call fails. ]*/
result = MODULE_LOADER_ERROR;
}
else
{
size_t length = json_array_get_count(loaders_array);
size_t i;
for (i = 0; i < length; i++)
{
JSON_Value* loader = json_array_get_value(loaders_array, i);
if (loader == NULL)
{
/*Codes_SRS_MODULE_LOADER_13_064: [ ModuleLoader_InitializeFromJson shall return MODULE_LOADER_ERROR if an underlying platform call fails. ]*/
LogError("json_array_get_value failed for loader %zu", i);
break;
}
if (add_loader_from_json(loader, i) != MODULE_LOADER_SUCCESS)
{
LogError("add_loader_from_json failed for loader %zu", i);
break;
}
}
/*Codes_SRS_MODULE_LOADER_13_073: [ ModuleLoader_InitializeFromJson shall return MODULE_LOADER_SUCCESS if the the JSON has been processed successfully. ]*/
// if the loop terminated early then something went wrong
result = (i < length) ? MODULE_LOADER_ERROR : MODULE_LOADER_SUCCESS;
}
}
}
return result;
}
static mrb_value
json_value_to_mrb_value(mrb_state* mrb, JSON_Value* value) {
mrb_value ret;
switch (json_value_get_type(value)) {
case JSONError:
case JSONNull:
ret = mrb_nil_value();
break;
case JSONString:
ret = mrb_str_new_cstr(mrb, json_value_get_string(value));
break;
case JSONNumber:
{
double d = json_value_get_number(value);
if (floor(d) == d) {
ret = mrb_fixnum_value(d);
}
else {
ret = mrb_float_value(mrb, d);
}
}
break;
case JSONObject:
{
mrb_value hash = mrb_hash_new(mrb);
JSON_Object* object = json_value_get_object(value);
size_t count = json_object_get_count(object);
size_t n;
for (n = 0; n < count; n++) {
int ai = mrb_gc_arena_save(mrb);
const char* name = json_object_get_name(object, n);
mrb_hash_set(mrb, hash, mrb_str_new_cstr(mrb, name),
json_value_to_mrb_value(mrb, json_object_get_value(object, name)));
mrb_gc_arena_restore(mrb, ai);
}
ret = hash;
}
break;
case JSONArray:
{
mrb_value ary;
JSON_Array* array;
size_t n, count;
ary = mrb_ary_new(mrb);
array = json_value_get_array(value);
count = json_array_get_count(array);
for (n = 0; n < count; n++) {
int ai = mrb_gc_arena_save(mrb);
JSON_Value* elem = json_array_get_value(array, n);
mrb_ary_push(mrb, ary, json_value_to_mrb_value(mrb, elem));
mrb_gc_arena_restore(mrb, ai);
}
ret = ary;
}
break;
case JSONBoolean:
if (json_value_get_boolean(value))
ret = mrb_true_value();
else
ret = mrb_false_value();
break;
default:
mrb_raise(mrb, E_ARGUMENT_ERROR, "invalid argument");
}
return ret;
}
