/* Testing correctness of parsed values */ void test_suite_2(JSON_Value *root_value) { JSON_Object *root_object; JSON_Array *array; size_t i; TEST(root_value); TEST(json_value_get_type(root_value) == JSONObject); root_object = json_value_get_object(root_value); TEST(STREQ(json_object_get_string(root_object, "string"), "lorem ipsum")); TEST(STREQ(json_object_get_string(root_object, "utf string"), "lorem ipsum")); TEST(STREQ(json_object_get_string(root_object, "utf-8 string"), "あいうえお")); TEST(STREQ(json_object_get_string(root_object, "surrogate string"), "lorem𝄞ipsum𝍧lorem")); TEST(json_object_get_number(root_object, "positive one") == 1.0); TEST(json_object_get_number(root_object, "negative one") == -1.0); TEST(json_object_get_number(root_object, "hard to parse number") == -0.000314); TEST(json_object_get_boolean(root_object, "boolean true") == 1); TEST(json_object_get_boolean(root_object, "boolean false") == 0); TEST(json_value_get_type(json_object_get_value(root_object, "null")) == JSONNull); array = json_object_get_array(root_object, "string array"); if (array != NULL && json_array_get_count(array) > 1) { TEST(STREQ(json_array_get_string(array, 0), "lorem")); TEST(STREQ(json_array_get_string(array, 1), "ipsum")); } else { tests_failed++; } array = json_object_get_array(root_object, "x^2 array"); if (array != NULL) { for (i = 0; i < json_array_get_count(array); i++) { TEST(json_array_get_number(array, i) == (i * i)); } } else { tests_failed++; } TEST(json_object_get_array(root_object, "non existent array") == NULL); TEST(STREQ(json_object_dotget_string(root_object, "object.nested string"), "str")); TEST(json_object_dotget_boolean(root_object, "object.nested true") == 1); TEST(json_object_dotget_boolean(root_object, "object.nested false") == 0); TEST(json_object_dotget_value(root_object, "object.nested null") != NULL); TEST(json_object_dotget_number(root_object, "object.nested number") == 123); TEST(json_object_dotget_value(root_object, "should.be.null") == NULL); TEST(json_object_dotget_value(root_object, "should.be.null.") == NULL); TEST(json_object_dotget_value(root_object, ".") == NULL); TEST(json_object_dotget_value(root_object, "") == NULL); array = json_object_dotget_array(root_object, "object.nested array"); if (array != NULL && json_array_get_count(array) > 1) { TEST(STREQ(json_array_get_string(array, 0), "lorem")); TEST(STREQ(json_array_get_string(array, 1), "ipsum")); } else { tests_failed++; } TEST(json_object_dotget_boolean(root_object, "nested true")); TEST(STREQ(json_object_get_string(root_object, "/**/"), "comment")); TEST(STREQ(json_object_get_string(root_object, "//"), "comment")); }
/* Testing correctness of parsed values */ void test_suite_2(void) { JSON_Value *root_value; JSON_Object *object; JSON_Array *array; int i; const char *filename = "tests/test_2.txt"; printf("Testing %s:\n", filename); root_value = json_parse_file(filename); TEST(root_value); TEST(json_value_get_type(root_value) == JSONObject); object = json_value_get_object(root_value); TEST(STREQ(json_object_get_string(object, "string"), "lorem ipsum")); TEST(STREQ(json_object_get_string(object, "utf string"), "lorem ipsum")); TEST(json_object_get_number(object, "positive one") == 1.0); TEST(json_object_get_number(object, "negative one") == -1.0); TEST(json_object_get_number(object, "hard to parse number") == -0.000314); TEST(json_object_get_boolean(object, "boolean true") == 1); TEST(json_object_get_boolean(object, "boolean false") == 0); TEST(json_value_get_type(json_object_get_value(object, "null")) == JSONNull); array = json_object_get_array(object, "string array"); if (array != NULL && json_array_get_count(array) > 1) { TEST(STREQ(json_array_get_string(array, 0), "lorem")); TEST(STREQ(json_array_get_string(array, 1), "ipsum")); } else { tests_failed++; } array = json_object_get_array(object, "x^2 array"); if (array != NULL) { for (i = 0; i < json_array_get_count(array); i++) { TEST(json_array_get_number(array, i) == (i * i)); } } else { tests_failed++; } TEST(json_object_get_array(object, "non existent array") == NULL); TEST(STREQ(json_object_dotget_string(object, "object.nested string"), "str")); TEST(json_object_dotget_boolean(object, "object.nested true") == 1); TEST(json_object_dotget_boolean(object, "object.nested false") == 0); TEST(json_object_dotget_value(object, "object.nested null") != NULL); TEST(json_object_dotget_number(object, "object.nested number") == 123); TEST(json_object_dotget_value(object, "should.be.null") == NULL); TEST(json_object_dotget_value(object, "should.be.null.") == NULL); TEST(json_object_dotget_value(object, ".") == NULL); TEST(json_object_dotget_value(object, "") == NULL); array = json_object_dotget_array(object, "object.nested array"); if (array != NULL && json_array_get_count(array) > 1) { TEST(STREQ(json_array_get_string(array, 0), "lorem")); TEST(STREQ(json_array_get_string(array, 1), "ipsum")); } else { tests_failed++; } TEST(json_object_dotget_boolean(object, "nested true")); json_value_free(root_value); }
bud_error_t bud_config_load_frontend(JSON_Object* obj, bud_config_frontend_t* frontend) { JSON_Value* val; bud_config_load_addr(obj, (bud_config_addr_t*) frontend); frontend->max_send_fragment = -1; frontend->allow_half_open = -1; frontend->reneg_limit = -1; if (obj == NULL) return bud_ok(); frontend->security = json_object_get_string(obj, "security"); frontend->reneg_window = json_object_get_number(obj, "reneg_window"); val = json_object_get_value(obj, "reneg_limit"); if (val != NULL) frontend->reneg_limit = json_value_get_number(val); val = json_object_get_value(obj, "max_send_fragment"); if (val != NULL) frontend->max_send_fragment = json_value_get_number(val); val = json_object_get_value(obj, "allow_half_open"); if (val != NULL) frontend->allow_half_open = json_value_get_boolean(val); return bud_config_load_frontend_ifaces(obj, &frontend->interface); }
bud_error_t bud_config_load_frontend(JSON_Object* obj, bud_config_frontend_t* frontend) { bud_error_t err; JSON_Value* val; bud_config_load_addr(obj, (bud_config_addr_t*) frontend); frontend->server_preference = -1; frontend->ssl3 = -1; frontend->max_send_fragment = -1; frontend->allow_half_open = -1; if (obj == NULL) return bud_ok(); frontend->security = json_object_get_string(obj, "security"); frontend->ciphers = json_object_get_string(obj, "ciphers"); frontend->ecdh = json_object_get_string(obj, "ecdh"); frontend->cert_file = json_object_get_string(obj, "cert"); frontend->key_file = json_object_get_string(obj, "key"); frontend->reneg_window = json_object_get_number(obj, "reneg_window"); frontend->reneg_limit = json_object_get_number(obj, "reneg_limit"); frontend->ticket_key = json_object_get_string(obj, "ticket_key"); /* Get and verify NPN */ frontend->npn = json_object_get_array(obj, "npn"); err = bud_config_verify_npn(frontend->npn); if (!bud_is_ok(err)) goto fatal; val = json_object_get_value(obj, "server_preference"); if (val != NULL) frontend->server_preference = json_value_get_boolean(val); val = json_object_get_value(obj, "ssl3"); if (val != NULL) frontend->ssl3 = json_value_get_boolean(val); val = json_object_get_value(obj, "max_send_fragment"); if (val != NULL) frontend->max_send_fragment = json_value_get_number(val); val = json_object_get_value(obj, "allow_half_open"); if (val != NULL) frontend->allow_half_open = json_value_get_boolean(val); fatal: return err; }
// retrieves the balancer url with the lowest load, if there are several balancers with the same load one of these is randomly selected static char *GetBalancerUrl(void) { char *bestUrl = NULL; char *balance = GetUrl(URL_BALANCE); if (balance != NULL) { JSON_Value *rootJson = json_parse_string(balance); free(balance); balance = NULL; if (rootJson != NULL && rootJson->type == JSONObject) { JSON_Object *serversJson = json_value_get_object(rootJson); if (serversJson != NULL) { size_t serverCount = json_object_get_count(serversJson); int bestLoad = 0; for (int i = 0; i < serverCount; i++) { const char *url = json_object_get_name(serversJson, i); JSON_Value *value = json_object_get_value(serversJson, url); if (value != NULL && value->type == JSONNumber) { int load = (int) json_object_get_number(serversJson, url); if (load != 0 && (bestUrl == NULL || load <= bestLoad/* || (load == bestLoad && rand() % 2)*/)) { if (bestUrl != NULL) { free(bestUrl); bestUrl = NULL; } bestUrl = (char*) malloc(strlen(url) + 1); if (bestUrl != NULL) strcpy(bestUrl, url); bestLoad = load; } } } } json_value_free(rootJson); rootJson = NULL; } } return bestUrl; }
void test_suite_precincts(JSON_Value *root_value) { JSON_Object *root_object; JSON_Array *array; TEST(root_value); TEST(json_value_get_type(root_value) == JSONObject); root_object = json_value_get_object(root_value); unsigned int number_of_precincts = (int) json_object_get_number(root_object, "number_of_precincts"); printf("number_of_precincts: %d\n", number_of_precincts); TEST(number_of_precincts == 60); array = json_object_get_array(root_object, "precincts"); if (array != NULL && json_array_get_count(array) == number_of_precincts) { JSON_Object *precinct_object; JSON_Array *layers_array; int id, coord_x, coord_y; unsigned int j; for(j = 0; j < number_of_precincts; j++) { precinct_object = json_array_get_object(array, j); id = (int) json_object_get_number(precinct_object, "id"); coord_x = (int) json_object_get_number(precinct_object, "coord_x"); coord_y = (int) json_object_get_number(precinct_object, "coord_y"); printf("id: %d \t coord_x: %d \t coord_y: %d\n", id, coord_x, coord_y); layers_array = json_object_get_array(precinct_object, "layers"); if (layers_array != NULL && json_array_get_count(layers_array) >= 1) { JSON_Object *layer_object; int ql, bytes, psnr; unsigned k; for(k = 0; k < json_array_get_count(layers_array); k++) { layer_object = json_array_get_object(layers_array, k); ql = (int) json_object_get_number(layer_object, "ql"); bytes = (int) json_object_get_number(layer_object, "bytes"); psnr = (int) json_object_get_number(layer_object, "psnr"); printf("\tql: %d \t bytes: %d \t psnr: %d\n", ql, bytes, psnr); } } else { } } } else { tests_failed++; } }
void bud_config_read_pool_conf(JSON_Object* obj, const char* key, bud_config_http_pool_t* pool) { JSON_Object* p; p = json_object_get_object(obj, key); if (p != NULL) { pool->enabled = json_object_get_boolean(p, "enabled"); pool->port = (uint16_t) json_object_get_number(p, "port"); pool->host = json_object_get_string(p, "host"); pool->query_fmt = json_object_get_string(p, "query"); } }
void bud_config_load_addr(JSON_Object* obj, bud_config_addr_t* addr) { JSON_Value* val; /* Backend configuration */ addr->keepalive = -1; if (obj == NULL) return; addr->port = (uint16_t) json_object_get_number(obj, "port"); addr->host = json_object_get_string(obj, "host"); val = json_object_get_value(obj, "keepalive"); if (val != NULL) addr->keepalive = json_value_get_number(val); }
int main(void) { int bytes_read; gchar buffer[MAX_BUFFER_SIZE]; JSON_Value *root_value; JSON_Object *root_object; gchar *json_str; gchar *func_name; gchar *path; while((bytes_read = read_msg(buffer)) > 0) { json_str = g_strndup((const gchar *)buffer, bytes_read); root_value = json_parse_string(json_str); root_object = json_value_get_object(root_value); func_name = (gchar *)json_object_get_string(root_object, "exec"); path = (gchar *)json_object_get_string(root_object, "path"); GString *json_message = NULL; if (!g_ascii_strcasecmp(func_name, "get_preview_json")) { json_message = gmimex_get_json(path, JSON_NO_MESSAGE_CONTENT); if (!json_message) { send_err(); } else { send_msg((gchar *)json_message->str, json_message->len); g_string_free(json_message, TRUE); } } else if (!g_ascii_strcasecmp(func_name, "get_json")) { gboolean raw = json_object_get_boolean(root_object, "raw"); json_message = gmimex_get_json(path, (raw ? JSON_RAW_MESSAGE_CONTENT : JSON_PREPARED_MESSAGE_CONTENT)); if (!json_message) { send_err(); } else { send_msg((gchar *)json_message->str, json_message->len); g_string_free(json_message, TRUE); } } else if (!g_ascii_strcasecmp(func_name, "get_part")) { int part_id = json_object_get_number(root_object, "partId"); GByteArray *part_content = gmimex_get_part(path, part_id); if (!part_content) { send_err(); } else { send_msg((gchar *)part_content->data, part_content->len); g_byte_array_free(part_content, TRUE); } } json_value_free(root_value); g_free(json_str); } return 0; }
int parse_blueprint_root(JSON_Object *root, blueprint bp) { bp->version = json_object_get_number(root, "Version"); bp->Name = bfromcstr(json_object_get_string(root, "Name")); JSON_Object *blueprint = json_object_get_object(root, "Blueprint"); if (blueprint == NULL) return 1; int retval; if ((retval = parse_blueprint_json(blueprint, bp)) != 0) return retval; return 0; }
int djcs_import_public_key(djcs_public_key *pk, const char *json) { JSON_Value *root = json_parse_string(json); JSON_Object *obj = json_value_get_object(root); pk->s = json_object_get_number(obj, "s"); pk->n = malloc(sizeof(mpz_t) * (pk->s + 1)); mpz_init(pk->n[0]); mpz_set_str(pk->n[0], json_object_get_string(obj, "n"), HCS_INTERNAL_BASE); json_value_free(root); /* Calculate remaining values */ mpz_add_ui(pk->g, pk->n[0], 1); for (unsigned long i = 1; i <= pk->s; ++i) { mpz_init_set(pk->n[i], pk->n[i-1]); mpz_mul(pk->n[i], pk->n[i], pk->n[0]); } return 0; }
int djcs_import_private_key(djcs_private_key *vk, const char *json) { JSON_Value *root = json_parse_string(json); JSON_Object *obj = json_value_get_object(root); vk->s = json_object_get_number(obj, "s"); vk->n = malloc(sizeof(mpz_t) * (vk->s + 1)); mpz_init(vk->n[0]); mpz_set_str(vk->n[0], json_object_get_string(obj, "n"), HCS_INTERNAL_BASE); mpz_set_str(vk->d, json_object_get_string(obj, "d"), HCS_INTERNAL_BASE); json_value_free(root); /* Calculate remaining values */ for (unsigned long i = 1; i <= vk->s; ++i) { mpz_init_set(vk->n[i], vk->n[i-1]); mpz_mul(vk->n[i], vk->n[i], vk->n[0]); } mpz_add_ui(vk->mu, vk->n[0], 1); mpz_powm(vk->mu, vk->mu, vk->d, vk->n[vk->s]); dlog_s(vk, vk->mu, vk->mu); mpz_invert(vk->mu, vk->mu, vk->n[vk->s-1]); return 0; }
static void* SimulatorModule_ParseConfigurationFromJson(const char* configuration) { SIMULATOR_MODULE_CONFIG * result; if (configuration == NULL) { LogError("Simulator module expects configuration"); result = NULL; } else { JSON_Value* json = json_parse_string((const char*)configuration); if (json == NULL) { LogError("unable to json_parse_string"); result = NULL; } else { JSON_Object* obj = json_value_get_object(json); if (obj == NULL) { LogError("unable to json_value_get_object"); result = NULL; } else { const char* deviceIdValue = json_object_get_string(obj, "deviceId"); if (deviceIdValue == NULL) { LogError("deviceId is a required field in configuration"); result = NULL; } else { result = (SIMULATOR_MODULE_CONFIG *)malloc(sizeof(SIMULATOR_MODULE_CONFIG)); if (result == NULL) { LogError("Could not allocated Module data"); } else { if (mallocAndStrcpy_s(&(result->device_id), deviceIdValue) != 0) { LogError("could not allocate memory for deviceID string"); free(result); result = NULL; } else { result->message_delay = 0; result->message_size = 256; result->properties_count = 2; result->properties_size = 16; if (json_object_has_value_of_type(obj, "message.delay", JSONNumber)) { result->message_delay = static_cast<unsigned int>(json_object_get_number(obj, "message.delay")); } double message_size_value = json_object_get_number(obj, "message.size"); if (message_size_value > 0) { result->message_size = static_cast<unsigned int>(message_size_value); } double properties_count_value = json_object_get_number(obj, "properties.count"); if (properties_count_value > 0) { result->properties_count = static_cast<unsigned int>(properties_count_value); } double properties_size_value = json_object_get_number(obj, "properties.size"); if (properties_size_value > 0) { result->properties_size = static_cast<unsigned int>(properties_size_value); } } } } } json_value_free(json); } } return result; }
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; }
bud_config_t* bud_config_load(uv_loop_t* loop, const char* path, bud_error_t* err) { int i; int context_count; JSON_Value* json; JSON_Value* val; JSON_Object* obj; JSON_Object* log; JSON_Object* frontend; JSON_Object* backend; JSON_Array* contexts; bud_config_t* config; bud_context_t* ctx; json = json_parse_file(path); if (json == NULL) { *err = bud_error_str(kBudErrJSONParse, path); goto end; } obj = json_value_get_object(json); if (obj == NULL) { *err = bud_error(kBudErrJSONNonObjectRoot); goto failed_get_object; } contexts = json_object_get_array(obj, "contexts"); context_count = contexts == NULL ? 0 : json_array_get_count(contexts); config = calloc(1, sizeof(*config) + context_count * sizeof(*config->contexts)); if (config == NULL) { *err = bud_error_str(kBudErrNoMem, "bud_config_t"); goto failed_get_object; } config->loop = loop; config->json = json; /* Workers configuration */ config->worker_count = -1; config->restart_timeout = -1; val = json_object_get_value(obj, "workers"); if (val != NULL) config->worker_count = json_value_get_number(val); val = json_object_get_value(obj, "restart_timeout"); if (val != NULL) config->restart_timeout = json_value_get_number(val); /* Logger configuration */ log = json_object_get_object(obj, "log"); config->log.stdio = -1; config->log.syslog = -1; if (log != NULL) { config->log.level = json_object_get_string(log, "level"); config->log.facility = json_object_get_string(log, "facility"); val = json_object_get_value(log, "stdio"); if (val != NULL) config->log.stdio = json_value_get_boolean(val); val = json_object_get_value(log, "syslog"); if (val != NULL) config->log.syslog = json_value_get_boolean(val); } /* Frontend configuration */ frontend = json_object_get_object(obj, "frontend"); config->frontend.proxyline = -1; config->frontend.keepalive = -1; config->frontend.server_preference = -1; config->frontend.ssl3 = -1; if (frontend != NULL) { config->frontend.port = (uint16_t) json_object_get_number(frontend, "port"); config->frontend.host = json_object_get_string(frontend, "host"); config->frontend.security = json_object_get_string(frontend, "security"); config->frontend.npn = json_object_get_array(frontend, "npn"); config->frontend.ciphers = json_object_get_string(frontend, "ciphers"); config->frontend.cert_file = json_object_get_string(frontend, "cert"); config->frontend.key_file = json_object_get_string(frontend, "key"); config->frontend.reneg_window = json_object_get_number(frontend, "reneg_window"); config->frontend.reneg_limit = json_object_get_number(frontend, "reneg_limit"); *err = bud_config_verify_npn(config->frontend.npn); if (!bud_is_ok(*err)) goto failed_get_index; val = json_object_get_value(frontend, "proxyline"); if (val != NULL) config->frontend.proxyline = json_value_get_boolean(val); val = json_object_get_value(frontend, "keepalive"); if (val != NULL) config->frontend.keepalive = json_value_get_number(val); val = json_object_get_value(frontend, "server_preference"); if (val != NULL) config->frontend.server_preference = json_value_get_boolean(val); val = json_object_get_value(frontend, "ssl3"); if (val != NULL) config->frontend.ssl3 = json_value_get_boolean(val); } /* Backend configuration */ backend = json_object_get_object(obj, "backend"); config->backend.keepalive = -1; if (backend != NULL) { config->backend.port = (uint16_t) json_object_get_number(backend, "port"); config->backend.host = json_object_get_string(backend, "host"); val = json_object_get_value(backend, "keepalive"); if (val != NULL) config->backend.keepalive = json_value_get_number(val); } /* SNI configuration */ bud_config_read_pool_conf(obj, "sni", &config->sni); /* OCSP Stapling configuration */ bud_config_read_pool_conf(obj, "stapling", &config->stapling); /* SSL Contexts */ /* TODO(indutny): sort them and do binary search */ for (i = 0; i < context_count; i++) { /* NOTE: contexts[0] - is a default context */ ctx = &config->contexts[i + 1]; obj = json_array_get_object(contexts, i); if (obj == NULL) { *err = bud_error(kBudErrJSONNonObjectCtx); goto failed_get_index; } ctx->servername = json_object_get_string(obj, "servername"); ctx->servername_len = ctx->servername == NULL ? 0 : strlen(ctx->servername); ctx->cert_file = json_object_get_string(obj, "cert"); ctx->key_file = json_object_get_string(obj, "key"); ctx->npn = json_object_get_array(obj, "npn"); ctx->ciphers = json_object_get_string(obj, "ciphers"); *err = bud_config_verify_npn(ctx->npn); if (!bud_is_ok(*err)) goto failed_get_index; } config->context_count = context_count; bud_config_set_defaults(config); *err = bud_ok(); return config; failed_get_index: free(config); failed_get_object: json_value_free(json); end: return NULL; }
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; }
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_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_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; }