common/fido_json_handler.c

   1 /*
   2  * Copyright (c) 2014 - 2015 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18
  19 #include <string.h>
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #include <dlog.h>
  23 #include <glib.h>
  24 #if !GLIB_CHECK_VERSION (2, 31, 0)
  25 #include <glib/gmacros.h>
  26 #endif
  27 #include <json-glib/json-glib.h>
  28 #include "fido_internal_types.h"
  29 #include "fido_json_handler.h"
  30 #include "fido_keys.h"
  31 #include "fido_logs.h"
  32 #include "fido_uaf_types.h"
  33 #include "fido_b64_util.h"
  34 #include "fido_tlv_util.h"
  35
  36 /*JSON keys start*/
  37 #define _JSON_KEY_ID "id"
  38 #define _JSON_KEY_DATA "data"
  39 #define _JSON_KEY_FAIL_IF_UNKNOWN "fail_if_unknown"
  40 #define _JSON_KEY_EXTS "exts"
  41 #define _JSON_KEY_UPV "upv"
  42 #define _JSON_KEY_MAJOR "major"
  43 #define _JSON_KEY_MINOR "minor"
  44 #define _JSON_KEY_OP "op"
  45 #define _JSON_KEY_APPID "appID"
  46 #define _JSON_KEY_SERVER_DATA "serverData"
  47 #define _JSON_KEY_AAID "aaid"
  48 #define _JSON_KEY_VENDOR_ID "vendorID"
  49 #define _JSON_KEY_KEY_IDS "keyIDs"
  50 #define _JSON_KEY_USER_VERIFICATION "userVerification"
  51 #define _JSON_KEY_KEY_PROTECTION "keyProtection"
  52 #define _JSON_KEY_MATCHER_PROTECTION "matcherProtection"
  53 #define _JSON_KEY_ATTACHMENT_HINT "attachmentHint"
  54 #define _JSON_KEY_TC_DISPLAY "tcDisplay"
  55 #define _JSON_KEY_AUTH_ALGOS "authenticationAlgorithms"
  56 #define _JSON_KEY_AUTH_ALGO "authenticationAlgorithm"
  57 #define _JSON_KEY_ASSERT_SCHEMES "assertionSchemes"
  58 #define _JSON_KEY_ATT_TYPES "attestationTypes"
  59 #define _JSON_KEY_ATT_TYPE "attestationType"
  60 #define _JSON_KEY_AUTH_VERSION "authenticatorVersion"
  61 #define _JSON_KEY_PLTE "plte"
  62 #define _JSON_KEY_R "r"
  63 #define _JSON_KEY_G "g"
  64 #define _JSON_KEY_B "b"
  65 #define _JSON_KEY_WIDTH "width"
  66 #define _JSON_KEY_HEIGHT "height"
  67 #define _JSON_KEY_BIT_DEPTH "bitDepth"
  68 #define _JSON_KEY_COLOR_TYPE "colorType"
  69 #define _JSON_KEY_COMPRESSION "compression"
  70 #define _JSON_KEY_FILTER "filter"
  71 #define _JSON_KEY_INTERLACE "interlace"
  72 #define _JSON_KEY_TC_DISP_PNG_CHARS "tcDisplayPNGCharacteristics"
  73 #define _JSON_KEY_RESP_DATA "responseData"
  74 #define _JSON_KEY_AUTHENTICATORS "Authenticators"
  75 #define _JSON_KEY_AUTHENTICATORS_SMALL "authenticators"
  76 #define _JSON_KEY_AUTH_INDEX "authenticatorIndex"
  77 #define _JSON_KEY_IS_USER_ENROLLED "isUserEnrolled"
  78 #define _JSON_KEY_HAS_SETTINGS "hasSettings"
  79 #define _JSON_KEY_AAID "aaid"
  80 #define _JSON_KEY_IS_2_FACTOR_ONLY "isSecondFactorOnly"
  81 #define _JSON_KEY_IS_ROAMING_AUTH "isRoamingAuthenticator"
  82 #define _JSON_KEY_SUPPORTED_EXT_IDS "supportedExtensionIDs"
  83 #define _JSON_KEY_TC_DISP_CONTENT_TYPE "tcDisplayContentType"
  84 #define _JSON_KEY_TITLE "title"
  85 #define _JSON_KEY_DESC "description"
  86 #define _JSON_KEY_ICON "icon"
  87 #define _JSON_KEY_STATUS_CODE "statusCode"
  88 #define _JSON_KEY_ASSERTION "assertion"
  89 #define _JSON_KEY_ASSERT_SCHEME "assertionScheme"
  90 #define _JSON_KEY_CHALLENGE "challenge"
  91 #define _JSON_KEY_CH_BINDING "channelBinding"
  92 #define _JSON_KEY_SERVER_END_POINT "serverEndPoint"
  93 #define _JSON_KEY_TLS_SERVER_CERT "tlsServerCertificate"
  94 #define _JSON_KEY_TLS_UNIQUE "tlsUnique"
  95 #define _JSON_KEY_CID_PUB_KEY "cid_pubkey"
  96 #define _JSON_KEY_FACET_ID "facetID"
  97 #define _JSON_KEY_HEADER "header"
  98 #define _JSON_KEY_FC_PARAMS "fcParams"
  99 #define _JSON_KEY_FINAL_CHALLENGE               "finalChallenge"
 100 #define _JSON_KEY_ASSERTIONS "assertions"
 101 #define _JSON_KEY_POLICY "policy"
 102 #define _JSON_KEY_ACCEPTED "accepted"
 103 #define _JSON_KEY_DISALLOWED "disallowed"
 104 #define _JSON_KEY_USER_NAME "username"
 105 #define _JSON_KEY_TRUSTED_FACETS "trustedFacets"
 106 #define _JSON_KEY_VERSION "version"
 107 #define _JSON_KEY_IDS "ids"
 108 #define _JSON_KEY_APP_REGS "appRegs"
 109 #define _JSON_KEY_REQ_TYPE      "requestType"
 110 #define _JSON_KEY_KEY_ID                "keyID"
 111 #define _JSON_KEY_TRANSACTION           "transaction"
 112 #define _JSON_KEY_CONTENT_TYPE "contentType"
 113 #define _JSON_KEY_CONTENT "content"
 114 #define _JSON_KEY_REGISTER              "Register"
 115 #define _JSON_KEY_AUTHENTICATE  "Authenticate"
 116 #define _JSON_KEY_DEREGISTER            "Deregister"
 117 #define _JSON_KEY_ASM_VERSION "asmVersion"
 118 #define _JSON_KEY_GET_REGS "GetRegistrations"
 119 #define _JSON_KEY_KTY "kty"
 120 #define _JSON_KEY_CRV "crv"
 121 #define _JSON_KEY_X "x"
 122 #define _JSON_KEY_Y "y"
 123 #define _JSON_KEY_ARGS          "args"
 124
 125 #define _JSON_KEY_VENDOR "vendor"
 126 #define _JSON_KEY_BIN_PATH "bin_path"
 127 #define _JSON_KEY_DBUS_INFO "dbus_info"
 128 #define _JSON_KEY_DBUS_OBJ_PATH "dbus_obj_path"
 129 #define _JSON_KEY_DBUS_INTF_NAME "dbus_interface_name"
 130 #define _JSON_KEY_DBUS_METHOD_NAME "dbus_method_name"
 131 /*JSON keys end*/
 132
 133 static void
 134 __add_string_to_json_object(JsonBuilder *json_obj, const char *key, const char *val)
 135 {
 136     if (key == NULL || val == NULL)
 137         return;
 138
 139     json_builder_set_member_name(json_obj, key);
 140     json_builder_add_string_value(json_obj, val);
 141 }
 142
 143 static void
 144 __add_int_to_json_object(JsonBuilder *json_obj, const char *key, int val)
 145 {
 146     if (key == NULL || val == _INVALID_INT)
 147         return;
 148
 149     json_builder_set_member_name(json_obj, key);
 150     json_builder_add_int_value(json_obj, val);
 151 }
 152
 153 static char*
 154 __get_string_from_json_object(JsonObject *obj, const char *key)
 155 {
 156     _INFO("__get_string_from_json_object [%s]", key);
 157
 158     if (json_object_has_member(obj, key) == false)
 159         return NULL;
 160
 161     const char *str = json_object_get_string_member(obj, key);
 162     _INFO("[%s] = [%s]", key, str);
 163
 164     return strdup(str);
 165 }
 166
 167 static int
 168 __get_int_from_json_object(JsonObject *obj, const char *key)
 169 {
 170     if (obj == NULL)
 171         return _INVALID_INT;
 172
 173     if (json_object_has_member(obj, key) == false)
 174         return _INVALID_INT;
 175
 176     int int_val = json_object_get_int_member(obj, key);
 177     dlog_print(DLOG_INFO, "FIDO", "[%s] = [%d]", key, int_val);
 178
 179     return int_val;
 180 }
 181
 182 static _extension_t *
 183 __get_extension(JsonObject *ext_json_obj)
 184 {
 185     RET_IF_FAIL(ext_json_obj != NULL, NULL);
 186
 187     _extension_t *ext = (_extension_t*) calloc(1, sizeof(_extension_t));
 188     RET_IF_FAIL(ext != NULL, NULL);
 189
 190     ext->id = __get_string_from_json_object(ext_json_obj, _JSON_KEY_ID);
 191     ext->data = __get_string_from_json_object(ext_json_obj, _JSON_KEY_DATA);
 192     ext->fail_if_unknown = json_object_get_boolean_member(ext_json_obj, _JSON_KEY_FAIL_IF_UNKNOWN);
 193
 194     return ext;
 195
 196 }
 197
 198 static GList *
 199 __get_extension_list(JsonObject *root_obj)
 200 {
 201     RET_IF_FAIL(root_obj != NULL, NULL);
 202
 203     JsonArray *ext_json_arr = json_object_get_array_member(root_obj, _JSON_KEY_EXTS);
 204     RET_IF_FAIL(ext_json_arr != NULL, NULL);
 205
 206     int ext_arr_len = json_array_get_length(ext_json_arr);
 207     RET_IF_FAIL(ext_arr_len > 0, NULL);
 208
 209     GList *ext_list = NULL;
 210
 211     int i = 0;
 212     for (; i < ext_arr_len; i++) {
 213         JsonObject *ext_json_obj = json_array_get_object_element(ext_json_arr, i);
 214         if (ext_json_obj != NULL) {
 215             _extension_t *ext = __get_extension(ext_json_obj);
 216             if (ext != NULL)
 217                 ext_list = g_list_append(ext_list, ext);
 218         }
 219     }
 220
 221     return ext_list;
 222 }
 223
 224 static _op_header_t*
 225 __parse_uaf_header(JsonObject *header_obj)
 226 {
 227     _INFO("__parse_uaf_header");
 228
 229     _op_header_t *header = (_op_header_t *)calloc(1, sizeof(_op_header_t));
 230
 231     header->version = (_version_t *)calloc(1, sizeof(_version_t));
 232
 233     JsonObject *ver_obj = json_object_get_object_member(header_obj, _JSON_KEY_UPV);
 234     if (ver_obj == NULL) {
 235         _free_op_header(header);
 236         return NULL;
 237     }
 238
 239     int major = __get_int_from_json_object(ver_obj, _JSON_KEY_MAJOR);
 240     int minor = __get_int_from_json_object(ver_obj, _JSON_KEY_MINOR);
 241
 242     if (major == _INVALID_INT || minor == _INVALID_INT) {
 243
 244         _free_op_header(header);
 245         return NULL;
 246     }
 247
 248     _INFO("found valid version");
 249
 250     header->version->major = major;
 251     header->version->minor = minor;
 252
 253     header->operation = __get_string_from_json_object(header_obj, _JSON_KEY_OP);
 254
 255     header->app_id = __get_string_from_json_object(header_obj, _JSON_KEY_APPID);
 256
 257     header->server_data = __get_string_from_json_object(header_obj, _JSON_KEY_SERVER_DATA);
 258
 259     header->ext_list = __get_extension_list(header_obj);
 260
 261     return header;
 262 }
 263
 264 static GList *
 265 __get_string_list_from_json_array(JsonArray *json_arr)
 266 {
 267     if (json_arr == NULL)
 268         return NULL;
 269
 270     GList *list = NULL;
 271
 272     int arr_len = json_array_get_length(json_arr);
 273     int i = 0;
 274     for (; i < arr_len; i++) {
 275         const char *str = json_array_get_string_element(json_arr, i);
 276         if (str != NULL)
 277             list = g_list_append(list, strdup(str));
 278
 279     }
 280
 281     return list;
 282 }
 283
 284 static GList *
 285 __get_int_list_from_json_array(JsonArray *json_arr)
 286 {
 287     if (json_arr == NULL)
 288         return NULL;
 289
 290     GList *list = NULL;
 291
 292     int arr_len = json_array_get_length(json_arr);
 293     int i = 0;
 294     for (; i < arr_len; i++) {
 295         int val = json_array_get_int_element(json_arr, i);
 296         list = g_list_append(list, GINT_TO_POINTER(val));
 297
 298     }
 299
 300     return list;
 301 }
 302
 303 static _match_criteria_t*
 304 _uaf_parser_parse_match(JsonObject *match_obj)
 305 {
 306     _INFO("_uaf_parser_parse_match");
 307
 308     if (match_obj != NULL) {
 309
 310         _match_criteria_t *match_criteria = (_match_criteria_t*)calloc(1, sizeof(_match_criteria_t));
 311
 312         JsonArray *aaid_arr = json_object_get_array_member(match_obj, _JSON_KEY_AAID);
 313         if (aaid_arr != NULL) {
 314             match_criteria->aaid_list = __get_string_list_from_json_array(aaid_arr);
 315         }
 316
 317         JsonArray *vendor_arr = json_object_get_array_member(match_obj, _JSON_KEY_VENDOR_ID);
 318         if (vendor_arr != NULL) {
 319             match_criteria->vendor_list = __get_string_list_from_json_array(vendor_arr);
 320         }
 321
 322         JsonArray *key_id_arr = json_object_get_array_member(match_obj, _JSON_KEY_KEY_IDS);
 323         if (key_id_arr != NULL) {
 324             match_criteria->key_id_list = __get_string_list_from_json_array(key_id_arr);
 325         }
 326
 327         match_criteria->user_verification = __get_int_from_json_object(match_obj, _JSON_KEY_USER_VERIFICATION);
 328
 329         match_criteria->key_protection = __get_int_from_json_object(match_obj, _JSON_KEY_KEY_PROTECTION);
 330
 331         match_criteria->matcher_protection = __get_int_from_json_object(match_obj, _JSON_KEY_MATCHER_PROTECTION);
 332
 333         match_criteria->attachement_hint = __get_int_from_json_object(match_obj, _JSON_KEY_ATTACHMENT_HINT);
 334
 335         match_criteria->tc_display = __get_int_from_json_object(match_obj, _JSON_KEY_TC_DISPLAY);
 336
 337
 338         JsonArray *auth_algo_arr = json_object_get_array_member(match_obj, _JSON_KEY_AUTH_ALGOS);
 339         if (auth_algo_arr) {
 340             match_criteria->auth_algo_list = __get_int_list_from_json_array(auth_algo_arr);
 341                 }
 342
 343         JsonArray *assertion_schm_arr = json_object_get_array_member(match_obj, _JSON_KEY_ASSERT_SCHEMES);
 344         if (assertion_schm_arr) {
 345             match_criteria->assertion_scheme_list = __get_string_list_from_json_array(assertion_schm_arr);
 346                 }
 347
 348         JsonArray *att_type_arr = json_object_get_array_member(match_obj, _JSON_KEY_ATT_TYPES);
 349         if (att_type_arr) {
 350             match_criteria->attestation_type_list = __get_string_list_from_json_array(att_type_arr);
 351         }
 352
 353         match_criteria->auth_version = __get_int_from_json_object(match_obj, _JSON_KEY_AUTH_VERSION);
 354
 355         _INFO("_uaf_parser_parse_match is returning match_criteria");
 356
 357         return match_criteria;
 358         }
 359
 360     _INFO("_uaf_parser_parse_match is returning NULL");
 361     return NULL;
 362 }
 363
 364 static GList*
 365 __get_plte_list(JsonObject *png_json_obj)
 366 {
 367
 368     _INFO("");
 369
 370     GList *plte_list_priv = NULL;
 371
 372     JsonArray *plte_json_arr = json_object_get_array_member(png_json_obj, "plte");
 373     RET_IF_FAIL(plte_json_arr != NULL, NULL);
 374
 375     int plte_arr_len = json_array_get_length(plte_json_arr);
 376     RET_IF_FAIL(plte_arr_len > 0, NULL);
 377
 378     int i = 0;
 379     for (; i < plte_arr_len; i++) {
 380         JsonObject *plte_json_obj = json_array_get_object_element(plte_json_arr, i);
 381         if (plte_json_obj != NULL) {
 382             fido_rgb_pallette_entry_s *pallete =
 383                     (fido_rgb_pallette_entry_s *) calloc(1, sizeof(fido_rgb_pallette_entry_s));
 384
 385             if (pallete != NULL) {
 386                 pallete->r = __get_int_from_json_object(plte_json_obj, _JSON_KEY_R);
 387                 pallete->g = __get_int_from_json_object(plte_json_obj, _JSON_KEY_G);
 388                 pallete->b = __get_int_from_json_object(plte_json_obj, _JSON_KEY_B);
 389
 390                 plte_list_priv = g_list_append(plte_list_priv, pallete);
 391             }
 392
 393         }
 394     }
 395
 396     if (plte_list_priv == NULL)
 397         return NULL;
 398
 399     plte_list_priv = g_list_first(plte_list_priv);
 400
 401     _INFO("");
 402
 403     return plte_list_priv;
 404 }
 405
 406 static fido_display_png_characteristics_descriptor_s *
 407 __get_png_data(JsonObject *png_json_obj)
 408 {
 409     RET_IF_FAIL(png_json_obj != NULL, NULL);
 410
 411     _INFO("");
 412
 413     fido_display_png_characteristics_descriptor_s *png_data = (fido_display_png_characteristics_descriptor_s*)
 414             calloc(1, sizeof(fido_display_png_characteristics_descriptor_s));
 415
 416     png_data->width = __get_int_from_json_object(png_json_obj, _JSON_KEY_WIDTH);
 417     png_data->height = __get_int_from_json_object(png_json_obj, _JSON_KEY_HEIGHT);
 418     png_data->bit_depth = __get_int_from_json_object(png_json_obj, _JSON_KEY_BIT_DEPTH);
 419     png_data->color_type = __get_int_from_json_object(png_json_obj, _JSON_KEY_COLOR_TYPE);
 420     png_data->compression = __get_int_from_json_object(png_json_obj, _JSON_KEY_COMPRESSION);
 421     png_data->filter = __get_int_from_json_object(png_json_obj, _JSON_KEY_FILTER);
 422     png_data->interlace = __get_int_from_json_object(png_json_obj, _JSON_KEY_INTERLACE);
 423
 424     png_data->plte = __get_plte_list(png_json_obj);
 425
 426     _INFO("");
 427     return png_data;
 428 }
 429
 430 static GList *
 431 __get_tc_disp_png_array(JsonObject *auth_obj)
 432 {
 433     RET_IF_FAIL(auth_obj != NULL, NULL);
 434
 435     JsonArray *png_arr_json = json_object_get_array_member(auth_obj, _JSON_KEY_TC_DISP_PNG_CHARS);
 436     RET_IF_FAIL(png_arr_json != NULL, NULL);
 437
 438     int arr_len = json_array_get_length(png_arr_json);
 439     RET_IF_FAIL(arr_len > 0, NULL);
 440
 441     GList *png_list = NULL;
 442     int i = 0;
 443     for (; i < arr_len; i++) {
 444         JsonObject *png_json_obj = json_array_get_object_element(png_arr_json, i);
 445         if (png_json_obj != NULL) {
 446
 447             fido_display_png_characteristics_descriptor_s *png = __get_png_data(png_json_obj);
 448             if (png != NULL)
 449                 png_list = g_list_append(png_list, png);
 450         }
 451     }
 452
 453
 454     return png_list;
 455 }
 456
 457 GList*
 458 _uaf_parser_parse_asm_response_discover_client(char **asm_response_list, int len, int *error_code)
 459 {
 460     _INFO("_uaf_parser_parse_asm_response_discover start");
 461
 462     RET_IF_FAIL(asm_response_list != NULL, NULL);
 463
 464     GList *available_authenticators = NULL;
 465
 466     int i = 0;
 467     for (; i < len; i++) {
 468
 469         JsonParser *parser = json_parser_new();
 470         CATCH_IF_FAIL(parser != NULL);
 471
 472         GError *parse_err = NULL;
 473         json_parser_load_from_data(parser, asm_response_list[i], -1, &parse_err);
 474         CATCH_IF_FAIL(parse_err == NULL);
 475
 476         JsonNode *root = json_parser_get_root(parser);
 477         CATCH_IF_FAIL(root != NULL);
 478
 479         JsonObject *root_obj = json_node_get_object(root);
 480         CATCH_IF_FAIL(root_obj != NULL);
 481
 482         int err_temp = 0;
 483         err_temp = json_object_get_int_member(root_obj, _JSON_KEY_STATUS_CODE);
 484
 485         *error_code = err_temp;
 486         CATCH_IF_FAIL(*error_code == 0);
 487
 488         JsonObject *response_obj = json_object_get_object_member(root_obj, _JSON_KEY_RESP_DATA);
 489         CATCH_IF_FAIL(response_obj != NULL);
 490
 491         JsonArray *auth_arr = json_object_get_array_member(response_obj, _JSON_KEY_AUTHENTICATORS);
 492         CATCH_IF_FAIL(auth_arr != NULL);
 493
 494         int auth_arr_len = json_array_get_length(auth_arr);
 495
 496         int auth_arr_index = 0;
 497         for (auth_arr_index = 0; auth_arr_index < auth_arr_len; auth_arr_index++) {
 498             JsonObject *auth_obj = json_array_get_object_element(auth_arr, auth_arr_index);
 499             if (auth_obj != NULL) {
 500                 fido_authenticator_s *auth_info = (fido_authenticator_s *)calloc(1, sizeof(fido_authenticator_s));
 501
 502
 503                 int auth_index = json_object_get_int_member(auth_obj, _JSON_KEY_AUTH_INDEX);
 504                 char *auth_idx_str = (char*)calloc(1, 128);
 505                 snprintf(auth_idx_str, 127, "%d", auth_index);
 506
 507                 auth_info->auth_index = auth_idx_str;
 508                 _INFO("auth_info->auth_index = [%s]", auth_info->auth_index);
 509
 510
 511                 /* FIXME : ASM version list */
 512
 513                 bool is_enrolled = json_object_get_boolean_member(auth_obj, _JSON_KEY_IS_USER_ENROLLED);
 514                 auth_info->is_user_enrolled = is_enrolled;
 515
 516                 bool has_settings = json_object_get_boolean_member(auth_obj, _JSON_KEY_HAS_SETTINGS);
 517                 auth_info->has_settings = has_settings;
 518
 519
 520                 const char *aaid = json_object_get_string_member(auth_obj, _JSON_KEY_AAID);
 521                 if (aaid != NULL) {
 522                     auth_info->aaid = strdup(aaid);
 523                     _INFO("auth_info->aaid = [%s]", auth_info->aaid);
 524                 }
 525
 526
 527                 const char *assertion_schm = json_object_get_string_member(auth_obj, _JSON_KEY_ASSERT_SCHEME);
 528                 if (assertion_schm != NULL)
 529                     auth_info->assertion_scheme = strdup(assertion_schm);
 530
 531                 int auth_algo  = json_object_get_int_member(auth_obj, _JSON_KEY_AUTH_ALGO);
 532                 auth_info->authentication_algorithm = auth_algo;
 533
 534                 GList *att_list = NULL;
 535                 JsonArray *att_arr = json_object_get_array_member(auth_obj, _JSON_KEY_ATT_TYPES);
 536                 if (att_arr != NULL) {
 537                     int att_arr_len = json_array_get_length(att_arr);
 538                     int att_arr_idx = 0;
 539                     for (att_arr_idx = 0; att_arr_idx < att_arr_len; att_arr_idx++) {
 540                         int att = json_array_get_int_element(att_arr, att_arr_idx);
 541                         att_list = g_list_append(att_list, GINT_TO_POINTER(att));
 542                     }
 543                 }
 544
 545                 if (att_list != NULL)
 546                     auth_info->attestation_types = g_list_first(att_list);
 547
 548                 int user_verification  = json_object_get_int_member(auth_obj, _JSON_KEY_USER_VERIFICATION);
 549                 auth_info->user_verification = user_verification;
 550
 551                 int key_prot  = json_object_get_int_member(auth_obj, _JSON_KEY_KEY_PROTECTION);
 552                 auth_info->key_protection = key_prot;
 553
 554
 555                 int matcher_prot  = json_object_get_int_member(auth_obj, _JSON_KEY_MATCHER_PROTECTION);
 556                 auth_info->matcher_protection = matcher_prot;
 557
 558                 int attch_hint  = json_object_get_int_member(auth_obj, _JSON_KEY_ATTACHMENT_HINT);
 559                 auth_info->attachment_hint = attch_hint;
 560
 561
 562                 bool is_sec_only  = json_object_get_boolean_member(auth_obj, _JSON_KEY_IS_2_FACTOR_ONLY);
 563                 auth_info->is_second_factor_only = is_sec_only;
 564
 565
 566                 bool is_roaming  = json_object_get_boolean_member(auth_obj, _JSON_KEY_IS_ROAMING_AUTH);
 567                 auth_info->is_roaming = is_roaming;
 568
 569
 570                 JsonArray *ext_id_json_arr = json_object_get_array_member(auth_obj, _JSON_KEY_SUPPORTED_EXT_IDS);
 571                 if (ext_id_json_arr != NULL)
 572                     auth_info->supported_extension_IDs = __get_string_list_from_json_array(ext_id_json_arr);
 573
 574
 575                 int tc_disp  = json_object_get_int_member(auth_obj, _JSON_KEY_TC_DISPLAY);
 576                 auth_info->tc_display = tc_disp;
 577
 578                 const char *tc_dis_type = json_object_get_string_member(auth_obj, _JSON_KEY_TC_DISP_CONTENT_TYPE);
 579                 if (tc_dis_type != NULL)
 580                     auth_info->tc_display_content_type = strdup(tc_dis_type);
 581
 582
 583                 auth_info->tc_display_png_characteristics = __get_tc_disp_png_array(auth_obj);
 584
 585                 const  char *title = json_object_get_string_member(auth_obj, _JSON_KEY_TITLE);
 586                 if (title != NULL)
 587                     auth_info->title = strdup(title);
 588
 589
 590                 const char *desc = json_object_get_string_member(auth_obj, _JSON_KEY_DESC);
 591                 if (desc != NULL)
 592                     auth_info->description = strdup(desc);
 593
 594
 595                 const char *icon  = json_object_get_string_member(auth_obj, _JSON_KEY_ICON);
 596                 if (icon != NULL)
 597                     auth_info->icon = strdup(icon);
 598
 599                 /* Supported UAF versions is fixed to 1.0*/
 600                  fido_version_s *version = calloc(1, sizeof(fido_version_s));
 601                  version->major = _VERSION_MAJOR;
 602                  version->minor = _VERSION_MINOR;
 603
 604                  auth_info->supported_versions = g_list_append(auth_info->supported_versions, version);
 605
 606                  available_authenticators = g_list_append(available_authenticators, auth_info);
 607             }
 608         }
 609
 610         if (parser != NULL)
 611             g_object_unref(parser);
 612
 613     }
 614
 615
 616     available_authenticators = g_list_first(available_authenticators);
 617
 618     _INFO("available_authenticators count = [%d]", g_list_length(available_authenticators));
 619
 620     return available_authenticators;
 621
 622 CATCH:
 623     return NULL;
 624 }
 625
 626 GList*
 627 _uaf_parser_parse_asm_response_discover(GList *asm_response_list, int *error_code)
 628 {
 629     _INFO("_uaf_parser_parse_asm_response_discover start");
 630
 631     RET_IF_FAIL(asm_response_list != NULL, NULL);
 632
 633     GList *available_authenticators = NULL;
 634
 635     GList *asm_response_list_iter = g_list_first(asm_response_list);
 636     while (asm_response_list_iter != NULL) {
 637
 638         _asm_discover_response_t *asm_resp = (_asm_discover_response_t*)(asm_response_list_iter->data);
 639         if (asm_resp->error_code == FIDO_ERROR_NONE
 640                 &&
 641                 asm_resp->asm_response_json != NULL) {
 642
 643             JsonParser *parser = json_parser_new();
 644             CATCH_IF_FAIL(parser != NULL);
 645
 646             GError *parse_err = NULL;
 647             json_parser_load_from_data(parser, asm_resp->asm_response_json, -1, &parse_err);
 648             CATCH_IF_FAIL(parse_err == NULL);
 649
 650             JsonNode *root = json_parser_get_root(parser);
 651             CATCH_IF_FAIL(root != NULL);
 652
 653             JsonObject *root_obj = json_node_get_object(root);
 654             CATCH_IF_FAIL(root_obj != NULL);
 655
 656             int err_temp = 0;
 657             err_temp = json_object_get_int_member(root_obj, _JSON_KEY_STATUS_CODE);
 658
 659             *error_code = err_temp;
 660             CATCH_IF_FAIL(*error_code == 0);
 661
 662             JsonObject *response_obj = json_object_get_object_member(root_obj, _JSON_KEY_RESP_DATA);
 663             CATCH_IF_FAIL(response_obj != NULL);
 664
 665             JsonArray *auth_arr = json_object_get_array_member(response_obj, _JSON_KEY_AUTHENTICATORS);
 666             CATCH_IF_FAIL(auth_arr != NULL);
 667
 668             int auth_arr_len = json_array_get_length(auth_arr);
 669
 670             int auth_arr_index = 0;
 671             for (auth_arr_index = 0; auth_arr_index < auth_arr_len; auth_arr_index++) {
 672                 JsonObject *auth_obj = json_array_get_object_element(auth_arr, auth_arr_index);
 673                 if (auth_obj != NULL) {
 674                     fido_authenticator_s *auth_info = (fido_authenticator_s *)calloc(1, sizeof(fido_authenticator_s));
 675
 676
 677                     int auth_index = json_object_get_int_member(auth_obj, _JSON_KEY_AUTH_INDEX);
 678                     char *auth_idx_str = (char*)calloc(1, 128);
 679                     snprintf(auth_idx_str, 127, "%d", auth_index);
 680
 681                     auth_info->auth_index = auth_idx_str;
 682                     _INFO("auth_info->auth_index = [%s]", auth_info->auth_index);
 683
 684
 685                     /* FIXME : ASM version list */
 686
 687                     bool is_enrolled = json_object_get_boolean_member(auth_obj, _JSON_KEY_IS_USER_ENROLLED);
 688                     auth_info->is_user_enrolled = is_enrolled;
 689
 690                     bool has_settings = json_object_get_boolean_member(auth_obj, _JSON_KEY_HAS_SETTINGS);
 691                     auth_info->has_settings = has_settings;
 692
 693
 694                     const char *aaid = json_object_get_string_member(auth_obj, _JSON_KEY_AAID);
 695                     if (aaid != NULL)
 696                         auth_info->aaid = strdup(aaid);
 697
 698
 699                     const char *assertion_schm = json_object_get_string_member(auth_obj, _JSON_KEY_ASSERT_SCHEME);
 700                     if (assertion_schm != NULL)
 701                         auth_info->assertion_scheme = strdup(assertion_schm);
 702
 703                     int auth_algo  = json_object_get_int_member(auth_obj, _JSON_KEY_AUTH_ALGO);
 704                     auth_info->authentication_algorithm = auth_algo;
 705
 706                     GList *att_list = NULL;
 707                     JsonArray *att_arr = json_object_get_array_member(auth_obj, _JSON_KEY_ATT_TYPES);
 708                     if (att_arr != NULL) {
 709                         int att_arr_len = json_array_get_length(att_arr);
 710                         int att_arr_idx = 0;
 711                         for (att_arr_idx = 0; att_arr_idx < att_arr_len; att_arr_idx++) {
 712                             int att = json_array_get_int_element(att_arr, att_arr_idx);
 713                             att_list = g_list_append(att_list, GINT_TO_POINTER(att));
 714                         }
 715                     }
 716
 717                     if (att_list != NULL)
 718                         auth_info->attestation_types = g_list_first(att_list);
 719
 720                     int user_verification  = json_object_get_int_member(auth_obj, _JSON_KEY_USER_VERIFICATION);
 721                     auth_info->user_verification = user_verification;
 722
 723                     int key_prot  = json_object_get_int_member(auth_obj, _JSON_KEY_KEY_PROTECTION);
 724                     auth_info->key_protection = key_prot;
 725
 726
 727                     int matcher_prot  = json_object_get_int_member(auth_obj, _JSON_KEY_MATCHER_PROTECTION);
 728                     auth_info->matcher_protection = matcher_prot;
 729
 730                     int attch_hint  = json_object_get_int_member(auth_obj, _JSON_KEY_ATTACHMENT_HINT);
 731                     auth_info->attachment_hint = attch_hint;
 732
 733
 734                     bool is_sec_only  = json_object_get_boolean_member(auth_obj, _JSON_KEY_IS_2_FACTOR_ONLY);
 735                     auth_info->is_second_factor_only = is_sec_only;
 736
 737
 738                     bool is_roaming  = json_object_get_boolean_member(auth_obj, _JSON_KEY_IS_ROAMING_AUTH);
 739                     auth_info->is_roaming = is_roaming;
 740
 741
 742                     JsonArray *ext_id_json_arr = json_object_get_array_member(auth_obj, _JSON_KEY_SUPPORTED_EXT_IDS);
 743                     if (ext_id_json_arr != NULL)
 744                         auth_info->supported_extension_IDs = __get_string_list_from_json_array(ext_id_json_arr);
 745
 746
 747                     int tc_disp  = json_object_get_int_member(auth_obj, _JSON_KEY_TC_DISPLAY);
 748                     auth_info->tc_display = tc_disp;
 749
 750                     const char *tc_dis_type = json_object_get_string_member(auth_obj, _JSON_KEY_TC_DISP_CONTENT_TYPE);
 751                     if (tc_dis_type != NULL)
 752                         auth_info->tc_display_content_type = strdup(tc_dis_type);
 753
 754
 755                     auth_info->tc_display_png_characteristics = __get_tc_disp_png_array(auth_obj);
 756
 757                     const char *title = json_object_get_string_member(auth_obj, _JSON_KEY_TITLE);
 758                     if (title != NULL)
 759                         auth_info->title = strdup(title);
 760
 761
 762                     const char *desc = json_object_get_string_member(auth_obj, _JSON_KEY_DESC);
 763                     if (desc != NULL)
 764                         auth_info->description = strdup(desc);
 765
 766
 767                     const char *icon  = json_object_get_string_member(auth_obj, _JSON_KEY_ICON);
 768                     if (icon != NULL)
 769                         auth_info->icon = strdup(icon);
 770
 771
 772                     if (asm_resp->asm_id != NULL)
 773                         auth_info->asm_id = strdup(asm_resp->asm_id);
 774                     else
 775                         _ERR("Authenticator does not have ASM ID!!");
 776
 777                     available_authenticators = g_list_append(available_authenticators, auth_info);
 778                 }
 779             }
 780
 781             if (parser != NULL)
 782                 g_object_unref(parser);
 783
 784         }
 785
 786         asm_response_list_iter = g_list_next(asm_response_list_iter);
 787
 788     }
 789
 790
 791     available_authenticators = g_list_first(available_authenticators);
 792
 793     _INFO("available_authenticators count = [%d]", g_list_length(available_authenticators));
 794
 795     return available_authenticators;
 796
 797 CATCH:
 798     return NULL;
 799 }
 800
 801 _asm_out_t*
 802 _uaf_parser_parse_asm_response_reg(const char *asm_response_json, int *error_code)
 803 {
 804     _asm_out_t *asm_out = NULL;
 805     int status = 0;
 806     GError *parser_err = NULL;
 807
 808     JsonParser *parser = json_parser_new();
 809     bool is_success = json_parser_load_from_data(parser, asm_response_json, -1, &parser_err);
 810
 811     CATCH_IF_FAIL(is_success == true);
 812
 813     JsonNode *root = json_parser_get_root(parser);
 814     CATCH_IF_FAIL(root != NULL);
 815
 816     JsonObject *root_obj = json_node_get_object(root);
 817     CATCH_IF_FAIL(root_obj != NULL);
 818
 819     status = json_object_get_int_member(root_obj, _JSON_KEY_STATUS_CODE);
 820     CATCH_IF_FAIL(status == 0);
 821
 822     JsonObject *resp_obj = json_object_get_object_member(root_obj, _JSON_KEY_RESP_DATA);
 823     CATCH_IF_FAIL(resp_obj != NULL);
 824
 825     const char *assertion = json_object_get_string_member(resp_obj, _JSON_KEY_ASSERTION);
 826     CATCH_IF_FAIL(assertion != NULL);
 827
 828     const char *assertion_scheme = json_object_get_string_member(resp_obj, _JSON_KEY_ASSERT_SCHEME);
 829     CATCH_IF_FAIL(assertion_scheme != NULL);
 830
 831     _asm_reg_out_t *reg_out = (_asm_reg_out_t*)calloc(1, sizeof(_asm_reg_out_t));
 832     reg_out->assertion = strdup(assertion);
 833     reg_out->assertion_schm = strdup(assertion_scheme);
 834
 835     asm_out = (_asm_out_t*)calloc(1, sizeof(_asm_out_t));
 836     asm_out->type = _ASM_OUT_TYPE_REG;
 837
 838     asm_out->status_code = status;
 839     asm_out->response_data = reg_out;
 840
 841     asm_out->ext_list = __get_extension_list(root_obj);
 842
 843     if (parser != NULL)
 844         g_object_unref(parser);
 845
 846     *error_code = 0;
 847     return asm_out;
 848
 849 CATCH:
 850     _free_asm_out(asm_out);
 851     if (parser != NULL)
 852         g_object_unref(parser);
 853
 854     *error_code = status;
 855     return NULL;
 856 }
 857
 858 _asm_out_t*
 859 _uaf_parser_parse_asm_response_auth(const char *asm_response_json, int *error_code)
 860 {
 861     _asm_out_t *asm_out = NULL;
 862     int status = 0;
 863     GError *parser_err = NULL;
 864
 865     JsonParser *parser = json_parser_new();
 866     bool is_success = json_parser_load_from_data(parser, asm_response_json, -1, &parser_err);
 867
 868     CATCH_IF_FAIL(is_success == true);
 869
 870     JsonNode *root = json_parser_get_root(parser);
 871     CATCH_IF_FAIL(root != NULL);
 872
 873     JsonObject *root_obj = json_node_get_object(root);
 874     CATCH_IF_FAIL(root_obj != NULL);
 875
 876     status = json_object_get_int_member(root_obj, _JSON_KEY_STATUS_CODE);
 877     CATCH_IF_FAIL(status == 0);
 878
 879     JsonObject *resp_obj = json_object_get_object_member(root_obj, _JSON_KEY_RESP_DATA);
 880     CATCH_IF_FAIL(resp_obj != NULL);
 881
 882     const char *assertion = json_object_get_string_member(resp_obj, _JSON_KEY_ASSERTION);
 883     CATCH_IF_FAIL(assertion != NULL);
 884
 885     const char *assertion_scheme = json_object_get_string_member(resp_obj, _JSON_KEY_ASSERT_SCHEME);
 886     CATCH_IF_FAIL(assertion_scheme != NULL);
 887
 888     _asm_auth_out_t *auth_out = (_asm_auth_out_t*)calloc(1, sizeof(_asm_auth_out_t));
 889     auth_out->assertion = strdup(assertion);
 890     auth_out->assertion_scheme = strdup(assertion_scheme);
 891
 892     asm_out = (_asm_out_t*)calloc(1, sizeof(_asm_out_t));
 893     asm_out->type = _ASM_OUT_TYPE_AUTH;
 894
 895     asm_out->status_code = status;
 896     asm_out->response_data = auth_out;
 897
 898     asm_out->ext_list = __get_extension_list(root_obj);
 899
 900     if (parser != NULL)
 901         g_object_unref(parser);
 902
 903     *error_code = 0;
 904     return asm_out;
 905
 906 CATCH:
 907     _free_asm_out(asm_out);
 908     if (parser != NULL)
 909         g_object_unref(parser);
 910
 911     *error_code = status;
 912     return NULL;
 913 }
 914
 915 _asm_dereg_out_t*
 916 _uaf_parser_parse_asm_response_dereg(const char *asm_response_json, int *error_code)
 917 {
 918     _asm_dereg_out_t *asm_out = NULL;
 919     int status = 0;
 920     GError *parser_err = NULL;
 921
 922     JsonParser *parser = json_parser_new();
 923     bool is_success = json_parser_load_from_data(parser, asm_response_json, -1, &parser_err);
 924
 925     CATCH_IF_FAIL(is_success == true);
 926
 927     JsonNode *root = json_parser_get_root(parser);
 928     CATCH_IF_FAIL(root != NULL);
 929
 930     JsonObject *root_obj = json_node_get_object(root);
 931     CATCH_IF_FAIL(root_obj != NULL);
 932
 933     asm_out = (_asm_dereg_out_t*)calloc(1, sizeof(_asm_dereg_out_t));
 934
 935     asm_out->status_code = json_object_get_int_member(root_obj, _JSON_KEY_STATUS_CODE);
 936
 937     if (parser != NULL)
 938         g_object_unref(parser);
 939
 940     *error_code = 0;
 941     return asm_out;
 942
 943 CATCH:
 944     free(asm_out);
 945     if (parser != NULL)
 946         g_object_unref(parser);
 947
 948     *error_code = status;
 949     return NULL;
 950 }
 951
 952 int
 953 _uaf_composer_compose_asm_reg_request(_version_t *version, int auth_index, _fido_asm_reg_in_t *reg_in, char **asm_reg_json)
 954 {
 955     _INFO("_uaf_composer_compose_asm_reg_request start");
 956
 957     /*Builder start*/
 958     JsonBuilder *builder = json_builder_new();
 959     json_builder_begin_object(builder);
 960
 961     /*requestType*/
 962     __add_string_to_json_object(builder, _JSON_KEY_REQ_TYPE, _JSON_KEY_REGISTER);
 963
 964     /*authIndex*/
 965     json_builder_set_member_name(builder, _JSON_KEY_AUTH_INDEX);
 966     json_builder_add_int_value(builder, auth_index);
 967
 968     /*version*/
 969     json_builder_set_member_name(builder, _JSON_KEY_ASM_VERSION);
 970     json_builder_begin_object(builder);
 971     json_builder_set_member_name(builder, _JSON_KEY_MAJOR);
 972     json_builder_add_int_value(builder, version->major);
 973
 974     json_builder_set_member_name(builder, _JSON_KEY_MINOR);
 975     json_builder_add_int_value(builder, version->minor);
 976
 977     json_builder_end_object(builder);
 978     /*version*/
 979
 980     /*args*/
 981     json_builder_set_member_name(builder, _JSON_KEY_ARGS);
 982     json_builder_begin_object(builder);
 983
 984     __add_string_to_json_object(builder, _JSON_KEY_APPID, reg_in->app_id);
 985     __add_string_to_json_object(builder, _JSON_KEY_USER_NAME, reg_in->user_name);
 986     __add_string_to_json_object(builder, _JSON_KEY_FINAL_CHALLENGE, reg_in->final_challenge);
 987
 988     if (reg_in->attestation_type != _INVALID_INT) {
 989         json_builder_set_member_name(builder, _JSON_KEY_ATT_TYPE);
 990
 991         json_builder_add_int_value(builder, reg_in->attestation_type);
 992     }
 993
 994
 995     json_builder_end_object(builder);
 996     /*args*/
 997
 998
 999     json_builder_end_object(builder);
1000     /*Builder end*/
1001
1002     JsonGenerator *gen = json_generator_new();
1003     JsonNode *root_builder = json_builder_get_root(builder);
1004     json_generator_set_root(gen, root_builder);
1005
1006     json_node_free(root_builder);
1007     g_object_unref(builder);
1008
1009     gsize len = 0;
1010     char *json = json_generator_to_data(gen, &len);
1011     if (json != NULL) {
1012         *asm_reg_json = json;
1013
1014         if (gen != NULL)
1015             g_object_unref(gen);
1016
1017         _INFO("%s", json);
1018
1019         _INFO("_uaf_composer_compose_asm_reg_request end");
1020
1021         return 0;
1022     }
1023
1024     g_object_unref(gen);
1025
1026     _INFO("_uaf_composer_compose_asm_reg_request fail");
1027     return -1;
1028 }
1029
1030 int
1031 _uaf_composer_compose_asm_auth_request(_version_t *version, int auth_index, _fido_asm_auth_in_t *auth_in,
1032                                        char **asm_auth_json)
1033 {
1034     _INFO("_uaf_composer_compose_asm_auth_request start");
1035
1036     /*Builder start*/
1037     JsonBuilder *builder = json_builder_new();
1038     json_builder_begin_object(builder);
1039
1040     /*requestType*/
1041     __add_string_to_json_object(builder, _JSON_KEY_REQ_TYPE, _JSON_KEY_AUTHENTICATE);
1042
1043     /*authIndex*/
1044     json_builder_set_member_name(builder, _JSON_KEY_AUTH_INDEX);
1045     json_builder_add_int_value(builder, auth_index);
1046
1047     /*version*/
1048     json_builder_set_member_name(builder, _JSON_KEY_ASM_VERSION);
1049     json_builder_begin_object(builder);
1050     json_builder_set_member_name(builder, _JSON_KEY_MAJOR);
1051     json_builder_add_int_value(builder, version->major);
1052
1053     json_builder_set_member_name(builder, _JSON_KEY_MINOR);
1054     json_builder_add_int_value(builder, version->minor);
1055
1056     json_builder_end_object(builder);
1057     /*version*/
1058
1059     /*args*/
1060     json_builder_set_member_name(builder, _JSON_KEY_ARGS);
1061     json_builder_begin_object(builder);
1062
1063     __add_string_to_json_object(builder, _JSON_KEY_APPID, auth_in->app_id);
1064     __add_string_to_json_object(builder, _JSON_KEY_FINAL_CHALLENGE, auth_in->final_challenge);
1065
1066     if (auth_in->key_ids != NULL) {
1067         _INFO("keyID to be sent in ASM req");
1068         /*keyIDs*/
1069         json_builder_set_member_name(builder, _JSON_KEY_KEY_IDS);
1070         json_builder_begin_array(builder);
1071
1072         GList *iter = g_list_first(auth_in->key_ids);
1073         while (iter != NULL) {
1074
1075             char *val = (char*)(iter->data);
1076             json_builder_add_string_value(builder, val);
1077             iter = iter->next;
1078         }
1079         json_builder_end_array(builder);
1080         /*keyIDs*/
1081     }
1082
1083     /*Transaction list composing*/
1084     if (auth_in->trans_list != NULL) {
1085         /*transaction*/
1086         json_builder_set_member_name(builder, _JSON_KEY_TRANSACTION);
1087         json_builder_begin_array(builder);
1088
1089         GList *iter = g_list_first(auth_in->trans_list);
1090         while (iter != NULL) {
1091
1092             _fido_asm_transaction_t *val = (_fido_asm_transaction_t*)(iter->data);
1093             /*transaction array element*/
1094             json_builder_begin_object(builder);
1095
1096             /*contentType*/
1097             __add_string_to_json_object(builder, _JSON_KEY_CONTENT_TYPE, val->content_type);
1098             /*content*/
1099             __add_string_to_json_object(builder, _JSON_KEY_CONTENT, val->content);
1100             /*tcDisplayPNGCharacteristics*/
1101             if (val->display_charac != NULL) {
1102
1103                 __add_int_to_json_object(builder, _JSON_KEY_WIDTH, val->display_charac->width);
1104                 __add_int_to_json_object(builder, _JSON_KEY_HEIGHT, val->display_charac->height);
1105                 __add_int_to_json_object(builder, _JSON_KEY_BIT_DEPTH, val->display_charac->bit_depth);
1106                 __add_int_to_json_object(builder, _JSON_KEY_COLOR_TYPE, val->display_charac->color_type);
1107                 __add_int_to_json_object(builder, _JSON_KEY_COMPRESSION, val->display_charac->compression);
1108                 __add_int_to_json_object(builder, _JSON_KEY_FILTER, val->display_charac->filter);
1109                 __add_int_to_json_object(builder, _JSON_KEY_INTERLACE, val->display_charac->interlace);
1110                 __add_int_to_json_object(builder, _JSON_KEY_WIDTH, val->display_charac->width);
1111
1112                 /*plte*/
1113                 if (val->display_charac->plte != NULL) {
1114
1115                     json_builder_begin_array(builder);
1116
1117                     GList *plte_iter = g_list_first(val->display_charac->plte);
1118                     while (plte_iter != NULL) {
1119                         _fido_asm_rgb_pallette_entry_t *plte = (_fido_asm_rgb_pallette_entry_t*)(plte_iter->data);
1120
1121                         __add_int_to_json_object(builder, _JSON_KEY_R, plte->r);
1122                         __add_int_to_json_object(builder, _JSON_KEY_G, plte->g);
1123                         __add_int_to_json_object(builder, _JSON_KEY_B, plte->b);
1124
1125                         plte_iter = plte_iter->next;
1126                     }
1127
1128                     json_builder_end_array(builder);
1129                 }
1130             }
1131
1132             json_builder_end_object(builder);
1133
1134             iter = iter->next;
1135         }
1136         json_builder_end_array(builder);
1137         /*transaction*/
1138     }
1139
1140     json_builder_end_object(builder);
1141     /*args*/
1142
1143
1144     json_builder_end_object(builder);
1145     /*Builder end*/
1146
1147     JsonGenerator *gen = json_generator_new();
1148     JsonNode *root_builder = json_builder_get_root(builder);
1149     json_generator_set_root(gen, root_builder);
1150
1151     json_node_free(root_builder);
1152     g_object_unref(builder);
1153
1154     gsize len = 0;
1155     char *json = json_generator_to_data(gen, &len);
1156     if (json != NULL) {
1157         *asm_auth_json = json;
1158
1159         if (gen != NULL)
1160             g_object_unref(gen);
1161
1162         _INFO("%s", json);
1163
1164         _INFO("_uaf_composer_compose_asm_auth_request end");
1165
1166         return 0;
1167     }
1168
1169     g_object_unref(gen);
1170
1171     _INFO("_uaf_composer_compose_asm_auth_request fail");
1172     return -1;
1173 }
1174
1175 int
1176 _uaf_composer_compose_asm_dereg_request(_version_t *version, int auth_index, _matched_auth_dereg_t *dereg_in,
1177                                         char **asm_dereg_json)
1178 {
1179     _INFO("_uaf_composer_compose_asm_dereg_request start");
1180
1181     /*Builder start*/
1182     JsonBuilder *builder = json_builder_new();
1183     JsonBuilder *root = json_builder_begin_object(builder);
1184
1185     /*requestType*/
1186     __add_string_to_json_object(root, _JSON_KEY_REQ_TYPE, _JSON_KEY_DEREGISTER);
1187
1188     /*authIndex*/
1189     json_builder_set_member_name(root, _JSON_KEY_AUTH_INDEX);
1190     json_builder_add_int_value(root, auth_index);
1191
1192     /*version*/
1193     json_builder_set_member_name(root, _JSON_KEY_ASM_VERSION);
1194     JsonBuilder *ver_root = json_builder_begin_object(root);
1195     json_builder_set_member_name(ver_root, _JSON_KEY_MAJOR);
1196     json_builder_add_int_value(ver_root, version->major);
1197
1198     json_builder_set_member_name(ver_root, _JSON_KEY_MINOR);
1199     json_builder_add_int_value(ver_root, version->minor);
1200
1201     json_builder_end_object(ver_root);
1202
1203
1204     /*args*/
1205     json_builder_set_member_name(root, _JSON_KEY_ARGS);
1206     JsonBuilder *args_root = json_builder_begin_object(root);
1207
1208     __add_string_to_json_object(args_root, _JSON_KEY_APPID, dereg_in->app_id);
1209     __add_string_to_json_object(args_root, _JSON_KEY_KEY_ID, dereg_in->key_id);
1210
1211     json_builder_end_object(args_root);
1212
1213     json_builder_end_object(root);
1214     /*Builder end*/
1215
1216     JsonGenerator *gen = json_generator_new();
1217     JsonNode *root_builder = json_builder_get_root(builder);
1218     json_generator_set_root(gen, root_builder);
1219
1220     json_node_free(root_builder);
1221     g_object_unref(builder);
1222
1223     gsize len = 0;
1224     char *json = json_generator_to_data(gen, &len);
1225     if (json != NULL) {
1226         *asm_dereg_json = json;
1227         _INFO("_uaf_composer_compose_uaf_process_response_reg return success");
1228
1229         if (gen != NULL)
1230             g_object_unref(gen);
1231
1232         _INFO("%s", json);
1233
1234         _INFO("_uaf_composer_compose_asm_dereg_request end");
1235
1236         return 0;
1237     }
1238
1239     g_object_unref(gen);
1240
1241     _INFO("_uaf_composer_compose_asm_dereg_request fail");
1242     return -1;
1243
1244 }
1245
1246 //{"appID":"https://qa-egypt.noknoktest.com:443/UAFSampleProxy/uaf/facets.uaf","challenge":"uYBuGQf7r-LND16Q0GUpPRi112UjCtcym3awjm-MmmI","channelBinding":{},"facetID":"com.noknok.android.sampleapp"}
1247 char *
1248 _uaf_composer_compose_final_challenge(const char *app_id, const char *challenge, const char *facet_id, const char *ch_bin)
1249 {
1250     _INFO("_uaf_composer_compose_final_challenge");
1251
1252     JsonBuilder *builder = json_builder_new();
1253     json_builder_begin_object(builder);
1254
1255     __add_string_to_json_object(builder, _JSON_KEY_APPID, app_id);
1256
1257     __add_string_to_json_object(builder, _JSON_KEY_CHALLENGE, challenge);
1258
1259     json_builder_set_member_name(builder, _JSON_KEY_CH_BINDING);
1260     json_builder_begin_object(builder);
1261     if (ch_bin != NULL) {
1262
1263         JsonParser *chb_parser = json_parser_new();
1264
1265         GError *chb_err = NULL;
1266         bool chb_parsed = json_parser_load_from_data(chb_parser, ch_bin, -1, &chb_err);
1267         if (chb_parsed == FALSE) {
1268             return NULL;
1269         }
1270
1271         JsonNode *chb_root = json_parser_get_root(chb_parser);
1272         RET_IF_FAIL(chb_root != NULL, NULL);
1273
1274         JsonObject *chb_root_obj = json_node_get_object(chb_root);
1275         RET_IF_FAIL(chb_root_obj != NULL, NULL);
1276
1277         char *end_pt = __get_string_from_json_object(chb_root_obj, _JSON_KEY_SERVER_END_POINT);
1278         char *cert = __get_string_from_json_object(chb_root_obj, _JSON_KEY_TLS_SERVER_CERT);
1279         char *uni = __get_string_from_json_object(chb_root_obj, _JSON_KEY_TLS_UNIQUE);
1280         char *cid = __get_string_from_json_object(chb_root_obj, _JSON_KEY_CID_PUB_KEY);
1281
1282         __add_string_to_json_object(builder, _JSON_KEY_SERVER_END_POINT, end_pt);
1283         __add_string_to_json_object(builder, _JSON_KEY_TLS_SERVER_CERT, cert);
1284         __add_string_to_json_object(builder, _JSON_KEY_TLS_UNIQUE, uni);
1285         __add_string_to_json_object(builder, _JSON_KEY_CID_PUB_KEY, cid);
1286
1287         SAFE_DELETE(end_pt);
1288         SAFE_DELETE(cert);
1289         SAFE_DELETE(uni);
1290         SAFE_DELETE(cid);
1291
1292         g_object_unref(chb_parser);
1293
1294     }
1295
1296     /*If no channledbinding to add, putting empty */
1297     json_builder_end_object(builder);
1298
1299     __add_string_to_json_object(builder, _JSON_KEY_FACET_ID, facet_id);
1300
1301     json_builder_end_object(builder);
1302
1303     JsonNode *root_node = json_builder_get_root(builder);
1304
1305     JsonGenerator *generator = json_generator_new();
1306     json_generator_set_root(generator, root_node);
1307
1308     json_node_free(root_node);
1309     g_object_unref(builder);
1310
1311     char *json_str = NULL;
1312     gsize len = 0;
1313     json_str = json_generator_to_data(generator, &len);
1314
1315     if (json_str == NULL)
1316         return NULL;
1317
1318     int inlen = strlen(json_str);
1319     int fc_enc_len = (4 * ((inlen + 2) / 3)) + 1;
1320
1321     unsigned char *fc_enc = calloc(1, fc_enc_len);
1322
1323     int r = _fido_b64url_encode((unsigned char*)json_str, inlen, fc_enc, &fc_enc_len);
1324
1325     _INFO("_fido_b64url_encode len=[%d]", fc_enc_len);
1326
1327     SAFE_DELETE(json_str);
1328     g_object_unref(generator);
1329
1330     if (r != 0)
1331         return NULL;
1332
1333     _INFO("_fido_b64url_encoded string=%s", fc_enc);
1334
1335     return ((char*)fc_enc);
1336
1337 }
1338
1339 int
1340 _uaf_composer_compose_uaf_process_response_reg(_op_header_t *header, char *final_ch, GList *assertions, char **uaf_response)
1341 {
1342     _INFO("_uaf_composer_compose_uaf_process_response_reg");
1343
1344     RET_IF_FAIL(header != NULL, FIDO_ERROR_PROTOCOL_ERROR);
1345
1346     /*Only 1.0 protocol support*/
1347
1348     JsonBuilder *builder = json_builder_new();
1349
1350     json_builder_begin_array(builder);
1351
1352     json_builder_begin_object(builder);
1353
1354     /* header*/
1355     json_builder_set_member_name(builder, _JSON_KEY_HEADER);
1356     json_builder_begin_object(builder);
1357
1358     json_builder_set_member_name(builder, _JSON_KEY_APPID);
1359     json_builder_add_string_value(builder, header->app_id);
1360
1361     json_builder_set_member_name(builder, _JSON_KEY_OP);
1362     json_builder_add_string_value(builder, header->operation);
1363
1364     json_builder_set_member_name(builder, _JSON_KEY_SERVER_DATA);
1365     json_builder_add_string_value(builder, header->server_data);
1366
1367     json_builder_set_member_name(builder, _JSON_KEY_UPV);
1368     json_builder_begin_object(builder);
1369
1370     json_builder_set_member_name(builder, _JSON_KEY_MAJOR);
1371     json_builder_add_int_value(builder, header->version->major);
1372
1373     json_builder_set_member_name(builder, _JSON_KEY_MINOR);
1374     json_builder_add_int_value(builder, header->version->minor);
1375
1376     json_builder_end_object(builder);
1377
1378     json_builder_end_object(builder);
1379
1380     /* fcparams*/
1381     if (final_ch != NULL) {
1382         json_builder_set_member_name(builder, _JSON_KEY_FC_PARAMS);
1383         json_builder_add_string_value(builder, final_ch);
1384     }
1385
1386     /* assertions*/
1387     json_builder_set_member_name(builder, _JSON_KEY_ASSERTIONS);
1388     json_builder_begin_array(builder);
1389     GList *assertions_iter = g_list_first(assertions);
1390     while (assertions_iter != NULL) {
1391         _auth_reg_assertion_t *ass_data = (_auth_reg_assertion_t*)(assertions_iter->data);
1392         json_builder_begin_object(builder);
1393         json_builder_set_member_name(builder, _JSON_KEY_ASSERTION);
1394         json_builder_add_string_value(builder, ass_data->assertion);
1395
1396         json_builder_set_member_name(builder, _JSON_KEY_ASSERT_SCHEME);
1397         json_builder_add_string_value(builder, ass_data->assertion_schm);
1398
1399         json_builder_end_object(builder);
1400
1401         assertions_iter = assertions_iter->next;
1402
1403     }
1404
1405     json_builder_end_array(builder);
1406
1407     json_builder_end_object(builder);
1408
1409
1410     json_builder_end_array(builder);
1411
1412
1413     JsonNode *root_builder = json_builder_get_root(builder);
1414
1415     JsonGenerator *gen = json_generator_new();
1416     json_generator_set_root(gen, root_builder);
1417
1418     json_node_free(root_builder);
1419     g_object_unref(builder);
1420
1421     gsize len = 0;
1422     char *json = json_generator_to_data(gen, &len);
1423     if (json != NULL) {
1424         *uaf_response = json;
1425         _INFO("_uaf_composer_compose_uaf_process_response_reg return success");
1426
1427         if (gen != NULL)
1428             g_object_unref(gen);
1429
1430         return FIDO_ERROR_NONE;
1431     }
1432
1433     _INFO("_uaf_composer_compose_uaf_process_response_reg return fail");
1434     g_object_unref(gen);
1435     return FIDO_ERROR_PROTOCOL_ERROR;
1436 }
1437
1438 int
1439 _uaf_composer_compose_uaf_process_response_auth(_op_header_t *header, char *final_ch, GList *assertions, char **uaf_response)
1440 {
1441     return _uaf_composer_compose_uaf_process_response_reg(header, final_ch, assertions, uaf_response);
1442 }
1443
1444 char *
1445 _uaf_composer_compose_dereg_request(_response_t *uaf_res)
1446 {
1447     _INFO("_uaf_composer_compose_dereg_request");
1448
1449     /*Only 1.0 protocol support*/
1450
1451     JsonBuilder *builder = json_builder_new();
1452
1453     JsonBuilder *root_array = json_builder_begin_array(builder);
1454
1455     JsonBuilder *uaf_1_root = json_builder_begin_object(root_array);
1456
1457     /* header*/
1458     json_builder_set_member_name(uaf_1_root, _JSON_KEY_HEADER);
1459     JsonBuilder *header_root = json_builder_begin_object(uaf_1_root);
1460
1461     json_builder_set_member_name(header_root, _JSON_KEY_APPID);
1462     json_builder_add_string_value(header_root, uaf_res->header->app_id);
1463
1464     json_builder_set_member_name(header_root, _JSON_KEY_OP);
1465     json_builder_add_string_value(header_root, strdup(_UAF_OPERATION_NAME_KEY_DE_REG));
1466
1467     json_builder_set_member_name(header_root, _JSON_KEY_SERVER_DATA);
1468     json_builder_add_string_value(header_root, uaf_res->header->server_data);
1469
1470     json_builder_set_member_name(header_root, _JSON_KEY_UPV);
1471     JsonBuilder *upv_root = json_builder_begin_object(header_root);
1472
1473     json_builder_set_member_name(upv_root, _JSON_KEY_MAJOR);
1474     json_builder_add_int_value(upv_root, uaf_res->header->version->major);
1475
1476     json_builder_set_member_name(upv_root, _JSON_KEY_MINOR);
1477     json_builder_add_int_value(upv_root,uaf_res->header->version->minor);
1478
1479     json_builder_end_object(upv_root);
1480
1481     json_builder_end_object(header_root);
1482     /* header*/
1483
1484     _INFO("after header");
1485
1486
1487     /*appID*/
1488     if (uaf_res->header->app_id == NULL) {
1489         _ERR("appID is missing");
1490
1491         g_object_unref(builder);
1492         return NULL;
1493     }
1494
1495     json_builder_set_member_name(uaf_1_root, _JSON_KEY_APPID);
1496     json_builder_add_string_value(uaf_1_root, uaf_res->header->app_id);
1497     /*appID*/
1498
1499
1500     /*authenticators*/
1501     json_builder_set_member_name(uaf_1_root, _JSON_KEY_AUTHENTICATORS_SMALL);
1502     JsonBuilder *auth_root = json_builder_begin_array(uaf_1_root);
1503     GList *assertions_iter = g_list_first(uaf_res->assertion_list);
1504     while (assertions_iter != NULL) {
1505
1506         _auth_reg_assertion_t *ass_data = (_auth_reg_assertion_t*)(assertions_iter->data);
1507
1508         char *assrt = ass_data->assertion;
1509
1510         _INFO("%s", assrt);
1511
1512         _auth_reg_assertion_tlv_t *assrt_tlv = _tlv_util_decode_reg_assertion(assrt);
1513         if (assrt_tlv == NULL) {
1514             _ERR("Invalid assertion format");
1515
1516             g_object_unref(builder);
1517             return NULL;
1518         }
1519
1520         char *aaid = strdup(assrt_tlv->aaid);
1521
1522         JsonBuilder *obj = json_builder_begin_object(auth_root);
1523
1524         if (aaid != NULL) {
1525             json_builder_set_member_name(obj, _JSON_KEY_AAID);
1526             json_builder_add_string_value(obj, aaid);
1527             _INFO("aaid=[%s]", aaid);
1528         }
1529
1530         if (assrt_tlv->key_id != NULL) {
1531             int inlen = assrt_tlv->key_id_len;
1532             int enc_len = (4 * ((inlen + 2) / 3)) + 1;
1533
1534             unsigned char *key_id_enc = calloc(1, enc_len);
1535
1536             int r = _fido_b64url_encode(assrt_tlv->key_id, inlen, key_id_enc, &enc_len);
1537
1538             _INFO("_fido_b64url_encode len=[%d]", enc_len);
1539
1540             if ((key_id_enc != NULL) && (r == 0)) {
1541                 _INFO("_fido_b64url_encoded string=%s", key_id_enc);
1542                 json_builder_set_member_name(obj, _JSON_KEY_KEY_ID);
1543                 json_builder_add_string_value(obj, (char *)key_id_enc);
1544                 _INFO("keyid=[%s]", key_id_enc);
1545             }
1546
1547         }
1548
1549         _INFO("after assertions");
1550
1551         _free_auth_reg_assertion_tlv(assrt_tlv);
1552
1553         json_builder_end_object(obj);
1554
1555
1556         assertions_iter = assertions_iter->next;
1557
1558     }
1559
1560     json_builder_end_array(auth_root);
1561     /*authenticators*/
1562
1563
1564     json_builder_end_object(uaf_1_root);
1565
1566
1567     json_builder_end_array(root_array);
1568
1569
1570     JsonNode *root_builder = json_builder_get_root(builder);
1571     JsonGenerator *gen = json_generator_new();
1572     json_generator_set_root(gen, root_builder);
1573
1574     json_node_free(root_builder);
1575     g_object_unref(builder);
1576
1577     gsize len = 0;
1578     char *dereg_json = json_generator_to_data(gen, &len);
1579     g_object_unref(gen);
1580
1581     if (dereg_json != NULL) {
1582         _INFO("_uaf_composer_compose_dereg_request return success");
1583         _INFO("%s", dereg_json);
1584         return dereg_json;
1585     }
1586
1587     _INFO("_uaf_composer_compose_dereg_request return fail");
1588     return NULL;
1589 }
1590
1591 static _policy_t*
1592 __get_policy(JsonObject *uaf_object)
1593 {
1594     /*TODO : Check in spec whether accepted array can be NULL, i.e allow all?*/
1595
1596     JsonObject *policy_obj = json_object_get_object_member(uaf_object, _JSON_KEY_POLICY);
1597     RET_IF_FAIL(policy_obj != NULL, NULL);
1598
1599     JsonArray *accepted_array = json_object_get_array_member(policy_obj, _JSON_KEY_ACCEPTED);
1600     RET_IF_FAIL(accepted_array != NULL, NULL);
1601
1602     int accepted_len = json_array_get_length(accepted_array);
1603    _INFO("Parser accepted list count [%d]", accepted_len);
1604
1605     _policy_t *policy_info = (_policy_t *)calloc(1, sizeof(_policy_t));
1606     policy_info->is_keyid_present = false;
1607
1608     GList *allowed_list = NULL;
1609
1610     int i = 0;
1611     for (i = 0; i < accepted_len; i++) {
1612
1613         JsonArray *accepted_arr_inner = json_array_get_array_element(accepted_array, i);
1614         if (accepted_arr_inner) {
1615             int accepted_len_inner = json_array_get_length(accepted_arr_inner);
1616             _INFO("Parser accepted list inner count [%d]", accepted_len_inner);
1617
1618             int j = 0;
1619             for (j = 0; j < accepted_len_inner; j++) {
1620                 GList *allowed_list_inner = NULL;
1621
1622                 JsonObject *match_obj = json_array_get_object_element(accepted_arr_inner, j);
1623                 if (match_obj) {
1624                     _match_criteria_t *match_info = _uaf_parser_parse_match(match_obj);
1625                     if (match_info) {
1626                         _INFO("Appending match_info");
1627                         if (policy_info->is_keyid_present == false) {
1628                             if (match_info->key_id_list != NULL)
1629                                 policy_info->is_keyid_present = true;
1630                         }
1631                         allowed_list_inner = g_list_append(allowed_list_inner, match_info);
1632                     }
1633                 }
1634                 if (j == (accepted_len_inner - 1)) {
1635                     if (allowed_list_inner) {
1636                         _INFO("Appending accepted list");
1637                         allowed_list = g_list_append(allowed_list, allowed_list_inner);
1638                     }
1639                 }
1640             }
1641         }
1642     }
1643
1644     if (allowed_list != NULL)
1645         policy_info->accepted_list = g_list_first(allowed_list);
1646
1647     GList *disallowed_list = NULL;
1648
1649     JsonArray *disallowed_array = json_object_get_array_member(policy_obj, _JSON_KEY_DISALLOWED);
1650     if (disallowed_array != NULL) {
1651         int disallowed_len = json_array_get_length(disallowed_array);
1652
1653         for (i = 0; i < disallowed_len; i++) {
1654             JsonObject *match_obj = json_array_get_object_element(disallowed_array, i);
1655             if (match_obj) {
1656
1657                 _match_criteria_t *match_info = _uaf_parser_parse_match(match_obj);
1658                 if (match_info) {
1659                     if (policy_info->is_keyid_present == false) {
1660                         if (match_info->key_id_list != NULL)
1661                             policy_info->is_keyid_present = true;
1662                     }
1663                     disallowed_list = g_list_append(disallowed_list, match_info);
1664                 }
1665             }
1666         }
1667
1668         if (disallowed_list != NULL)
1669             policy_info->disallowed_list = g_list_first(disallowed_list);
1670     }
1671
1672     _INFO("returning policy [%p]", policy_info);
1673     return policy_info;
1674 }
1675
1676 static _reg_request_t*
1677 __parse_uaf_reg_message(JsonObject *uaf_object)
1678 {
1679         _reg_request_t *reg_req_temp = (_reg_request_t *)calloc(1, sizeof(_reg_request_t));
1680
1681         reg_req_temp->challenge = __get_string_from_json_object(uaf_object, _JSON_KEY_CHALLENGE);
1682
1683         reg_req_temp->user_name = __get_string_from_json_object(uaf_object, _JSON_KEY_USER_NAME);
1684
1685         reg_req_temp->policy = __get_policy(uaf_object);
1686         if (reg_req_temp->policy != NULL)
1687             _INFO("parsed policy [%p]", reg_req_temp->policy);
1688         else
1689             _INFO("parsed policy [NULL]");
1690
1691         return reg_req_temp;
1692 }
1693
1694 static GList*
1695 __get_transaction_list(JsonObject *uaf_obj)
1696 {
1697     RET_IF_FAIL(uaf_obj != NULL, NULL);
1698
1699     JsonArray *tr_arr = json_object_get_array_member(uaf_obj, _JSON_KEY_TRANSACTION);
1700     RET_IF_FAIL(tr_arr != NULL, NULL);
1701
1702     _INFO("");
1703
1704     GList *trans_list = NULL;
1705
1706     int tr_arr_len = json_array_get_length(tr_arr);
1707     int i = 0;
1708     for (; i< tr_arr_len; i++) {
1709         JsonObject *tr_obj = json_array_get_object_element(tr_arr, i);
1710         if (tr_obj != NULL) {
1711
1712             _auth_transaction_t *trans = calloc(1, sizeof(_auth_transaction_t));
1713
1714             trans->content_type = __get_string_from_json_object(tr_obj, _JSON_KEY_CONTENT_TYPE);
1715             trans->content = __get_string_from_json_object(tr_obj, _JSON_KEY_CONTENT);
1716
1717             /*tcDisplayPNGCharacteristics*/
1718             JsonObject *tc_disp_obj = json_object_get_object_member(tr_obj, _JSON_KEY_TC_DISP_PNG_CHARS);
1719             if (tc_disp_obj != NULL) {
1720                 trans->display_charac = __get_png_data(tr_obj);
1721             }
1722
1723             trans_list = g_list_append(trans_list, trans);
1724         }
1725     }
1726
1727     if (trans_list != NULL) {
1728         trans_list = g_list_first(trans_list);
1729         _INFO("Transaction list count = [%d]", g_list_length(trans_list));
1730     }
1731
1732     _INFO("");
1733     return trans_list;
1734 }
1735
1736 static _auth_request_t*
1737 __parse_uaf_auth_message(JsonObject *uaf_object)
1738 {
1739     _auth_request_t *auth_req_temp = (_auth_request_t *)calloc(1, sizeof(_auth_request_t));
1740
1741     auth_req_temp->challenge = __get_string_from_json_object(uaf_object, _JSON_KEY_CHALLENGE);
1742
1743     auth_req_temp->transaction_list = __get_transaction_list(uaf_object);
1744
1745     auth_req_temp->policy = __get_policy(uaf_object);
1746
1747     if (auth_req_temp->policy != NULL)
1748         _INFO("parsed policy [%p]", auth_req_temp->policy);
1749     else
1750         _INFO("parsed policy [NULL]");
1751
1752     return auth_req_temp;
1753 }
1754
1755 static void
1756 __dereg_auth_parser(JsonArray *array, guint index_, JsonNode *element_node, gpointer user_data)
1757 {
1758      _dereg_request_t *dereg_req_temp = (_dereg_request_t *)user_data;
1759
1760      JsonObject *auth_obj = json_node_get_object(element_node);
1761      if (auth_obj != NULL) {
1762          _dereg_auth_info_t *dereg_auth = (_dereg_auth_info_t*)calloc(1, sizeof(_dereg_auth_info_t));
1763
1764          dereg_auth->aaid = __get_string_from_json_object(auth_obj, _JSON_KEY_AAID);
1765          dereg_auth->key_id = __get_string_from_json_object(auth_obj, _JSON_KEY_KEY_ID);
1766
1767          dereg_req_temp->auth_info_list = g_list_append(dereg_req_temp->auth_info_list, dereg_auth);
1768      }
1769 }
1770
1771 static _dereg_request_t*
1772 __parse_uaf_dereg_message(JsonObject *uaf_object)
1773 {
1774     _dereg_request_t *dereg_req_temp = (_dereg_request_t *)calloc(1, sizeof(_dereg_request_t));
1775
1776     JsonArray *auth_arr = json_object_get_array_member(uaf_object, _JSON_KEY_AUTHENTICATORS_SMALL);
1777     if (auth_arr != NULL) {
1778         json_array_foreach_element(auth_arr, __dereg_auth_parser, dereg_req_temp);
1779     }
1780
1781     return dereg_req_temp;
1782 }
1783
1784 _message_t *
1785 _uaf_parser_parse_message(const char *uaf_json, const gchar *channel_binding)
1786 {
1787     _INFO("_uaf_parser_parse_message");
1788
1789     RET_IF_FAIL(uaf_json != NULL, NULL);
1790
1791     _message_t *uaf_message_temp = (_message_t*) calloc(1, sizeof(_message_t));
1792     uaf_message_temp->type = _MESSAGE_TYPE_MIN;
1793
1794     if (channel_binding != NULL) {
1795         if (strcmp(channel_binding, _FIDO_NO_CHANNEL_BINDING_DBUS_STRING) != 0)
1796             uaf_message_temp->channel_binding = strdup(channel_binding);
1797     }
1798
1799     JsonParser *parser = json_parser_new();
1800     CATCH_IF_FAIL(parser != NULL);
1801
1802     GError *parse_err = NULL;
1803     json_parser_load_from_data(parser, uaf_json, -1, &parse_err);
1804     CATCH_IF_FAIL(parse_err == NULL);
1805
1806     JsonNode *root = json_parser_get_root(parser);
1807     CATCH_IF_FAIL(root != NULL);
1808
1809     JsonArray *uaf_array = json_node_get_array(root);
1810     CATCH_IF_FAIL(uaf_array != NULL);
1811
1812     /* Parse all and accept only 1.0 version */
1813
1814     int uaf_arr_len = json_array_get_length(uaf_array);
1815     if (uaf_arr_len <= 0) {
1816         _ERR("No UAF message found");
1817
1818         _free_message(uaf_message_temp);
1819         g_object_unref(parser);
1820         return NULL;
1821     }
1822
1823     int i = 0;
1824     for (; i < uaf_arr_len ; i++) {
1825         JsonObject *uaf_object = json_array_get_object_element(uaf_array, i);
1826         CATCH_IF_FAIL(uaf_object != NULL);
1827
1828         JsonObject *header_obj = json_object_get_object_member(uaf_object, _JSON_KEY_HEADER);
1829         CATCH_IF_FAIL(header_obj != NULL);
1830
1831         uaf_message_temp->header = __parse_uaf_header(header_obj);
1832
1833         /* NULL signifies the header version is not 1.0 */
1834         if (uaf_message_temp->header == NULL)
1835             continue;
1836
1837         if (strcmp(uaf_message_temp->header->operation, _UAF_OPERATION_NAME_KEY_REG) == 0){
1838             uaf_message_temp->data = (void *)__parse_uaf_reg_message(uaf_object);
1839             if (uaf_message_temp->data == NULL) {
1840
1841                 _free_message(uaf_message_temp);
1842                 g_object_unref(parser);
1843
1844                 return NULL;
1845             }
1846             else {
1847                 uaf_message_temp->type = _MESSAGE_TYPE_REG;
1848
1849                 g_object_unref(parser);
1850
1851                 return uaf_message_temp;
1852             }
1853         }
1854
1855         if (strcmp(uaf_message_temp->header->operation, _UAF_OPERATION_NAME_KEY_AUTH) == 0){
1856             uaf_message_temp->data = (void *)__parse_uaf_auth_message(uaf_object);
1857             if (uaf_message_temp->data == NULL) {
1858
1859                 _free_message(uaf_message_temp);
1860                 g_object_unref(parser);
1861
1862                 return NULL;
1863             }
1864             else {
1865                uaf_message_temp->type = _MESSAGE_TYPE_AUTH;
1866
1867                g_object_unref(parser);
1868                return uaf_message_temp;
1869
1870             }
1871         }
1872
1873         if (strcmp(uaf_message_temp->header->operation, _UAF_OPERATION_NAME_KEY_DE_REG) == 0){
1874             uaf_message_temp->data = (void *)__parse_uaf_dereg_message(uaf_object);
1875             if (uaf_message_temp->data == NULL) {
1876
1877                 _free_message(uaf_message_temp);
1878                 g_object_unref(parser);
1879
1880                 return NULL;
1881             }
1882             else {
1883                 uaf_message_temp->type = _MESSAGE_TYPE_DEREG;
1884
1885                 g_object_unref(parser);
1886                 return uaf_message_temp;
1887             }
1888         }
1889
1890     }
1891
1892 CATCH:
1893     _free_message(uaf_message_temp);
1894     if (parser != NULL)
1895         g_object_unref(parser);
1896
1897     return NULL;
1898 }
1899
1900 GList *
1901 _uaf_parser_parse_trusted_facets(const char *json)
1902 {
1903     JsonParser *parser = json_parser_new();
1904
1905     gsize len = -1;
1906     GError *err = NULL;
1907
1908     GList *app_id_list = NULL;
1909
1910     bool is_parsed = json_parser_load_from_data(parser, json, len, &err);
1911     CATCH_IF_FAIL(is_parsed == TRUE);
1912
1913
1914     JsonNode *root = json_parser_get_root(parser);
1915
1916     JsonObject *root_obj = json_node_get_object(root);
1917     CATCH_IF_FAIL(root_obj != NULL);
1918
1919     JsonArray *facet_arr = json_object_get_array_member(root_obj, _JSON_KEY_TRUSTED_FACETS);
1920     CATCH_IF_FAIL(facet_arr != NULL);
1921
1922     int facet_arr_len = json_array_get_length(facet_arr);
1923
1924     int i = 0;
1925     for (; i < facet_arr_len; i++) {
1926         JsonObject *facet_obj = json_array_get_object_element(facet_arr, i);
1927         if (facet_obj != NULL) {
1928
1929             JsonObject *ver_obj = json_object_get_object_member(facet_obj, _JSON_KEY_VERSION);
1930             if (ver_obj != NULL) {
1931                 int major = _INVALID_INT;
1932                 int minor = _INVALID_INT;
1933
1934                 major = json_object_get_int_member(ver_obj, _JSON_KEY_MAJOR);
1935                 minor = json_object_get_int_member(ver_obj, _JSON_KEY_MINOR);
1936
1937                 if (major == _VERSION_MAJOR && minor == _VERSION_MINOR) {
1938                     JsonArray *id_arr = json_object_get_array_member(facet_obj, _JSON_KEY_IDS);
1939                     if (id_arr != NULL) {
1940                         int id_arr_len = json_array_get_length(id_arr);
1941
1942                         int idx = 0;
1943                         for (; idx < id_arr_len; idx++) {
1944                             const char *id = json_array_get_string_element(id_arr, idx);
1945                             if (id != NULL) {
1946                                 app_id_list = g_list_append(app_id_list, strdup(id));
1947                             }
1948                         }
1949                     }
1950                 }
1951             }
1952         }
1953     }
1954
1955 CATCH:
1956     if (parser != NULL)
1957         g_object_unref(parser);
1958
1959     if (app_id_list != NULL)
1960         app_id_list = g_list_first(app_id_list);
1961
1962     return app_id_list;
1963 }
1964
1965 _response_t*
1966 _uaf_parser_parse_uaf_response(const char *uaf_response)
1967 {
1968     RET_IF_FAIL(uaf_response != NULL, NULL);
1969
1970     _response_t *uaf_res_temp = (_response_t*) calloc(1, sizeof(_response_t));
1971
1972     JsonParser *parser = json_parser_new();
1973     CATCH_IF_FAIL(parser != NULL);
1974
1975     GError *parse_err = NULL;
1976     json_parser_load_from_data(parser, uaf_response, -1, &parse_err);
1977     CATCH_IF_FAIL(parse_err == NULL);
1978
1979     JsonNode *root = json_parser_get_root(parser);
1980     CATCH_IF_FAIL(root != NULL);
1981
1982     JsonArray *uaf_array = json_node_get_array(root);
1983     CATCH_IF_FAIL(uaf_array != NULL);
1984
1985     /* Parse all and accept only 1.0 version */
1986
1987     int uaf_arr_len = json_array_get_length(uaf_array);
1988     CATCH_IF_FAIL(uaf_arr_len > 0);
1989
1990     int i = 0;
1991     for (; i < uaf_arr_len ; i++) {
1992         JsonObject *uaf_object = json_array_get_object_element(uaf_array, i);
1993         CATCH_IF_FAIL(uaf_object != NULL);
1994
1995         JsonObject *header_obj = json_object_get_object_member(uaf_object, _JSON_KEY_HEADER);
1996         CATCH_IF_FAIL(header_obj != NULL);
1997
1998         uaf_res_temp->header = __parse_uaf_header(header_obj);
1999
2000         /* NULL signifies the header version is not 1.0 */
2001         if (uaf_res_temp->header == NULL)
2002             continue;
2003
2004         char *op = uaf_res_temp->header->operation;
2005
2006         /*Only process reg and auth responses*/
2007         if ((strcmp(op, _UAF_OPERATION_NAME_KEY_REG) != 0)
2008                 && (strcmp(op, _UAF_OPERATION_NAME_KEY_AUTH) != 0)) {
2009             goto CATCH;
2010         }
2011
2012         uaf_res_temp->fcp = __get_string_from_json_object(uaf_object, _JSON_KEY_FC_PARAMS);
2013
2014         JsonArray *assrt_json_arr = json_object_get_array_member(uaf_object, _JSON_KEY_ASSERTIONS);
2015         CATCH_IF_FAIL(assrt_json_arr != NULL);
2016
2017         int assrt_arr_len = json_array_get_length(assrt_json_arr);
2018         int i = 0;
2019         for (; i < assrt_arr_len; i++) {
2020             JsonObject *assrt_json_obj = json_array_get_object_element(assrt_json_arr, i);
2021             if (assrt_json_obj != NULL) {
2022
2023                 _auth_reg_assertion_t *assrt_data = (_auth_reg_assertion_t*)calloc(1, sizeof(_auth_reg_assertion_t));
2024                 assrt_data->assertion = __get_string_from_json_object(assrt_json_obj, _JSON_KEY_ASSERTION);
2025                 assrt_data->assertion_schm = __get_string_from_json_object(assrt_json_obj, _JSON_KEY_ASSERT_SCHEME);
2026
2027                 uaf_res_temp->assertion_list = g_list_append(uaf_res_temp->assertion_list, assrt_data);
2028
2029             }
2030         }
2031
2032     }
2033
2034     g_object_unref(parser);
2035     _INFO("before _uaf_parser_parse_uaf_response end");
2036     return uaf_res_temp;
2037
2038 CATCH:
2039     if (parser != NULL)
2040         g_object_unref(parser);
2041
2042     if (uaf_res_temp != NULL)
2043         _free_response(uaf_res_temp);
2044
2045     return NULL;
2046 }
2047
2048 static int
2049 __print_string_list(GList *list)
2050 {
2051     RET_IF_FAIL(list != NULL, -1);
2052
2053     GList *list_iter = g_list_first(list);
2054     while (list_iter != NULL) {
2055         char *data = (char*) (list->data);
2056         if (data != NULL)
2057             _INFO("[%s]", data);
2058
2059         list_iter = list_iter->next;
2060     }
2061
2062     return 0;
2063 }
2064
2065 _asm_get_reg_out_t *
2066 _uaf_parser_parser_asm_get_reg_response(const char *get_reg_resp)
2067 {
2068     _INFO("_uaf_parser_parser_asm_get_reg_response start");
2069
2070     RET_IF_FAIL(get_reg_resp != NULL, NULL);
2071
2072     JsonParser *parser = json_parser_new();
2073     RET_IF_FAIL(parser != NULL, NULL);
2074
2075     GError *parser_err = NULL;
2076     gboolean is_parsed = json_parser_load_from_data(parser, get_reg_resp, -1, &parser_err);
2077     RET_IF_FAIL(is_parsed == TRUE, NULL);
2078
2079     _INFO("");
2080
2081     _asm_get_reg_out_t *reg_out = NULL;
2082
2083     JsonNode *root = json_parser_get_root(parser);
2084     CATCH_IF_FAIL(root != NULL);
2085
2086     JsonObject *root_obj = json_node_get_object(root);
2087     CATCH_IF_FAIL(root_obj != NULL);
2088
2089     _INFO("");
2090
2091     /*responseData*/
2092     JsonObject *res_obj = json_object_get_object_member(root_obj, _JSON_KEY_RESP_DATA);
2093     CATCH_IF_FAIL(res_obj != NULL);
2094
2095     /*appRegs*/
2096     JsonArray *app_reg_json_arr = json_object_get_array_member(res_obj, _JSON_KEY_APP_REGS);
2097     CATCH_IF_FAIL(app_reg_json_arr != NULL);
2098
2099     _INFO("");
2100
2101     int app_reg_json_arr_len = json_array_get_length(app_reg_json_arr);
2102     CATCH_IF_FAIL(app_reg_json_arr_len > 0);
2103
2104     reg_out = (_asm_get_reg_out_t*) calloc(1, sizeof(_asm_get_reg_out_t));
2105
2106     int i = 0;
2107     for (; i < app_reg_json_arr_len; i++) {
2108         JsonObject *app_reg_json_obj = json_array_get_object_element(app_reg_json_arr, i);
2109         if (app_reg_json_obj != NULL) {
2110             /*appID*/
2111             const char *app_id = json_object_get_string_member(app_reg_json_obj, _JSON_KEY_APPID);
2112
2113             _INFO("");
2114
2115             /*keyIDs*/
2116             JsonArray *key_id_json_arr = json_object_get_array_member(app_reg_json_obj, _JSON_KEY_KEY_IDS);
2117             GList *key_id_list = __get_string_list_from_json_array(key_id_json_arr);
2118
2119             if (app_id != NULL || key_id_list != NULL) {
2120                 _asm_app_reg_t *app_reg = (_asm_app_reg_t*) calloc(1, sizeof(_asm_app_reg_t));
2121
2122                 if (app_id != NULL) {
2123                     _INFO("app_id = [%s]", app_id);
2124                     app_reg->app_id = strdup(app_id);
2125                 }
2126
2127                 app_reg->key_id_list = key_id_list;
2128                 __print_string_list(key_id_list);
2129
2130                 reg_out->app_reg_list = g_list_append(reg_out->app_reg_list, app_reg);
2131                 _INFO("");
2132
2133             }
2134         }
2135     }
2136
2137     _INFO("");
2138     /*statusCode*/
2139     reg_out->status_code = __get_int_from_json_object(root_obj, _JSON_KEY_STATUS_CODE);
2140
2141 CATCH:
2142     g_object_unref(parser);
2143
2144     _INFO("_uaf_parser_parser_asm_get_reg_response end");
2145     return reg_out;
2146 }
2147
2148 char *
2149 _uaf_composer_compose_get_registrations_request(const char *auth_index)
2150 {
2151     _INFO("_uaf_composer_compose_get_registrations_request");
2152
2153     JsonBuilder *builder = json_builder_new();
2154
2155     json_builder_begin_object(builder);
2156
2157     /*Version : 1.0*/
2158     json_builder_set_member_name(builder, _JSON_KEY_ASM_VERSION);
2159     json_builder_begin_object(builder);
2160     json_builder_set_member_name(builder, _JSON_KEY_MAJOR);
2161     json_builder_add_int_value(builder, _VERSION_MAJOR);
2162     json_builder_set_member_name(builder, _JSON_KEY_MINOR);
2163     json_builder_add_int_value(builder, _VERSION_MINOR);
2164     json_builder_end_object(builder);
2165
2166     /*authenticatorIndex*/
2167     json_builder_set_member_name(builder, _JSON_KEY_AUTH_INDEX);
2168     int auth_index_int = -1;
2169     sscanf(auth_index, "%d", &auth_index_int);
2170     json_builder_add_int_value(builder, auth_index_int);
2171
2172
2173     /*requestType : "GetRegistrations" */
2174     json_builder_set_member_name(builder, _JSON_KEY_REQ_TYPE);
2175     json_builder_add_string_value(builder, _JSON_KEY_GET_REGS);
2176
2177
2178     json_builder_end_object(builder);
2179
2180     JsonNode *root_builder = json_builder_get_root(builder);
2181     JsonGenerator *gen = json_generator_new();
2182     json_generator_set_root(gen, root_builder);
2183
2184     json_node_free(root_builder);
2185     g_object_unref(builder);
2186
2187     gsize len = 0;
2188     char *json = json_generator_to_data(gen, &len);
2189
2190     if (json != NULL)
2191         _INFO("%s", json);
2192
2193     g_object_unref(gen);
2194     return json;
2195 }
2196
2197 int
2198 _convert_asm_status_code_to_uaf_error(int asm_status_code)
2199 {
2200     switch (asm_status_code) {
2201
2202     case _ASM_STATUS_OK:
2203         return FIDO_ERROR_NONE;
2204
2205     case _ASM_STATUS_ERROR:
2206         return FIDO_ERROR_UNKNOWN;
2207
2208     case _ASM_STATUS_ACCESS_DENIED:
2209         return FIDO_ERROR_PERMISSION_DENIED;
2210
2211     case _ASM_STATUS_USER_CANCELLED:
2212         return FIDO_ERROR_USER_CANCELLED;
2213
2214     default:
2215         return FIDO_ERROR_UNKNOWN;
2216     }
2217 }
2218
2219 /*
2220 {
2221     "vendor" : "Samsung Electronics",
2222     "bin_path" : "/usr/bin/fido-asm",
2223     "dbus_info" : "org.tizen.fido_uaf_asm.server",
2224     "dbus_obj_path" : "/org/tizen/fido_uaf_asm/server",
2225     "dbus_interface_name" : "org.tizen.fido_uaf_asm.server.interface",
2226     "dbus_method_name" : "asm_request"
2227 }
2228 */
2229
2230 _fido_asm_proxy_t*
2231 _parse_asm_conf_file(const char *file_name)
2232 {
2233     _INFO("_parse_asm_conf_file");
2234
2235     RET_IF_FAIL(file_name != NULL, NULL);
2236
2237     JsonParser *parser = json_parser_new();
2238
2239     _fido_asm_proxy_t *proxy = NULL;
2240     GError *err = NULL;
2241     gboolean is_parsed = json_parser_load_from_file(parser, file_name, &err);
2242     CATCH_IF_FAIL(is_parsed == TRUE);
2243
2244     JsonNode *root = json_parser_get_root(parser);
2245     CATCH_IF_FAIL(root != NULL);
2246
2247     JsonObject *root_obj = json_node_get_object(root);
2248     CATCH_IF_FAIL(root_obj != NULL);
2249
2250     const char *vendor = json_object_get_string_member(root_obj, _JSON_KEY_VENDOR);
2251     CATCH_IF_FAIL(vendor != NULL);
2252
2253     const char *bin_path = json_object_get_string_member(root_obj, _JSON_KEY_BIN_PATH);
2254     CATCH_IF_FAIL(bin_path != NULL);
2255
2256     const char *dbus_info = json_object_get_string_member(root_obj, _JSON_KEY_DBUS_INFO);
2257     CATCH_IF_FAIL(dbus_info != NULL);
2258
2259     const char *dbus_obj_path = json_object_get_string_member(root_obj, _JSON_KEY_DBUS_OBJ_PATH);
2260     CATCH_IF_FAIL(dbus_obj_path != NULL);
2261
2262     const char *dbus_interface_name = json_object_get_string_member(root_obj, _JSON_KEY_DBUS_INTF_NAME);
2263     CATCH_IF_FAIL(dbus_interface_name != NULL);
2264
2265     const char *dbus_method_name = json_object_get_string_member(root_obj, _JSON_KEY_DBUS_METHOD_NAME);
2266     CATCH_IF_FAIL(dbus_method_name != NULL);
2267
2268     proxy = calloc(1, sizeof(_fido_asm_proxy_t));
2269
2270     proxy->vendor = strdup(vendor);
2271     proxy->bin_path = strdup(bin_path);
2272     proxy->dbus_info = strdup(dbus_info);
2273     proxy->dbus_obj_path = strdup(dbus_obj_path);
2274     proxy->dbus_interface_name = strdup(dbus_interface_name);
2275     proxy->dbus_method_name = strdup(dbus_method_name);
2276
2277 CATCH:
2278     g_object_unref(parser);
2279     return proxy;
2280 }